Feature/code cleanup (#16)

* code cleanup

* fixed takeWhile to return correct results

* fixed skipWhile to return correct results

* fixed skip to return the proper results

* increased test coverage

* Update package.json

gulpfile.js

@@ -9,7 +9,7 @@ var del = require("del");
 var webpack = require("webpack");
 var gutil = require('gulp-util');
 
-gulp.task('default', ['minify']);
+gulp.task('default', ['build']);
 
 gulp.task('clean', function() 
 {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "asenumerable",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "a JavaScript library that provides linq functions on native JavaScript arrays",
   "dependencies": {},
   "main": "src/enumerable.js",

spec/enumerable.js

@@ -0,0 +1,28 @@
+var Enumerable = require('../src/enumerable');
+
+describe("Enumerable", function ()
+{
+    describe("when initialized from an empty array", function ()
+    {
+        it("should return an empty enumerable object", function ()
+        {
+            var testArray = [];
+
+            var result = new Enumerable(testArray);
+
+            expect(result).toEqual(new Enumerable([]));
+        });
+    });
+
+    describe("when initialized from a null array", function ()
+    {
+        it("should return an empty enumerable object", function ()
+        {
+            var testArray = null;
+
+            var result = new Enumerable(testArray);
+
+            expect(result).toEqual(new Enumerable([]));
+        });
+    });
+});

spec/skip.js

@@ -0,0 +1,52 @@
+var Enumerable = require('../src/enumerable');
+
+describe("skip", function ()
+{
+    describe("when an enumerable object has 3 items", function ()
+    {
+        it("should skip specified number of items and return the remaining items", function ()
+        {
+            var testArray = new Enumerable([{ name: 'test', id: 1 }, { name: '1234', id: 2 }, { name: '5678', id: 3 }]);
+
+            var result = testArray.skip(2);
+
+            expect(result).toEqual(new Enumerable([{ name: '5678', id: 3 }]));
+        });
+    });
+
+    describe("when an enumerable object has multiple items", function ()
+    {
+        it("should skip specified number of items and return the remaining items", function ()
+        {
+            var testArray = new Enumerable([98, 92, 85, 82, 70, 59, 56]);
+
+            var result = testArray.skip(3);
+
+            expect(result).toEqual(new Enumerable([82, 70, 59, 56]));
+        });
+    });
+
+    describe("when an enumerable object is empty", function ()
+    {
+        it("should return empty enumerable", function ()
+        {
+            var testArray = new Enumerable([]);
+
+            var result = testArray.skip(2);
+
+            expect(result).toEqual(new Enumerable([]));
+        });
+    });
+
+    describe("when count is a greater integer than the length of the enumerable object", function ()
+    {
+        it("should return current enumerable", function ()
+        {
+            var testArray = new Enumerable([{ name: 'test', id: 1 }, { name: '1234', id: 2 }, { name: '5678', id: 3 }]);
+
+            var result = testArray.skip(50);
+
+            expect(result).toEqual(testArray);
+        });
+    });
+});

spec/skipWhile.js

@@ -2,24 +2,51 @@
 
 describe("skip while", function ()
 {
-    describe("when an enumerable object has 3 items", function ()
+    describe("when an enumerable object has multiple items", function ()
     {
-        it("should skip items that match a predicate function and return the others", function ()
+        it("should return everything after the item where the predicate function evaluated to false", function ()
         {
-            var testArray = new Enumerable([{ name: 'test', id: 1 }, { name: '1234', id: 2 }, { name: '5678', id: 3 }]);
+            var testArray = new Enumerable([{ name: 'test', id: 1 }, { name: '1234', id: 2 }, { name: '5678', id: 3 }, { name: '9012', id: 4 }]);
 
             var result = testArray.skipWhile(function (i, item, collection)
             {
-                return (item.name === "test");
+                return (item.id < 3);
+            });
+
+            expect(result).toEqual(new Enumerable([{ name: '5678', id: 3 }, { name: '9012', id: 4 }]));
+        });
+    });
+
+    describe("when an enumerable object has multiple numbers", function ()
+    {
+        it("should return everything after the item where the predicate function evaluated to false", function ()
+        {
+            var testArray = new Enumerable([98, 92, 85, 82, 70, 59, 56]);
+
+            var result = testArray.skipWhile(function (i, item, collection)
+            {
+                return (item >= 80);
             });
 
-            expect(result).toEqual(new Enumerable([{ name: '1234', id: 2 }, { name: '5678', id: 3 }]));
+            expect(result).toEqual(new Enumerable([70, 59, 56]));
+        });
+    });
+
+    describe("when no function is passed", function ()
+    {
+        it("should return the collection", function ()
+        {
+            var testArray = new Enumerable([98, 92, 85, 82, 70, 59, 56]);
+
+            var result = testArray.skipWhile();
+
+            expect(result).toEqual(testArray);
         });
     });
 
     describe("when an enumerable object has 1 item", function ()
     {
-        it("should skips items that match a predicate function and return the others", function ()
+        it("should return everything after the item where the predicate function evaluated to false", function ()
         {
             var testArray = new Enumerable([{ name: 'test', id: 1 }]);
 
@@ -46,4 +73,23 @@ describe("skip while", function ()
             expect(result).toEqual(new Enumerable([]));
         });
     });
+
+    describe("when an enumerable object has multiple items and the predicate return true midway through the collection", function ()
+    {
+        it("should return everything after the item where the predicate function evaluated to false", function ()
+        {
+            var testArray = new Enumerable([{ name: 'test', id: 1 }, { name: '1234', id: 2 }, { name: '5678', id: 3 }]);
+
+            var result = testArray.skipWhile(function (i, item, collection)
+            {
+                return (item.id < 3);
+            });
+
+            expect(result).toEqual(new Enumerable([{ name: '5678', id: 3 }]));
+        });
+    });
+
+    //skip while >= 80
+    //98, 92, 85, 82, 70, 59, 56
+    //returns 70, 59, 56
 });