move code to this repo

Author: manzoid

.eslintrc.js

@@ -0,0 +1,30 @@
+module.exports = {
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    },
+    "globals": {
+        "describe": false,
+        "expect": false,
+        "it": false
+    }
+};

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -1 +1,30 @@
-# underbar
+# Underbar
+
+This repo is a clone of the open-source project called Underscore.
+
+[Underscore](http://underscorejs.org/) is a popular JavaScript library that supplies utility functions that facilitates programming in a more functional style.
+
+Underscore has been around for nearly 8 years, and in that time, a lot of its facilities [have been subsumed into ES6](https://www.reindex.io/blog/you-might-not-need-underscore/).
+
+However, we think there's considerable learning value to you closely examining a simplified implementation of Underscore.
+
+This is a complete implementation, including tests.
+
+## Running individual tests
+
+Note that the `jest-cli` package was also installed into this repo, with the command:
+
+```
+npm install --save-dev jest-cli
+```
+
+This should allow you to use this syntax to just run one test file:
+
+```
+npm test isArrayLike
+```
+
+That will do a partial match on the string and find the matching test and run it.
+
+This can save you some time as you are writing the tests, as opposed to executing the entire test suite on every run.
+

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "underbar",
+  "version": "1.0.0",
+  "description": "",
+  "scripts": {
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tim-hr/underbar.git"
+  },
+  "author": "manzoid <manzoid@gmail.com>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tim-hr/underbar/issues"
+  },
+  "homepage": "https://github.com/tim-hr/underbar#readme",
+  "devDependencies": {
+    "jest": "^19.0.2",
+    "jest-cli": "^19.0.2"
+  }
+}

test/contains.test.js

@@ -0,0 +1,34 @@
+const _ = require('../underbar');
+
+describe('contains()', () => {
+  it('returns true if an array contains the target', () => {
+    const nums = [1, 2, 3, 4, 5];
+    expect(_.contains(nums, 4)).toBe(true);
+  });
+
+  it('returns false if an array does not contain the target', () => {
+    const nums = [1, 2, 3, 4, 5];
+    expect(_.contains(nums, 7)).toBe(false);
+  });
+
+  it('returns true if the target value is among the values of an object', () => {
+    const ponies = {
+      'pony1': 'Fluttershy',
+      'pony2': 'Pinkie Pie',
+      'pony3': 'Rainbow Dash',
+      'pony4': 'Rarity'
+    };
+    expect(_.contains(ponies, 'Rarity')).toBe(true);
+  });
+
+  it('returns false if the target value is not among the values of an object', () => {
+    const ponies = {
+      'pony1': 'Fluttershy',
+      'pony2': 'Pinkie Pie',
+      'pony3': 'Rainbow Dash',
+      'pony4': 'Rarity'
+    };
+    expect(_.contains(ponies, 'Applejack')).toBe(false);
+  });
+
+});

test/each.test.js

@@ -0,0 +1,43 @@
+const _ = require('../underbar');
+
+describe('each()', () => {
+  it('iterates every element of an array, passing that element, its corresponding index, and the entire array to the callback', () => {
+    const arr = ['a', 'b', 'c'];
+    let count = 0;
+    _.each(arr, function(element, index, array) {
+      expect(element).toEqual(array[index]);
+      count += 1;
+    });
+    expect(count).toBe(3);
+  });
+
+  it('iterates every element of an array-like object, passing that element, its corresponding index, and the entire array to the callback', () => {
+    const arrayLikeObj = {
+      length: 3,
+      1: 'a',
+      2: 'b',
+      3: 'c'
+    };
+    let count = 0;
+    _.each(arrayLikeObj, function(element, index, iteratedArrayLikeObj) {
+      expect(element).toEqual(iteratedArrayLikeObj[index]);
+      count += 1;
+    });
+    expect(count).toBe(3);
+  });
+
+  it('iterates every property of an object, passing the value, the corresponding key, and the entire object to the callback', () => {
+    const obj = {
+      name: 'Calvin',
+      age: 6,
+      occupation: 'student'
+    };
+    let count = 0;
+    _.each(obj, function(value, key, iteratedObj) {
+      expect(value).toEqual(iteratedObj[key]);
+      count += 1;
+    });
+    expect(count).toBe(3);
+  });
+});
+

test/every.test.js

@@ -0,0 +1,21 @@
+const _ = require('../underbar');
+
+describe('every()', () => {
+  describe('processing an array of numbers', () => {
+    it('will return true if no callback is supplied', () => {
+      const nums = [1, 3, 5, 7];
+      expect(_.every(nums)).toBe(true);
+    });
+
+    it('returns true if all numbers in an array are odd and we test for odd numbers', () => {
+      const nums = [1, 3, 5, 7];
+      expect(_.every(nums, num => num % 2 === 1)).toBe(true);
+    });
+
+    it('returns false if not all numbers in an array are odd and we test for odd numbers', () => {
+      const nums = [1, 3, 5, 6, 7];
+      expect(_.every(nums, num => num % 2 === 1)).toBe(false);
+    });
+
+  });
+});

test/filter.test.js

@@ -0,0 +1,26 @@
+const _ = require('../underbar');
+
+describe('filter()', () => {
+  it('filters an array to odd numbers', () => {
+    const nums = [2, 4, 5, 6, 7, 8, 10, 11];
+    expect(_.filter(nums, num => num % 2 === 1)).toEqual([5, 7, 11]);
+  });
+
+  it('filters an object to only numeric values', () => {
+    const characterAttributes = {
+      name: 'Thokul Mongothsbeard',
+      honorific: 'Lord Thokul Mongothsbeard the Arcane',
+      race: 'human',
+      class: 'druid',
+      strength: 4,
+      constitution: 7,
+      dexterity: 10,
+      intelligence: 16,
+      wisdom: 5,
+      charisma: 4
+    };
+
+    const abilityScores = _.filter(characterAttributes, (value) => !isNaN(value));
+    expect(abilityScores).toEqual([4, 7, 10, 16, 5, 4]);
+  });
+});

test/first.test.js

@@ -0,0 +1,15 @@
+const _ = require('../underbar');
+
+describe('first()', () => {
+  it('returns the first element of an array', () => {
+    expect(_.first(['a', 'b', 'c'])).toEqual('a');
+  });
+
+  it('returns the first 2 elements of an array', () => {
+    expect(_.first(['a', 'b', 'c'], 2)).toEqual(['a', 'b']);
+  });
+
+  it('returns the whole array if you ask for more elements than it has', () => {
+    expect(_.first(['a', 'b', 'c'], 5)).toEqual(['a', 'b', 'c']);
+  });
+});

test/identity.test.js

@@ -0,0 +1,23 @@
+const _ = require('../underbar');
+
+describe('identity()', () => {
+  it('returns null if given null', () => {
+    expect(_.identity(null)).toBe(null);
+  });
+
+  it('returns the number if given a number', () => {
+    expect(_.identity(5)).toBe(5);
+  });
+
+  it('returns the same array if given an array', () => {
+    const val = [1, 2, 3];
+    expect(_.identity(val)).toBe(val);
+  });
+
+  it('returns the same object if given an object', () => {
+    const val = {
+      'foo': 'bar'
+    };
+    expect(_.identity(val)).toBe(val);
+  });
+});

test/indexOf.test.js

@@ -0,0 +1,29 @@
+const _ = require('../underbar');
+
+describe('indexOf()', () => {
+  it('returns the index of a value at the beginning of an array', () => {
+    const arr = ['foo', 'bar', 'baz'];
+    expect(_.indexOf(arr, 'foo')).toBe(0);
+  });
+
+  it('returns the index of a value at the end of an array', () => {
+    const arr = ['foo', 'bar', 'baz'];
+    expect(_.indexOf(arr, 'baz')).toBe(2);
+  });
+
+  it('returns -1 for a missing value', () => {
+    const arr = ['foo', 'bar', 'baz'];
+    expect(_.indexOf(arr, 'quux')).toBe(-1);
+  });
+
+  it('returns the first matching index when multiple matches in array', () => {
+    const arr = ['foo', 'bar', 'baz', 'bar', 'bar'];
+    expect(_.indexOf(arr, 'bar')).toBe(1);
+  });
+
+  it('starts searching at the given offset', () => {
+    const arr = ['foo', 'bar', 'baz', 'bar', 'bar'];
+    expect(_.indexOf(arr, 'bar', 2)).toBe(3);
+  });
+
+});

test/isArrayLike.test.js

@@ -0,0 +1,21 @@
+const _ = require('../underbar');
+
+describe('isArrayLike()', () => {
+  it('returns true for an actual array', () => {
+    expect(_.isArrayLike([1, 2, 3])).toBe(true);
+  });
+
+  it('returns true for an array-like object', () => {
+    const arrayLikeObj = {
+      length: 10
+    };
+    expect(_.isArrayLike(arrayLikeObj)).toBe(true);
+  });
+
+  it('returns false for a non-array-like object', () => {
+    const nonArrayLikeObj = {
+      'foo': 'bar'
+    };
+    expect(_.isArrayLike(nonArrayLikeObj)).toBe(false);
+  });
+});

test/last.test.js

@@ -0,0 +1,15 @@
+const _ = require('../underbar');
+
+describe('last()', () => {
+  it('returns the last element of an array', () => {
+    expect(_.last(['a', 'b', 'c'])).toEqual('c');
+  });
+
+  it('returns the last 2 elements of an array', () => {
+    expect(_.last(['a', 'b', 'c'], 2)).toEqual(['b', 'c']);
+  });
+
+  it('returns the whole array if you ask for more elements than it has', () => {
+    expect(_.last(['a', 'b', 'c'], 5)).toEqual(['a', 'b', 'c']);
+  });
+});

test/map.test.js

@@ -0,0 +1,9 @@
+_ = require('../underbar');
+
+describe('map()', () => {
+  it('maps every numbers in an array of numbers to their square', () => {
+    const arr = [1, 2, 3, 4, 5];
+    const mappedArr = _.map(arr, (el) => el * el);
+    expect(mappedArr).toEqual([1, 4, 9, 16, 25]);
+  });
+});

test/pluck.test.js

@@ -0,0 +1,14 @@
+const _ = require('../underbar');
+
+describe('pluck()', () => {
+  it('returns an array of just ages, given an array of people objects', () => {
+    const people = [
+      { name: 'Harriet', age: 12},
+      { name: 'Lazarus', age: 999},
+      { name: 'Bethany', age: 14}
+    ];
+    const result = _.pluck(people, 'age');
+    expect(result).toEqual([12, 999, 14]);
+  });
+
+});

test/reduce.test.js

@@ -0,0 +1,16 @@
+const _ = require('../underbar');
+
+describe('reduce()', () => {
+  it('reduces an array of numbers to a sum, *with* an explicit initial value for the accumulator', () => {
+    const nums = [1, 2, 3, 4, 5];
+    const result = _.reduce(nums, (acc, num) => acc + num, 0);
+    expect(result).toEqual(15);
+  });
+
+  it('reduces an array of numbers to a sum, *without* an explicit initial value for the accumulator', () => {
+    const nums = [1, 2, 3, 4, 5];
+    const result = _.reduce(nums, (a, b) => a + b);
+    expect(result).toEqual(15);
+  });
+
+});