Initial import

Author: eprunier

README

@@ -0,0 +1,3 @@
+# exercism-javascript
+
+[Exercism](http://exercism.io)'s **Javascript** track

hello-world/README.md

@@ -0,0 +1,144 @@
+# Hello World
+
+The classical introductory exercise. Just say "Hello, World!"
+
+["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
+the traditional first program for beginning programming in a new language
+or environment.
+
+The objectives are simple:
+
+- Write a function that returns the string "Hello, World!".
+- Run the test suite and make sure that it succeeds.
+- Submit your solution and check it at the website.
+
+If everything goes well, you will be ready to fetch your first real exercise.
+
+## Tutorial
+
+This exercise has two files:
+
+- hello-world.js
+- hello-world.spec.js
+
+The first file is where you will write your code.
+The second is where the tests are defined.
+
+The tests will check whether your code is doing the right thing.
+You don't need to be able to write a test suite from scratch,
+but it helps to understand what a test looks like, and what
+it is doing.
+
+Open up the test file, hello-world.spec.js.
+It has three tests defined in it.
+
+This is the first test:
+
+    it('says hello world with no name', function() {
+      expect(helloWorld.hello('')).toEqual('Hello, World!');
+    });
+
+Run the test now, with the following command on the command-line:
+
+    jasmine-node .
+
+The test fails, which makes sense since you've not written any code yet.
+
+The failure looks like this:
+
+    1) Hello World says hello world with no name
+       Message:
+          Expected undefined to equal 'Hello, World!'.
+
+There's more, but this is the most important part.
+
+Take a look at that first line:
+
+    1) Hello World says hello world with no name
+
+Now look at the test definition again:
+
+    it('says hello world with no name', function() {
+      // ... more code here ...
+    });
+
+The text 'says hello world with no name' is repeated.
+This is how you know which test failed.
+
+The failure message explains what is wrong:
+
+    Expected undefined to equal 'Hello, World!'.
+
+This comes from the part of the test definition that says "expect":
+
+    expect(helloWorld.hello('')).toEqual('Hello, World!');
+
+It's comparing two values. It is calling
+
+    helloWorld.hello('')
+
+and comparing the result to a hard-coded string.
+
+    'Hello, World!'.
+
+So if you look at the failure message again, the hello function
+is returning undefined.
+
+Try changing the function in hello-world.js so that it says
+
+    HelloWorld.prototype.hello = function(input) {
+        return "chocolate";
+    };
+
+Then run the tests again from the command-line:
+
+    jasmine-node .
+
+Notice how it changes the failure message.
+
+Then change the implementation in hello-world.js again, this time to make the test pass.
+
+Once the test is passing, look at the second test in hello-world.spec.js. It looks like this:
+
+    xit('says hello to bob', function() {
+      expect(helloWorld.hello('Bob')).toEqual('Hello, Bob!');
+    });
+
+This test starts with `xit` instead of `it`.
+That means that when jasmine-node runs the tests,
+the test will be skipped.
+
+Change the test so that it starts with `it`,
+and run the tests again.
+
+Make the test pass, and then do the same with the third test.
+
+When you are done, submit your solution to exercism:
+
+    exercism submit hello-world.js
+
+## Setup
+
+Go through the setup instructions for JavaScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/javascript
+
+## Making the Test Suite Pass
+
+Execute the tests with:
+
+    jasmine-node .
+
+In many test suites all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+changing `xit` to `it`.
+
+## Source
+
+This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

hello-world/hello-world.js

@@ -0,0 +1,14 @@
+//
+// This is a stub file for the 'Hello World' exercise. It's been provided as a
+// convenience to get you started writing code faster.
+// Make sure to look at hello-world.spec.js--that should give you some hints about what is
+// expected here.
+
+var HelloWorld = function() {};
+
+HelloWorld.prototype.hello = function(input) {
+	const name = input ? input : 'World';
+	return `Hello, ${name}!`;
+};
+
+module.exports = HelloWorld;

hello-world/hello-world.spec.js

@@ -0,0 +1,17 @@
+var HelloWorld = require('./hello-world');
+
+describe('Hello World', function() {
+  var helloWorld = new HelloWorld();
+
+  it('says hello world with no name', function() {
+    expect(helloWorld.hello('')).toEqual('Hello, World!');
+  });
+
+  it('says hello to bob', function() {
+    expect(helloWorld.hello('Bob')).toEqual('Hello, Bob!');
+  });
+
+  it('says hello to sally', function() {
+    expect(helloWorld.hello('Sally')).toEqual('Hello, Sally!');
+  });
+});

leap/HINT.md

@@ -0,0 +1,52 @@
+This is the first test for this exercise:
+
+```javascript
+  it('is not very common', function() {
+    var year = new Year(2015);
+    expect(year.isLeap()).toBe(false);
+  });
+```
+
+Each test in the exercise follows the same pattern: 
+
+  1. A new Year is instantiated with a value and stored in a variable: year.
+  2. The test calls an instance method, isLeap(), from the variable `year`.
+
+The `Year` function is a constructor, which means that it is specifically designed to provide a template for new objects.
+
+When a new `Year` object is created:
+
+```javascript
+  var year = new Year(2015);
+```
+
+We expect `year` to, at the very least, have a specific value (in this case 2015) assigned to it.  Otherwise it would not represent an actual year.
+
+This means that we must store the value passed as a parameter when the new `Year` is created (2015), so that the new `Year` can access it.
+
+The way a constructor stores these fundamental values (instance variables) is like this:
+
+```javascript
+  var Constructor = function(input) {
+    this.value = input;
+  };
+```
+
+The `this` in the constructor refers to the newly created instance of the `Constructor`.
+
+Once the input (parameter) is stored in an instance variable, any instance methods, such as:
+
+```javascript
+  Constructor.prototype.instanceMethod = function() {
+    // this method can now access the input by calling `this.value`
+  };
+```
+
+The instance method accesses the input using `this.value` (in this example).
+
+This is why code needs to be written in two separate functions:
+
+  1. The first function, `Year`, is a constructor that serves as a template for year objects that are created with their value (such as 2015).
+     This function needs to store the input when a new `Year` is created.
+  2. The second function, isLeap(), is an instance method that is called from a new `year`. 
+     This function (method) should contain the logic to determine if the given year is a leap year.

leap/README.md

@@ -0,0 +1,53 @@
+# Leap
+
+Given a year, report if it is a leap year.
+
+The tricky thing here is that a leap year in the Gregorian calendar occurs:
+
+```plain
+on every year that is evenly divisible by 4
+  except every year that is evenly divisible by 100
+    unless the year is also evenly divisible by 400
+```
+
+For example, 1997 is not a leap year, but 1996 is.  1900 is not a leap
+year, but 2000 is.
+
+If your language provides a method in the standard library that does
+this look-up, pretend it doesn't exist and implement it yourself.
+
+## Notes
+
+Though our exercise adopts some very simple rules, there is more to
+learn!
+
+For a delightful, four minute explanation of the whole leap year
+phenomenon, go watch [this youtube video][video].
+
+[video]: http://www.youtube.com/watch?v=xX96xng7sAE
+
+## Setup
+
+Go through the setup instructions for JavaScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/javascript
+
+## Making the Test Suite Pass
+
+Execute the tests with:
+
+    jasmine-node .
+
+In many test suites all but the first test have been skipped.
+
+Once you get a test passing, you can unskip the next one by
+changing `xit` to `it`.
+
+## Source
+
+JavaRanch Cattle Drive, exercise 3 [http://www.javaranch.com/leap.jsp](http://www.javaranch.com/leap.jsp)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

leap/leap.js

@@ -0,0 +1,18 @@
+//
+// This is only a SKELETON file for the "Leap" exercise. It's been provided as a
+// convenience to get you started writing code faster.
+//
+
+var Year = function(input) {
+	this.year = input;
+};
+
+Year.prototype.isDivisibleBy = function (divider) {
+	return this.year % divider === 0;
+};
+
+Year.prototype.isLeap = function() {
+	return this.isDivisibleBy(4) && !this.isDivisibleBy(100) || this.isDivisibleBy(400);
+};
+
+module.exports = Year;

leap/leap.spec.js

@@ -0,0 +1,50 @@
+var Year = require('./leap');
+
+describe('Leap year', function() {
+
+  it('is not very common', function() {
+    var year = new Year(2015);
+    expect(year.isLeap()).toBe(false);
+  });
+
+  it('is introduced every 4 years to adjust about a day', function() {
+    var year = new Year(2016);
+    expect(year.isLeap()).toBe(true);
+  });
+
+  it('is skipped every 100 years to remove an extra day', function() {
+    var year = new Year(1900);
+    expect(year.isLeap()).toBe(false);
+  });
+
+  it('is reintroduced every 400 years to adjust another day', function() {
+    var year = new Year(2000);
+    expect(year.isLeap()).toBe(true);
+  });
+
+  // Feel free to enable the following tests to check some more examples
+  describe('Additional example of a leap year that', function () {
+
+    it('is not a leap year', function () {
+      var year = new Year(1978);
+      expect(year.isLeap()).toBe(false);
+    });
+
+    it('is a common leap year', function () {
+      var year = new Year(1992);
+      expect(year.isLeap()).toBe(true);
+    });
+
+    it('is skipped every 100 years', function () {
+      var year = new Year(2100);
+      expect(year.isLeap()).toBe(false);
+    });
+
+    it('is reintroduced every 400 years', function () {
+      var year = new Year(2400);
+      expect(year.isLeap()).toBe(true);
+    });
+
+  });
+
+});