Merge remote-tracking branch 'upstream/master'

Conflicts:
	seamless-immutable.development.js
	seamless-immutable.development.min.js
	seamless-immutable.production.min.js
	src/seamless-immutable.js
	test/Immutable.spec.js

Author: davidblurton

README.md

@@ -155,6 +155,20 @@ Immutable(new Square(2), {prototype: Square.prototype}).area();
 
 Beyond [the usual Object fare](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object#Methods_of_Object_instances), the following methods have been added.
 
+### Stack overflow protection
+
+Currently you can't construct Immutable from an object with circular references. To protect from ugly stack overflows, we provide a simple protection during development. We stop at a suspiciously deep stack level and [show an error message][deep].
+
+If your objects are deep, but not circular, you can increase this level from default `64`. For example:
+
+```javascript
+Immutable(deepObject, null, 256);
+```
+
+This check is not performed in the production build.
+
+[deep]: https://github.com/rtfeldman/seamless-immutable/wiki/Deeply-nested-object-was-detected
+
 ### merge
 
 ```javascript
@@ -199,6 +213,34 @@ Immutable({type: {main: "parrot", sub: "Norwegian Blue"}, status: "alive"}).setI
 // returns Immutable({type: {main: "parrot", sub: "Norwegian Ridgeback"}, status: "alive"})
 ```
 
+### update
+
+Returns an Immutable Object with a single property updated using the provided updater function.
+
+```javascript
+function inc (x) { return x + 1 }
+Immutable({foo: 1}).update("foo", inc)
+// returns Immutable({foo: 2})
+```
+
+All additional arguments will be passed to the updater function.
+
+```javascript
+function add (x, y) { return x + y }
+Immutable({foo: 1}).update("foo", add, 10)
+// returns Immutable({foo: 11})
+```
+
+### updateIn
+
+Like [update](#update), but accepts a nested path to the property.
+
+```javascript
+function add (x, y) { return x + y }
+Immutable({foo: {bar: 1}}).updateIn(["foo", "bar"], add, 10)
+// returns Immutable({foo: {bar: 11}})
+```
+
 ### without
 
 ```javascript
@@ -234,6 +276,14 @@ Returns a mutable copy of the object. For a deeply mutable copy, in which any in
 
 ### Releases
 
+#### 6.0.0
+
+Add cycle detection.
+
+#### 5.2.0
+
+Add `update` and `updateIn`.
+
 #### 5.1.1
 
 `Immutable(Object.create(null))` now works as expected.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "seamless-immutable",
-  "version": "5.1.1",
+  "version": "6.0.0",
   "description": "Immutable data structures for JavaScript which are backwards-compatible with normal JS Arrays and Objects.",
   "main": "src/seamless-immutable.js",
   "devDependencies": {

seamless-immutable.development.js

@@ -155,6 +155,8 @@
     addPropertyTo(array, "asMutable", asMutableArray);
     addPropertyTo(array, "set", arraySet);
     addPropertyTo(array, "setIn", arraySetIn);
+    addPropertyTo(array, "update", update);
+    addPropertyTo(array, "updateIn", updateIn);
 
     for(var i = 0, length = array.length; i < length; i++) {
       array[i] = Immutable(array[i]);
@@ -434,6 +436,28 @@
     return makeImmutableObject(mutable, this);
   }
 
+  function update(property, updater) {
+    var restArgs = Array.prototype.slice.call(arguments, 2);
+    var initialVal = this[property];
+    return this.set(property, updater.apply(initialVal, [initialVal].concat(restArgs)));
+  }
+
+  function getInPath(obj, path) {
+    /*jshint eqnull:true */
+    for (var i = 0, l = path.length; obj != null && i < l; i++) {
+      obj = obj[path[i]];
+    }
+
+    return (i && i == l) ? obj : undefined;
+  }
+
+  function updateIn(path, updater) {
+    var restArgs = Array.prototype.slice.call(arguments, 2);
+    var initialVal = getInPath(this, path);
+
+    return this.setIn(path, updater.apply(initialVal, [initialVal].concat(restArgs)));
+  }
+
   function asMutableObject(opts) {
     var result = this.instantiateEmptyObject(), key;
 
@@ -471,6 +495,8 @@
     addPropertyTo(obj, "instantiateEmptyObject", instantiateEmptyObject);
     addPropertyTo(obj, "set", objectSet);
     addPropertyTo(obj, "setIn", objectSetIn);
+    addPropertyTo(obj, "update", update);
+    addPropertyTo(obj, "updateIn", updateIn);
 
     return makeImmutable(obj, mutatingObjectMethods);
   }
@@ -483,7 +509,7 @@
            (obj.$$typeof === REACT_ELEMENT_TYPE_FALLBACK || obj.$$typeof === REACT_ELEMENT_TYPE);
   }
 
-  function Immutable(obj, options) {
+  function Immutable(obj, options, stackRemaining) {
     if (isImmutable(obj) || isReactElement(obj)) {
       return obj;
     } else if (obj instanceof Array) {
@@ -498,9 +524,22 @@
           instantiatePlainObject : (function() { return Object.create(prototype); });
       var clone = instantiateEmptyObject();
 
+      if ("development" !== "production") {
+        /*jshint eqnull:true */
+        if (stackRemaining == null) {
+          stackRemaining = 64;
+        }
+        if (stackRemaining <= 0) {
+          throw new ImmutableError("Attempt to construct Immutable from a deeply nested object was detected." +
+            " Have you tried to wrap an object with circular references (e.g. React element)?" +
+            " See https://github.com/rtfeldman/seamless-immutable/wiki/Deeply-nested-object-was-detected for details.");
+        }
+        stackRemaining -= 1;
+      }
+
       for (var key in obj) {
         if (Object.getOwnPropertyDescriptor(obj, key)) {
-          clone[key] = Immutable(obj[key]);
+          clone[key] = Immutable(obj[key], undefined, stackRemaining);
         }
       }