entangled 0.0.9 → 0.0.10

data/spec/dummy/public/Gruntfile.js

@@ -0,0 +1,30 @@
+// Created with the help of
+// http://paislee.io/testing-angularjs-with-grunt-karma-and-jasmine/
+
+module.exports = function(grunt) {
+
+  grunt.loadNpmTasks('grunt-karma');
+
+  grunt.initConfig({
+    karma: {  
+      unit: {
+        options: {
+          frameworks: ['jasmine'],
+          singleRun: true,
+          browsers: ['Chrome'], // 'PhantomJS'
+          files: [
+            'bower_components/angular/angular.js',
+            'bower_components/angular-route/angular-route.js',
+            'bower_components/angular-mocks/angular-mocks.js',
+            'app/**/*.js',
+            'test/**/*.js'
+          ]
+        }
+      }
+    }
+  });
+
+  grunt.registerTask('test', [  
+    'karma'
+  ]);
+};

data/spec/dummy/public/app/app.js

@@ -0,0 +1,20 @@
+'use strict';
+
+angular.module('entangledTest', [
+  'ngRoute',
+  'entangled'
+])
+
+.config(function($routeProvider) {
+  $routeProvider
+    .when('/', {
+      templateUrl: 'views/messages/index.html',
+      controller: 'MessagesCtrl'
+    }).when('/messages/:id', {
+      templateUrl: 'views/messages/show.html',
+      controller: 'MessageCtrl'
+    })
+    .otherwise({
+      redirectTo: '/'
+    });
+})

data/spec/dummy/public/app/controllers/message.js

@@ -0,0 +1,16 @@
+'use strict';
+
+angular.module('entangledTest')
+
+.controller('MessageCtrl', function($scope, $routeParams, Message) {
+  $scope.update = function() {
+    $scope.message.$save();
+  };
+
+  Message.find($routeParams.id, function(message) {
+    $scope.$apply(function() {
+      $scope.message = message;
+      console.log('Show callback called!');
+    });
+  });
+});

data/spec/dummy/public/app/controllers/messages.js

@@ -0,0 +1,23 @@
+'use strict';
+
+angular.module('entangledTest')
+
+.controller('MessagesCtrl', function($scope, Message) {
+  $scope.message = Message.new();
+
+  $scope.create = function() {
+    $scope.message.$save(function() {
+      $scope.message = Message.new();
+    });
+  };
+
+  $scope.destroy = function(message) {
+    message.$destroy();
+  };
+
+  Message.all(function(messages) {
+    $scope.$apply(function() {
+      $scope.messages = messages;
+    });
+  });
+});

data/spec/dummy/public/app/entangled/entangled.js

@@ -0,0 +1,191 @@
+// Register Angular module and call it 'entangled'
+angular.module('entangled', [])
+
+// Register service and call it 'Entangled'
+.factory('Entangled', function() {
+  // Every response coming from the server will be wrapped
+  // in a Resource constructor to represent a CRUD-able
+  // resource that can be saved and destroyed using the
+  // methods $save() and $destroy. A Resource also
+  // stores the socket's URL it was retrieved from so it
+  // can be reused for other requests.
+  var Resource = function(params, webSocketUrl) {
+    // Assign proerties
+    for (var key in params) {
+      // Skip inherent object properties
+      if (params.hasOwnProperty(key)) {
+        this[key] = params[key];
+      }
+    }
+
+    this.webSocketUrl = webSocketUrl;
+  };
+
+  // $save() will send a request to the server
+  // to either create a new record or update
+  // an existing, depending on whether or not
+  // an id is present.
+  Resource.prototype.$save = function(callback) {
+    var that = this;
+
+    if (this.id) {
+      // Update
+      var socket = new WebSocket(that.webSocketUrl + '/' + that.id + '/update');
+      socket.onopen = function() {
+        socket.send(JSON.stringify(that));
+
+        if (callback) callback();
+      };
+    } else {
+      // Create
+      var socket = new WebSocket(that.webSocketUrl + '/create');
+
+      socket.onopen = function() {
+        socket.send(JSON.stringify(that));
+
+        if (callback) callback();
+      };
+    }
+  };
+
+  // $destroy() will send a request to the server to
+  // destroy an existing record.
+  Resource.prototype.$destroy = function(callback) {
+    var socket = new WebSocket(this.webSocketUrl + '/' + this.id + '/destroy');
+    socket.onopen = function() {
+      // It's fine to send an empty message since the
+      // socket's URL contains all the information
+      // needed to destroy the record (the id).
+      socket.send(null);
+
+      if (callback) callback();
+    };
+  };
+
+  // Resources wraps all individual Resource objects
+  // in a collection.
+  var Resources = function(resources, webSocketUrl) {
+    this.all = [];
+
+    for (var i = 0; i < resources.length; i++) {
+      var resource = new Resource(resources[i], webSocketUrl);
+      this.all.push(resource);
+    }
+  };
+
+  // Entangled is the heart of this service. It contains
+  // several methods to instantiate a new Resource,
+  // retrieve an existing Resource from the server,
+  // and retrieve a collection of existing Resources
+  // from the server.
+  // 
+  // Entangled is a constructor that takes the URL
+  // of the index action on the server where the
+  // Resources can be retrieved.
+  var Entangled = function(webSocketUrl) {
+    // Store the root URL that sockets
+    // will connect to
+    this.webSocketUrl = webSocketUrl;
+  };
+
+  // Function to instantiate a new Resource, optionally
+  // with given parameters
+  Entangled.prototype.new = function(params) {
+    return new Resource(params, this.webSocketUrl);
+  };
+
+  // Retrieve all Resources from the root of the socket's
+  // URL
+  Entangled.prototype.all = function(callback) {
+    var socket = new WebSocket(this.webSocketUrl);
+
+    socket.onmessage = function(event) {
+      // If the message from the server isn't empty
+      if (event.data.length) {
+        // Convert message to JSON
+        var data = JSON.parse(event.data);
+
+        // If the collection of Resources was sent
+        if (data.resources) {
+          // Store retrieved Resources in property
+          this.resources = new Resources(data.resources, socket.url);
+        } else if (data.action) {
+          if (data.action === 'create') {
+            // If new Resource was created, add it to the
+            // collection
+            this.resources.all.push(new Resource(data.resource, socket.url));
+          } else if (data.action === 'update') {
+            // If an existing Resource was updated,
+            // update it in the collection as well
+            var index;
+
+            for (var i = 0; i < this.resources.all.length; i++) {
+              if (this.resources.all[i].id === data.resource.id) {
+                index = i;
+              }
+            }
+
+            this.resources.all[index] = new Resource(data.resource, socket.url);
+          } else if (data.action === 'destroy') {
+            // If a Resource was destroyed, remove it
+            // from Resources as well
+            var index;
+
+            for (var i = 0; i < this.resources.all.length; i++) {
+              if (this.resources.all[i].id === data.resource.id) {
+                index = i;
+              }
+            }
+
+            this.resources.all.splice(index, 1);
+          } else {
+            console.log('Something else other than CRUD happened...');
+            console.log(data);
+          }
+        }
+      }
+
+      // Run the callback and pass in the
+      // resulting collection
+      callback(this.resources.all);
+    };
+  };
+
+  // Find an individual Resource on the server
+  Entangled.prototype.find = function(id, callback) {
+    var webSocketUrl = this.webSocketUrl;
+    var socket = new WebSocket(webSocketUrl + '/' + id);
+
+    socket.onmessage = function(event) {
+      // If the message from the server isn't empty
+      if (event.data.length) {
+        // Parse message and convert to JSON
+        var data = JSON.parse(event.data);
+
+        if (data.resource && !data.action) {
+          // If the Resource was sent from the server,
+          // store it
+          this.resource = new Resource(data.resource, webSocketUrl);
+        } else if (data.action) {
+          if (data.action === 'update') {
+            // If the stored Resource was updated,
+            // update it here as well
+            this.resource = new Resource(data.resource, webSocketUrl);
+          } else if (data.action === 'destroy') {
+            // If the stored Resource was destroyed,
+            // remove it from here as well
+            this.resource = undefined;
+          }
+        } else {
+          console.log('Something else other than CRUD happened...');
+          console.log(data);
+        }
+      }
+
+      // Run callback with retrieved Resource
+      callback(this.resource);
+    };
+  };
+
+  return Entangled;
+});

data/spec/dummy/public/app/services/message.js

@@ -0,0 +1,21 @@
+'use strict';
+
+angular.module('entangledTest')
+
+.factory('Message', function(Entangled) {
+  var entangled = new Entangled('ws://localhost:3000/messages');
+
+  var Message = {
+    new: function(params) {
+      return entangled.new(params);
+    },
+    all: function(callback) {
+      return entangled.all(callback);
+    },
+    find: function(id, callback) {
+      return entangled.find(id, callback);
+    }
+  };
+
+  return Message;
+});

data/spec/dummy/public/bower.json

@@ -0,0 +1,22 @@
+{
+  "name": "dummy",
+  "version": "0.0.0",
+  "homepage": "https://github.com/dchacke/entangled",
+  "authors": [
+    "Dennis Charles Hackethal <dennis.hackethal@gmail.com>"
+  ],
+  "license": "MIT",
+  "private": true,
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "dependencies": {
+    "angular-route": "~1.3.14",
+    "angular": "~1.3.14",
+    "angular-mocks": "~1.3.14"
+  }
+}

data/spec/dummy/public/bower_components/angular-route/README.md

@@ -14,21 +14,12 @@ You can install this package either with `npm` or with `bower`.
 npm install angular-route
 ```
 
-Add a `<script>` to your `index.html`:
-
-```html
-<script src="/node_modules/angular-route/angular-route.js"></script>
-```
-
 Then add `ngRoute` as a dependency for your app:
 
 ```javascript
-angular.module('myApp', ['ngRoute']);
+angular.module('myApp', [require('angular-route')]);
 ```
 
-Note that this package is not in CommonJS format, so doing `require('angular-route')` will
-return `undefined`.
-
 ### bower
 
 ```shell
@@ -56,7 +47,7 @@ Documentation is available on the
 
 The MIT License
 
-Copyright (c) 2010-2012 Google, Inc. http://angularjs.org
+Copyright (c) 2010-2015 Google, Inc. http://angularjs.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/spec/dummy/public/bower_components/angular-route/angular-route.js

@@ -1,5 +1,5 @@
 /**
- * @license AngularJS v1.3.13
+ * @license AngularJS v1.3.14
  * (c) 2010-2014 Google, Inc. http://angularjs.org
  * License: MIT
  */

data/spec/dummy/public/bower_components/angular-route/angular-route.min.js

@@ -1,5 +1,5 @@
 /*
- AngularJS v1.3.13
+ AngularJS v1.3.14
  (c) 2010-2014 Google, Inc. http://angularjs.org
  License: MIT
 */

data/spec/dummy/public/bower_components/angular-route/bower.json

@@ -1,9 +1,9 @@
 {
   "name": "angular-route",
-  "version": "1.3.13",
+  "version": "1.3.14",
   "main": "./angular-route.js",
   "ignore": [],
   "dependencies": {
-    "angular": "1.3.13"
+    "angular": "1.3.14"
   }
 }

data/spec/dummy/public/bower_components/angular-route/package.json

@@ -1,8 +1,8 @@
 {
   "name": "angular-route",
-  "version": "1.3.13",
+  "version": "1.3.14",
   "description": "AngularJS router module",
-  "main": "angular-route.js",
+  "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

data/spec/dummy/public/bower_components/angular/README.md

@@ -20,10 +20,7 @@ Then add a `<script>` to your `index.html`:
 <script src="/node_modules/angular/angular.js"></script>
 ```
 
-Note that this package is not in CommonJS format, so doing `require('angular')` will return `undefined`.
-If you're using [Browserify](https://github.com/substack/node-browserify), you can use
-[exposify](https://github.com/thlorenz/exposify) to have `require('angular')` return the `angular`
-global.
+Or `require('angular')` from your code.
 
 ### bower
 
@@ -46,7 +43,7 @@ Documentation is available on the
 
 The MIT License
 
-Copyright (c) 2010-2012 Google, Inc. http://angularjs.org
+Copyright (c) 2010-2015 Google, Inc. http://angularjs.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/spec/dummy/public/bower_components/angular/angular.js

@@ -1,5 +1,5 @@
 /**
- * @license AngularJS v1.3.13
+ * @license AngularJS v1.3.14
  * (c) 2010-2014 Google, Inc. http://angularjs.org
  * License: MIT
  */
@@ -54,7 +54,7 @@ function minErr(module, ErrorConstructor) {
       return match;
     });
 
-    message = message + '\nhttp://errors.angularjs.org/1.3.13/' +
+    message = message + '\nhttp://errors.angularjs.org/1.3.14/' +
       (module ? module + '/' : '') + code;
     for (i = 2; i < arguments.length; i++) {
       message = message + (i == 2 ? '?' : '&') + 'p' + (i - 2) + '=' +
@@ -2121,11 +2121,11 @@ function toDebugString(obj) {
  * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
  */
 var version = {
-  full: '1.3.13',    // all of these placeholder strings will be replaced by grunt's
+  full: '1.3.14',    // all of these placeholder strings will be replaced by grunt's
   major: 1,    // package task
   minor: 3,
-  dot: 13,
-  codeName: 'meticulous-riffleshuffle'
+  dot: 14,
+  codeName: 'instantaneous-browserification'
 };
 
 
@@ -17854,20 +17854,23 @@ var htmlAnchorDirective = valueFn({
  *
  * @description
  *
- * We shouldn't do this, because it will make the button enabled on Chrome/Firefox but not on IE8 and older IEs:
+ * This directive sets the `disabled` attribute on the element if the
+ * {@link guide/expression expression} inside `ngDisabled` evaluates to truthy.
+ *
+ * A special directive is necessary because we cannot use interpolation inside the `disabled`
+ * attribute.  The following example would make the button enabled on Chrome/Firefox
+ * but not on older IEs:
+ *
  * ```html
- * <div ng-init="scope = { isDisabled: false }">
- *  <button disabled="{{scope.isDisabled}}">Disabled</button>
+ * <div ng-init="isDisabled = false">
+ *  <button disabled="{{isDisabled}}">Disabled</button>
  * </div>
  * ```
  *
- * The HTML specification does not require browsers to preserve the values of boolean attributes
- * such as disabled. (Their presence means true and their absence means false.)
+ * This is because the HTML specification does not require browsers to preserve the values of
+ * boolean attributes such as `disabled` (Their presence means true and their absence means false.)
  * If we put an Angular interpolation expression into such an attribute then the
  * binding information would be lost when the browser removes the attribute.
- * The `ngDisabled` directive solves this problem for the `disabled` attribute.
- * This complementary directive is not removed by the browser and so provides
- * a permanent reliable place to store the binding information.
  *
  * @example
     <example>
@@ -17886,7 +17889,7 @@ var htmlAnchorDirective = valueFn({
  *
  * @element INPUT
  * @param {expression} ngDisabled If the {@link guide/expression expression} is truthy,
- *     then special attribute "disabled" will be set on the element
+ *     then the `disabled` attribute will be set on the element
  */
 
 
@@ -19888,7 +19891,7 @@ function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
     return value;
   });
 
-  if (attr.min || attr.ngMin) {
+  if (isDefined(attr.min) || attr.ngMin) {
     var minVal;
     ctrl.$validators.min = function(value) {
       return ctrl.$isEmpty(value) || isUndefined(minVal) || value >= minVal;
@@ -19904,7 +19907,7 @@ function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
     });
   }
 
-  if (attr.max || attr.ngMax) {
+  if (isDefined(attr.max) || attr.ngMax) {
     var maxVal;
     ctrl.$validators.max = function(value) {
       return ctrl.$isEmpty(value) || isUndefined(maxVal) || value <= maxVal;
@@ -22710,6 +22713,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
       ngModelGet = parsedNgModel,
       ngModelSet = parsedNgModelAssign,
       pendingDebounce = null,
+      parserValid,
       ctrl = this;
 
   this.$$setOptions = function(options) {
@@ -22982,16 +22986,12 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     // the model although neither viewValue nor the model on the scope changed
     var modelValue = ctrl.$$rawModelValue;
 
-    // Check if the there's a parse error, so we don't unset it accidentially
-    var parserName = ctrl.$$parserName || 'parse';
-    var parserValid = ctrl.$error[parserName] ? false : undefined;
-
     var prevValid = ctrl.$valid;
     var prevModelValue = ctrl.$modelValue;
 
     var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid;
 
-    ctrl.$$runValidators(parserValid, modelValue, viewValue, function(allValid) {
+    ctrl.$$runValidators(modelValue, viewValue, function(allValid) {
       // If there was no change in validity, don't update the model
       // This prevents changing an invalid modelValue to undefined
       if (!allowInvalid && prevValid !== allValid) {
@@ -23009,12 +23009,12 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
   };
 
-  this.$$runValidators = function(parseValid, modelValue, viewValue, doneCallback) {
+  this.$$runValidators = function(modelValue, viewValue, doneCallback) {
     currentValidationRunId++;
     var localValidationRunId = currentValidationRunId;
 
     // check parser error
-    if (!processParseErrors(parseValid)) {
+    if (!processParseErrors()) {
       validationDone(false);
       return;
     }
@@ -23024,21 +23024,22 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     }
     processAsyncValidators();
 
-    function processParseErrors(parseValid) {
+    function processParseErrors() {
       var errorKey = ctrl.$$parserName || 'parse';
-      if (parseValid === undefined) {
+      if (parserValid === undefined) {
         setValidity(errorKey, null);
       } else {
-        setValidity(errorKey, parseValid);
-        if (!parseValid) {
+        if (!parserValid) {
           forEach(ctrl.$validators, function(v, name) {
             setValidity(name, null);
           });
           forEach(ctrl.$asyncValidators, function(v, name) {
             setValidity(name, null);
           });
-          return false;
         }
+        // Set the parse error last, to prevent unsetting it, should a $validators key == parserName
+        setValidity(errorKey, parserValid);
+        return parserValid;
       }
       return true;
     }
@@ -23133,7 +23134,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   this.$$parseAndValidate = function() {
     var viewValue = ctrl.$$lastCommittedViewValue;
     var modelValue = viewValue;
-    var parserValid = isUndefined(modelValue) ? undefined : true;
+    parserValid = isUndefined(modelValue) ? undefined : true;
 
     if (parserValid) {
       for (var i = 0; i < ctrl.$parsers.length; i++) {
@@ -23159,7 +23160,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
     // Pass the $$lastCommittedViewValue here, because the cached viewValue might be out of date.
     // This can happen if e.g. $setViewValue is called from inside a parser
-    ctrl.$$runValidators(parserValid, modelValue, ctrl.$$lastCommittedViewValue, function(allValid) {
+    ctrl.$$runValidators(modelValue, ctrl.$$lastCommittedViewValue, function(allValid) {
       if (!allowInvalid) {
         // Note: Don't check ctrl.$valid here, as we could have
         // external validators (e.g. calculated on the server),
@@ -23280,6 +23281,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     // TODO(perf): why not move this to the action fn?
     if (modelValue !== ctrl.$modelValue) {
       ctrl.$modelValue = ctrl.$$rawModelValue = modelValue;
+      parserValid = undefined;
 
       var formatters = ctrl.$formatters,
           idx = formatters.length;
@@ -23292,7 +23294,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
         ctrl.$viewValue = ctrl.$$lastCommittedViewValue = viewValue;
         ctrl.$render();
 
-        ctrl.$$runValidators(undefined, modelValue, viewValue, noop);
+        ctrl.$$runValidators(modelValue, viewValue, noop);
       }
     }
 
@@ -24108,6 +24110,55 @@ var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interp
  * when keys are deleted and reinstated.
  *
  *
+ * # Tracking and Duplicates
+ *
+ * When the contents of the collection change, `ngRepeat` makes the corresponding changes to the DOM:
+ *
+ * * When an item is added, a new instance of the template is added to the DOM.
+ * * When an item is removed, its template instance is removed from the DOM.
+ * * When items are reordered, their respective templates are reordered in the DOM.
+ *
+ * By default, `ngRepeat` does not allow duplicate items in arrays. This is because when
+ * there are duplicates, it is not possible to maintain a one-to-one mapping between collection
+ * items and DOM elements.
+ *
+ * If you do need to repeat duplicate items, you can substitute the default tracking behavior
+ * with your own using the `track by` expression.
+ *
+ * For example, you may track items by the index of each item in the collection, using the
+ * special scope property `$index`:
+ * ```html
+ *    <div ng-repeat="n in [42, 42, 43, 43] track by $index">
+ *      {{n}}
+ *    </div>
+ * ```
+ *
+ * You may use arbitrary expressions in `track by`, including references to custom functions
+ * on the scope:
+ * ```html
+ *    <div ng-repeat="n in [42, 42, 43, 43] track by myTrackingFunction(n)">
+ *      {{n}}
+ *    </div>
+ * ```
+ *
+ * If you are working with objects that have an identifier property, you can track
+ * by the identifier instead of the whole object. Should you reload your data later, `ngRepeat`
+ * will not have to rebuild the DOM elements for items it has already rendered, even if the
+ * JavaScript objects in the collection have been substituted for new ones:
+ * ```html
+ *    <div ng-repeat="model in collection track by model.id">
+ *      {{model.name}}
+ *    </div>
+ * ```
+ *
+ * When no `track by` expression is provided, it is equivalent to tracking by the built-in
+ * `$id` function, which tracks items by their identity:
+ * ```html
+ *    <div ng-repeat="obj in collection track by $id(obj)">
+ *      {{obj.prop}}
+ *    </div>
+ * ```
+ *
  * # Special repeat start and end points
  * To repeat a series of elements instead of just one parent element, ngRepeat (as well as other ng directives) supports extending
  * the range of the repeater by defining explicit start and end points by using **ng-repeat-start** and **ng-repeat-end** respectively.
@@ -24175,12 +24226,12 @@ var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interp
  *
  *     For example: `(name, age) in {'adam':10, 'amalie':12}`.
  *
- *   * `variable in expression track by tracking_expression` – You can also provide an optional tracking function
- *     which can be used to associate the objects in the collection with the DOM elements. If no tracking function
- *     is specified the ng-repeat associates elements by identity in the collection. It is an error to have
- *     more than one tracking function to resolve to the same key. (This would mean that two distinct objects are
- *     mapped to the same DOM element, which is not possible.)  Filters should be applied to the expression,
- *     before specifying a tracking expression.
+ *   * `variable in expression track by tracking_expression` – You can also provide an optional tracking expression
+ *     which can be used to associate the objects in the collection with the DOM elements. If no tracking expression
+ *     is specified, ng-repeat associates elements by identity. It is an error to have
+ *     more than one tracking expression value resolve to the same key. (This would mean that two distinct objects are
+ *     mapped to the same DOM element, which is not possible.)  If filters are used in the expression, they should be
+ *     applied before the tracking expression.
  *
  *     For example: `item in items` is equivalent to `item in items track by $id(item)`. This implies that the DOM elements
  *     will be associated by item identity in the array.