feat: stop diffing internally; lean on mocha

See: https://mochajs.org/#diffs
Closes: #38

package.json

@@ -24,11 +24,7 @@
       ]
     }
   },
-  "browser": {
-    "diff": "./lib/diff-stub.js"
-  },
   "dependencies": {
-    "diff": "^3.3.0",
     "lodash": "^4.6.1"
   },
   "devDependencies": {

src/assertive.js

@@ -40,9 +40,6 @@ let assert;
 // eslint-disable-next-line global-require
 const _ = global._ || require('lodash');
 
-// may be stubbed out for browsers
-const jsDiff = require('diff');
-
 const toString = Object.prototype.toString;
 
 let green = x => `\x1B[32m${x}\x1B[39m`;
@@ -55,11 +52,13 @@ if (!(global.process && process.stdout && process.stdout.isTTY)) {
   clear = '';
 }
 
-function error(message, explanation) {
+function error(message, explanation, errProps) {
   if (explanation != null) {
     message = `Assertion failed: ${explanation}\n${clear}${message}`;
   }
-  return new Error(message);
+  const err = new Error(message);
+  if (errProps) _.assign(err, errProps);
+  return err;
 }
 
 function nameNegative(name) {
@@ -290,7 +289,8 @@ const assertSync = {
       throw error(
         `Expected: ${green(stringify(expected))}\nActually: ` +
           `${red(stringify(actual))}`,
-        explanation
+        explanation,
+        { actual, expected }
       );
     }
   },
@@ -322,22 +322,10 @@ ${red(wrongLooks)}`,
         `deepEqual ${green(rightLooks)} failed on something that\n` +
         'serializes to the same result (likely some function)';
     } else {
-      const values = jsDiff.diffJson(actual, expected).map(entry => {
-        let value = entry.value;
-        let prefix = '  ';
-        if (entry.added) prefix = '+ ';
-        else if (entry.removed) prefix = '- ';
-        value = value.replace(/^/gm, prefix).replace(/\n..$/, '');
-        if (entry.added) value = green(value);
-        else if (entry.removed) value = red(value);
-        return value;
-      });
-      message = `Actual: ${red('-')} Expected: ${green('+')}\n${values.join(
-        '\n'
-      )}`;
+      message = `Expected: ${wrongLooks} to deepEqual ${rightLooks}`;
     }
 
-    throw error(message, explanation);
+    throw error(message, explanation, { expected, actual });
   },
 
   include(needle, haystack) {

test/assertive.test.js

@@ -258,7 +258,9 @@ describe('equal', () => {
   });
 
   it('errors out when passed two non-identical values', () => {
-    throws(() => equal(0, 1));
+    const err = throws(() => equal(0, 1));
+    equal(0, err.expected);
+    equal(1, err.actual);
     throws(() => equal({}, {}));
     throws(() => equal(null, undefined));
     throws(() => equal(false, 0));
@@ -370,8 +372,15 @@ describe('deepEqual', () => {
   });
 
   it('diffs Actual and Expected values', () => {
-    const err = throws(() => deepEqual({ b: 2, a: 1 }, { b: 3, a: 1 }));
-    match(/"a": 1,\n.*- {3}"b": 3.*\n.*\+ {3}"b": 2/, err.message);
+    const expected = { b: 2, a: 1 };
+    const actual = { b: 3, a: 1 };
+    const err = throws(() => deepEqual(expected, actual));
+    match(
+      /^Expected: [\s\S]+"b": 3[\s\S]+ to deepEqual[\s\S]+"b": 2/,
+      err.message
+    );
+    equal(expected, err.expected);
+    equal(actual, err.actual);
   });
 });