trackler 2.1.0.48 → 2.1.0.49

data/tracks/javascript/exercises/hello-world/HINTS.md

@@ -14,12 +14,10 @@ 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.
+There is one test inside:
 
-This is the first test:
-
-    it('says hello world with no name', function() {
-      expect(helloWorld.hello('')).toEqual('Hello, World!');
+    it('says hello world', function() {
+      expect(helloWorld.hello()).toEqual('Hello, World!');
     });
 
 Run the test now, with the following command on the command-line:
@@ -30,7 +28,7 @@ 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
+    1) Hello World says hello world 
        Message:
           Expected undefined to equal 'Hello, World!'.
 
@@ -38,16 +36,16 @@ 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
+    1) Hello World says hello world 
 
 Now look at the test definition again:
 
-    it('says hello world with no name', function() {
+    it('says hello world', function() {
       // ... more code here ...
     });
 
-The text 'says hello world with no name' is repeated.
-This is how you know which test failed.
+The text 'says hello world' is repeated.
+This is how you know the test failed.
 
 The failure message explains what is wrong:
 
@@ -55,11 +53,11 @@ The failure message explains what is wrong:
 
 This comes from the part of the test definition that says "expect":
 
-    expect(helloWorld.hello('')).toEqual('Hello, World!');
+    expect(helloWorld.hello()).toEqual('Hello, World!');
 
 It's comparing two values. It is calling
 
-    helloWorld.hello('')
+    helloWorld.hello()
 
 and comparing the result to a hard-coded string.
 
@@ -82,21 +80,6 @@ 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 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

data/tracks/javascript/exercises/hello-world/hello-world.js

@@ -6,7 +6,7 @@
 
 var HelloWorld = function() {};
 
-HelloWorld.prototype.hello = function(input) {
+HelloWorld.prototype.hello = function() {
 //
 // YOUR CODE GOES HERE
 //

data/tracks/javascript/exercises/hello-world/hello-world.spec.js

@@ -3,15 +3,7 @@ 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!');
-  });
-
-  xit('says hello to bob', function() {
-    expect(helloWorld.hello('Bob')).toEqual('Hello, Bob!');
-  });
-
-  xit('says hello to sally', function() {
-    expect(helloWorld.hello('Sally')).toEqual('Hello, Sally!');
+  it('says hello world', function() {
+    expect(helloWorld.hello()).toEqual('Hello, World!');
   });
 });

data/tracks/javascript/exercises/phone-number/example.js

@@ -8,12 +8,12 @@ var Phone = module.exports = function Phone(number) {
 Phone.prototype.cleanNumber = function(number) {
   var num = number.replace(/\D/g,'');
 
-  if (num.length === 10) {
+  if (num.length === 10 && num[0]>=2&& num[3]>=2) {
     return num;
   } else if (num.length === 11 && num[0] === '1') {
     return num.substr(1,num.length);
   } else {
-    return '0000000000';
+    return null;
   }
 };
 

data/tracks/javascript/exercises/phone-number/phone-number.spec.js

@@ -1,58 +1,63 @@
 var PhoneNumber = require('./phone-number');
 
 describe('PhoneNumber()', function() {
-  it('cleans the number (123) 456-7890', function() {
-    var phone = new PhoneNumber('(123) 456-7890');
-    expect(phone.number()).toEqual('1234567890');
+  it('cleans the number', function() {
+    var phone = new PhoneNumber('(223) 456-7890');
+    expect(phone.number()).toEqual('2234567890');
   });
 
   xit('cleans numbers with dots', function() {
-    var phone = new PhoneNumber('123.456.7890');
-    expect(phone.number()).toEqual('1234567890');
+    var phone = new PhoneNumber('223.456.7890');
+    expect(phone.number()).toEqual('2234567890');
   });
 
-  xit('cleans some other number with dots', function() {
-    var phone = new PhoneNumber('555.456.7890');
-    expect(phone.number()).toEqual('5554567890');
+  xit('cleans numbers with multiple spaces', function() {
+    var phone = new PhoneNumber('223 456   7890   ');
+    expect(phone.number()).toEqual('2234567890');
   });
-
-  xit('valid when 11 digits and first digit is 1', function() {
-    var phone = new PhoneNumber('11234567890');
-    expect(phone.number()).toEqual('1234567890');
-  });
-
-  xit('invalid when 11 digits and the first digit is NOT 1', function() {
-    var phone = new PhoneNumber('2  1234567890');
-    expect(phone.number()).toEqual('0000000000');
-  });
-
-  xit('invalid when 12 digits', function() {
-    var phone = new PhoneNumber('991234567890');
-    expect(phone.number()).toEqual('0000000000');
-  });
-
+  
   xit('invalid when 9 digits', function() {
     var phone = new PhoneNumber('123456789');
-    expect(phone.number()).toEqual('0000000000');
-  });
-
-  xit('has an area code', function() {
-    var phone = new PhoneNumber('1234567890');
-    expect(phone.areaCode()).toEqual('123');
-  });
-
-  xit('has some other area code', function() {
-    var phone = new PhoneNumber('5554567890');
-    expect(phone.areaCode()).toEqual('555');
-  });
-
-  xit('formats a number', function() {
-    var phone = new PhoneNumber('1234567890');
-    expect(phone.toString()).toEqual('(123) 456-7890');
-  });
-
-  xit('formats some other number', function() {
-    var phone = new PhoneNumber('5554567890');
-    expect(phone.toString()).toEqual('(555) 456-7890');
-  });
+    expect(phone.number()).toEqual(null);
+  });
+  
+  xit('invalid when 11 digits does not start with a 1', function(){
+    var phone = new PhoneNumber('22234567890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
+  
+  xit('valid when 11 digits and starting with 1', function(){
+    var phone = new PhoneNumber('12234567890'); 
+    expect(phone.number()).toEqual('2234567890'); 
+  }); 
+  
+  xit('valid when 11 digits and starting with 1 even with punctuation', function(){
+    var phone = new PhoneNumber('+1 (223) 456-7890'); 
+    expect(phone.number()).toEqual('2234567890'); 
+  }); 
+  
+  xit('invalid when more than 11 digits', function(){
+    var phone = new PhoneNumber('321234567890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
+  
+  xit('invalid with letters', function(){
+    var phone = new PhoneNumber('123-abc-7890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
+  
+  xit('invalid with punctuations', function(){
+    var phone = new PhoneNumber('123-@:!-7890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
+  
+  xit('invalid if area code does not start with 2-9', function(){
+    var phone = new PhoneNumber('(123) 456-7890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
+  
+  xit('invalid if exchange code does not start with 2-9', function(){
+    var phone = new PhoneNumber('(223) 056-7890'); 
+    expect(phone.number()).toEqual(null); 
+  }); 
 });

data/tracks/javascript/exercises/simple-linked-list/example.js

@@ -0,0 +1,119 @@
+function Element (value, next) {
+  if (!(this instanceof Element)) {
+    throw new Error('Element is a constructor.');
+  }
+
+  if (value === undefined) {
+    throw new Error('Value required.');
+  }
+
+  if (next !== undefined && !(next instanceof Element)) {
+    throw new Error('A Element instance as next value is required.');
+  }
+
+  this.value = value;
+  this.next = next;
+};
+
+function List () {};
+
+List.prototype.push = function (value) {
+  if (value === undefined) {
+    throw new Error('Argument required.');
+  }
+
+  var newEl = (value instanceof Element)
+    ? value
+    : new Element(value);
+
+  if (!this.head) {
+    this.head = newEl;
+    return;
+  }
+
+  var lastEl = this.head;
+  while (lastEl.next) {
+    lastEl = lastEl.next;
+  }
+
+  lastEl.next = newEl;
+};
+
+List.prototype.unshift = function (value) {
+  if (value === undefined) {
+    throw new Error('Argument required.');
+  }
+
+  var newEl = (value instanceof Element)
+    ? value
+    : new Element(value);
+
+  newEl.next = this.head;
+  this.head = newEl;
+};
+
+List.prototype.shift = function () {
+  if (!this.head) {
+    return;
+  }
+
+  this.head = this.head.next;
+};
+
+List.prototype.pop = function () {
+  if (!this.head) {
+    return;
+  }
+
+  var penultEl, lastEl = this.head;
+  while (lastEl.next) {
+    penultEl = lastEl;
+    lastEl = lastEl.next;
+  }
+
+  if (!penultEl) {
+    this.head = undefined;
+  }
+  else {
+    penultEl.next = undefined;
+  }
+};
+
+List.prototype.reverse = function () {
+  if (!this.head) {
+    return;
+  }
+
+  var current, previous;
+  while (this.head) {
+    current = this.head;
+    this.shift();
+    current.next = previous;
+    previous = current;
+  }
+
+  this.head = previous;
+};
+
+List.prototype.toArray = function () {
+  var array = [];
+
+  while (this.head) {
+    array.push(this.head.value);
+    this.shift();
+  }
+
+  return array;
+};
+
+List.fromArray = function (array) {
+  var list = new List();
+  array.forEach(function (item) {
+    list.push(new Element(item));
+  });
+
+  return list;
+};
+
+exports.List = List;
+exports.Element = Element;

data/tracks/javascript/exercises/simple-linked-list/simple-linked-list.spec.js

@@ -0,0 +1,160 @@
+var SimpleLinkedList  = require('./simple-linked-list');
+var List  = SimpleLinkedList.List;
+var Element = SimpleLinkedList.Element;
+
+describe('simple-linked-list', function () {
+
+  it('exports a List constructor', function () {
+    expect(List).toBeDefined();
+  });
+
+  xit('exports a Element constructor', function () {
+    expect(Element).toBeDefined();
+  });
+
+  describe('Element', function () {
+
+    xit('is a constructor', function () {
+      var el = new Element(1);
+      expect(el).toBeDefined();
+
+      expect(function () {
+        var el = Element(1);
+      }).toThrow();
+    });
+
+    xit('requires an argument', function () {
+      var el = new Element(1);
+      expect(el).toBeDefined();
+
+      expect(function () {
+        var el = new Element();
+      }).toThrow();
+    });
+
+    xit('has as a value', function () {
+      var el = new Element(1);
+      expect(el.value).toBe(1);
+    });
+
+    xit('reference to next is undefined by default', function () {
+      var el = new Element(1);
+      expect(el.next).toBeUndefined();
+    });
+  });
+
+  xit('accepts a reference to the next element', function () {
+    var elOne = new Element(1);
+    var elTwo = new Element(2, elOne);
+    expect(elTwo.next).toBe(elOne);
+  });
+
+  xit('requires an instance of Element as next element', function () {
+    expect(function () {
+      var el = new Element(1, true);
+      var el = new Element(1, false);
+    }).toThrow();
+    expect(function () {
+      var el = new Element(1, 'lorem ipsum');
+    }).toThrow();
+    expect(function () {
+      var el = new Element(1, []);
+    }).toThrow();
+    expect(function () {
+      var el = new Element(1, {});
+    }).toThrow();
+  });
+
+  describe('List', function () {
+
+    xit('is a constructor', function () {
+      var ll = new List();
+      expect(ll).toBeDefined();
+    });
+
+    xit('allows you to append an element', function () {
+      var ll = new List();
+      var el = new Element(1);
+      ll.push(el);
+      expect(ll.head).toBe(el);
+
+      var ll2 = new List();
+      var elOne = new Element(1);
+      var elTwo = new Element(2);
+      ll2.push(elOne);
+      ll2.push(elTwo);
+      expect(ll2.head.next).toBe(elTwo);
+    });
+
+    xit('allows you to prepend an element', function () {
+      var ll = new List();
+      var el = new Element(1);
+      ll.unshift(el);
+      expect(ll.head).toBe(el);
+
+      var ll2 = new List();
+      var elOne = new Element(1);
+      var elTwo = new Element(2);
+      ll2.unshift(elOne);
+      ll2.unshift(elTwo);
+      expect(ll2.head).toBe(elTwo);
+    });
+
+    xit('allows you to remove the first element', function () {
+      var ll = new List();
+      ll.push(new Element(1));
+      ll.shift();
+      expect(ll.head).toBeUndefined();
+
+      ll.push(new Element(2));
+      ll.push(new Element(3));
+      ll.shift();
+      expect(ll.head.value).toBe(3);
+    });
+
+    xit('allows you to remove the last element', function () {
+      var ll = new List();
+      ll.push(new Element(1));
+      ll.pop();
+      expect(ll.head).toBeUndefined();
+
+      ll.push(new Element(2));
+      ll.push(new Element(3));
+      ll.pop();
+      expect(ll.head.next).toBeUndefined();
+    });
+
+    xit('allows you to convert an array to a List', function () {
+      var ll = List.fromArray([1, 2]);
+
+      expect(ll.head.value).toBe(1);
+      expect(ll.head.next.value).toBe(2);
+    });
+
+    xit('allows you to convert a List into an array', function () {
+      var ll = new List();
+      ll.push(new Element(1));
+      ll.push(new Element(2));
+      var a = ll.toArray();
+
+      expect(a instanceof Array).toBe(true);
+      expect(a.length).toBe(2);
+      expect(a[0]).toBe(1);
+      expect(a[1]).toBe(2);
+    });
+
+    xit('allows you to reverse a List', function () {
+      var ll = new List();
+      ll.push(new Element(1));
+      ll.push(new Element(2));
+      ll.push(new Element(3));
+      ll.reverse();
+
+      expect(ll.head.value).toBe(3);
+      expect(ll.head.next.value).toBe(2);
+      expect(ll.head.next.next.value).toBe(1);
+    });
+
+  });
+
+});