Added browser support & tests. Refactored export.

Author: cerebralkungfu

Readme.md

@@ -14,18 +14,39 @@
 npm install deep-diff
 ```
 
-## Testing
-Tests are written using [vows](http://vowsjs.org/) & [should.js](https://github.com/visionmedia/should.js/) (you may need to install them). If you've installed in a development environment you can use npm to run the tests.
+## Tests
 
+Tests use [mocha](http://visionmedia.github.io/mocha/) and [expect.js](https://github.com/LearnBoost/expect.js/), so if you clone the [github repository](https://github.com/flitbit/json-ptr) you'll need to run:
+
+```bash
+npm install
 ```
-npm test deep-diff
+
+... followed by ...
+
+```bash
+npm test
+```
+
+... or ...
+
+```bash
+mocha -R spec
 ```
 
-If you intend to run the examples you'll also need [extend](https://github.com/justmoon/node-extend) and [lodash](https://github.com/bestiejs/lodash).
+### Importing
 
-## Warning!
+**nodejs**
+```javascript
+var deep = require('deep-diff')
+```
 
-I've only had time to verify its behavior in node.js. If you're working in a browser you're on your own for now.
+**browser**
+```html
+<script src="deep-diff-0.1.2.min.js"></script>
+```
+
+> In a browser, `deep-diff` defines a global variable `DeepDiff`. If there is a conflict in the global namesapce you can restore the conflicting definition and assign `deep-diff` to another variable like this: `var deep = DeepDiff.noConflict();`.
 
 ## Simple Examples
 
@@ -54,7 +75,7 @@ var rhs = {
 	}
 };
 
-var differences = diff(lhs, rhs); 
+var differences = diff(lhs, rhs);
 ```
 The code snippet above would result in the following structure describing the differences:
 ``` javascript
@@ -89,7 +110,7 @@ Differences are reported as one or more change records. Change records have the
 * `lhs` - the value on the left-hand-side of the comparison (undefined if kind === 'N')
 * `rhs` - the value on the right-hand-side of the comparison (undefined if kind === 'D')
 * `index` - when kind === 'A', indicates the array index where the change occurred
-* `item` - when kind === 'A', contains a nested change record indicating the change that occurred at the array index 
+* `item` - when kind === 'A', contains a nested change record indicating the change that occurred at the array index
 
 Change records are generated for all structural differences between `origin` and `comparand`. The methods only consider an object's own properties and array elements; those inherited from an object's prototype chain are not considered.
 
@@ -126,12 +147,13 @@ var rhs = {
 observableDiff(lhs, rhs, function (d) {
 	// Apply all changes except those to the 'name' property...
 	if (d.path.length !== 1 || d.path.join('.') !== 'name') {
-		applyChange(lhs, rhs, d);	
+		applyChange(lhs, rhs, d);
 	}
-}); 
+});
 ```
 
 ## API Documentation
+
 A standard import of `var diff = require('deep-diff')` is assumed in all of the code examples. The import results in an object having the following public properties:
 
 * `diff`           - a function that calculates the differences between two objects.

examples/performance.js

@@ -0,0 +1,65 @@
+var util = require('util')
+, diff = require('..')
+, data = require('./practice-data')
+;
+
+var cycle = -1
+, i
+, len = data.length
+, prior = {}
+, comparand
+, records
+, roll = []
+, ch
+, stat
+, stats = []
+, mark, elapsed, avg = { diff: { ttl: 0 }, apply: { ttl: 0 } }, ttl = 0
+;
+
+mark = process.hrtime();
+while(++cycle < 10) {
+	i = -1;
+	while(++i < len) {
+		stats.push(stat = { mark: process.hrtime() });
+
+		comparand = roll[i] || data[i];
+
+		stat.diff = { mark: process.hrtime() };
+		records = diff(prior, comparand);
+		stat.diff.intv = process.hrtime(stat.diff.mark);
+
+		if (records) {
+			stat.apply = { count: diff.length, mark: process.hrtime() };
+			records.forEach(function(ch) {
+				diff.applyChange(prior, comparand, ch);
+			});
+			stat.apply.intv = process.hrtime(stat.apply.mark);
+
+			prior = comparand;
+		}
+		stat.intv = process.hrtime(stat.mark);
+	}
+}
+
+function ms(intv) {
+	return (intv[0]*1e9 + intv[1]/1e6);
+}
+elapsed = ms(process.hrtime(mark));
+
+stats.forEach(function(stat) {
+	stat.elapsed = ms(stat.intv);
+	stat.diff.elapsed = ms(stat.diff.intv);
+	avg.diff.ttl += stat.diff.elapsed;
+	if (stat.apply) {
+		stat.apply.elapsed = ms(stat.apply.intv);
+		ttl += stat.apply.count;
+		avg.apply.ttl += stat.apply.elapsed;
+	}
+});
+
+avg.diff.avg = avg.diff.ttl / ttl;
+avg.apply.avg = avg.apply.ttl / ttl;
+
+console.log('Captured '.concat(stats.length, ' samples with ', ttl, ' combined differences in ', elapsed, 'ms'));
+console.log('\tavg diff: '.concat(avg.diff.avg, 'ms or ', (1 / avg.diff.avg), ' per ms'));
+console.log('\tavg apply: '.concat(avg.apply.avg, 'ms or ', (1 / avg.apply.avg), ' per ms'));