promethee 1.4.8 → 1.4.9

data/node_modules/angular-ui-sortable/test/bower_overrides.json

@@ -0,0 +1,13 @@
+{
+  "jquery-simulate": {
+    "main": "jquery.simulate.js",
+    "dependencies": {
+      "jquery": ""
+    }
+  },
+  "angular": {
+    "dependencies": {
+      "jquery": ""
+    }
+  }
+}

data/node_modules/angular-ui-sortable/test/karma.conf.js

@@ -0,0 +1,85 @@
+// Karma configuration
+// Generated on Sat Dec 28 2013 20:27:08 GMT+0100 (CET)
+
+'use strict';
+
+module.exports = function(config) {
+  var wiredep = require('wiredep');
+
+  var fs = require('fs');
+  var bowerOverrides = JSON.parse(fs.readFileSync('./test/bower_overrides.json'));
+
+  var devJSDependencies = wiredep({
+    devDependencies: true,
+    overrides: bowerOverrides
+  }).js;
+
+  config.set({
+
+    // base path, that will be used to resolve files and exclude
+    basePath: '..',
+
+
+    // frameworks to use
+    frameworks: ['jasmine'],
+
+
+    // list of files / patterns to load in the browser
+    files: devJSDependencies.concat([
+      'test/libs/jquery.simulate.dragandrevert.js',
+      'src/sortable.js',
+      'test/sortable.test-helper.js',
+      'test/sortable.test-directives.js',
+      'test/*.spec.js',
+      'test/sortable.tests.css'
+    ]),
+
+
+    // list of files to exclude
+    exclude: [
+
+    ],
+
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress', 'junit', 'growl', 'coverage'
+    reporters: ['progress'],
+
+
+    // web server port
+    port: 9876,
+
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_INFO,
+
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: false,
+
+
+    // Start these browsers, currently available:
+    // - Chrome
+    // - ChromeCanary
+    // - Firefox
+    // - Opera (has to be installed with `npm install karma-opera-launcher`)
+    // - Safari (only Mac; has to be installed with `npm install karma-safari-launcher`)
+    // - PhantomJS
+    // - IE (only Windows; has to be installed with `npm install karma-ie-launcher`)
+    browsers: ['Chrome', 'Firefox'/*, 'PhantomJS'*/],
+
+
+    // If browser does not capture in given timeout [ms], kill it
+    captureTimeout: 60000,
+
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun: false
+  });
+};

data/node_modules/angular-ui-sortable/test/libs/jquery.simulate.dragandrevert.js

@@ -0,0 +1,60 @@
+;(function($, undefined) {
+	function findCenter(elem) {
+		var offset,
+			document = $(elem.ownerDocument);
+		elem = $(elem);
+		offset = elem.offset();
+
+		return {
+			x: offset.left + elem.outerWidth() / 2 - document.scrollLeft(),
+			y: offset.top + elem.outerHeight() / 2 - document.scrollTop()
+		};
+	}
+
+	$.extend($.simulate.prototype, {
+		simulateDragAndRevert: function() {
+			var i = 0,
+				target = this.target,
+				options = this.options,
+				center = findCenter(target),
+				x = Math.floor(center.x),
+				y = Math.floor(center.y),
+				dx = options.dx || 0,
+				dy = options.dy || 0,
+				moves = options.moves || 3,
+				coord = {
+					clientX: x,
+					clientY: y
+				};
+
+			this.simulateEvent(target, "mousedown", coord);
+
+			for (; i < moves; i++) {
+				x += dx / moves;
+				y += dy / moves;
+
+				coord = {
+					clientX: Math.round(x),
+					clientY: Math.round(y)
+				};
+
+				this.simulateEvent(document, "mousemove", coord);
+			}
+
+			for (i = 0; i < moves; i++) {
+				x -= dx / moves;
+				y -= dy / moves;
+
+				coord = {
+					clientX: Math.round(x),
+					clientY: Math.round(y)
+				};
+
+				this.simulateEvent(document, "mousemove", coord);
+			}
+
+			this.simulateEvent(target, "mouseup", coord);
+			this.simulateEvent(target, "click", coord);
+		}
+	});
+})(jQuery);

data/node_modules/angular-ui-sortable/test/sortable.e2e.callbacks.attr.spec.js

@@ -0,0 +1,199 @@
+'use strict';
+
+describe('uiSortable', function() {
+
+  beforeEach(module(function($compileProvider) {
+    if (typeof $compileProvider.debugInfoEnabled === 'function') {
+      $compileProvider.debugInfoEnabled(false);
+    }
+  }));
+
+  // Ensure the sortable angular module is loaded
+  beforeEach(module('ui.sortable'));
+  beforeEach(module('ui.sortable.testHelper'));
+
+  var EXTRA_DY_PERCENTAGE, listContent, hasUndefinedProperties, beforeLiElement, afterLiElement;
+
+  beforeEach(inject(function (sortableTestHelper) {
+    EXTRA_DY_PERCENTAGE = sortableTestHelper.EXTRA_DY_PERCENTAGE;
+    listContent = sortableTestHelper.listContent;
+    hasUndefinedProperties = sortableTestHelper.hasUndefinedProperties;
+    beforeLiElement = sortableTestHelper.extraElements && sortableTestHelper.extraElements.beforeLiElement;
+    afterLiElement = sortableTestHelper.extraElements && sortableTestHelper.extraElements.afterLiElement;
+  }));
+
+  tests.description = 'Attribute Callbacks related';
+  function tests (useExtraElements) {
+
+    var host;
+
+    beforeEach(inject(function() {
+      host = $('<div id="test-host"></div>');
+      $('body').append(host);
+
+      if (!useExtraElements) {
+        beforeLiElement = afterLiElement = '';
+      }
+    }));
+
+    afterEach(function() {
+      host.remove();
+      host = null;
+    });
+
+    it('should cancel sorting of node "Two"', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        element = $compile(''.concat(
+          '<ul ui-sortable ui-sortable-update="update" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement,
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.update = function(e, ui) {
+            if (ui.item.sortable.model === 'Two') {
+              ui.item.sortable.cancel();
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        $(element).remove();
+      });
+    });
+
+    it('should call all callbacks with the proper context', function() {
+      inject(function($compile, $rootScope) {
+        var element, callbackContexts = {};
+        $rootScope.$apply(function() {
+          $rootScope.create = function() {
+            callbackContexts.create = this;
+          };
+          // $rootScope.helper = function(e, item) {
+          //   callbackContexts.helper = this;
+          //   return item;
+          // };
+          $rootScope.start = function() {
+            callbackContexts.start = this;
+          };
+          $rootScope.activate = function() {
+            callbackContexts.activate = this;
+          };
+          $rootScope.beforeStop = function() {
+            callbackContexts.beforeStop = this;
+          };
+          $rootScope.update = function() {
+            callbackContexts.update = this;
+          };
+          $rootScope.deactivate = function() {
+            callbackContexts.deactivate = this;
+          };
+          $rootScope.stop = function() {
+            callbackContexts.stop = this;
+          };
+
+          // spyOn($rootScope, 'helper').and.callThrough();
+          spyOn($rootScope, 'create').and.callThrough();
+          spyOn($rootScope, 'start').and.callThrough();
+          spyOn($rootScope, 'activate').and.callThrough();
+          spyOn($rootScope, 'beforeStop').and.callThrough();
+          spyOn($rootScope, 'update').and.callThrough();
+          spyOn($rootScope, 'deactivate').and.callThrough();
+          spyOn($rootScope, 'stop').and.callThrough();
+          $rootScope.items = ['One', 'Two', 'Three'];
+          element = $compile(''.concat(
+            '<ul ui-sortable ' +
+            'ui-sortable-create="create" ' +
+            // 'ui-sortable-helper="helper" ' +
+            'ui-sortable-start="start" ' +
+            'ui-sortable-activate="activate" ' +
+            'ui-sortable-update="update" ' +
+            'ui-sortable-before-stop="beforeStop" ' +
+            'ui-sortable-deactivate="deactivate" ' +
+            'ui-sortable-stop="stop" ' +
+            'ng-model="items">',
+            beforeLiElement,
+            '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+            afterLiElement +
+            '</ul>'))($rootScope);
+        });
+
+        host.append(element);
+
+        $rootScope.$apply(function() {
+        });
+        var li = element.find('[ng-repeat]:eq(0)');
+        var dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        expect($rootScope.create).toHaveBeenCalled();
+        // expect($rootScope.helper).toHaveBeenCalled();
+        expect($rootScope.start).toHaveBeenCalled();
+        expect($rootScope.activate).toHaveBeenCalled();
+        expect($rootScope.beforeStop).toHaveBeenCalled();
+        expect($rootScope.update).toHaveBeenCalled();
+        expect($rootScope.deactivate).toHaveBeenCalled();
+        expect($rootScope.stop).toHaveBeenCalled();
+
+        expect(callbackContexts.create).toEqual(element[0]);
+        // expect(callbackContexts.helper).toEqual(element[0]);
+        expect(callbackContexts.start).toEqual(element[0]);
+        expect(callbackContexts.activate).toEqual(element[0]);
+        expect(callbackContexts.beforeStop).toEqual(element[0]);
+        expect(callbackContexts.update).toEqual(element[0]);
+        expect(callbackContexts.deactivate).toEqual(element[0]);
+        expect(callbackContexts.stop).toEqual(element[0]);
+
+        $(element).remove();
+      });
+    });
+  }
+
+  [0, 1].forEach(function(useExtraElements){
+    var testDescription = tests.description;
+
+    if (useExtraElements) {
+      testDescription += ' with extra elements';
+    }
+
+    describe(testDescription, function(){
+      tests(useExtraElements);
+    });
+  });
+
+});

data/node_modules/angular-ui-sortable/test/sortable.e2e.callbacks.spec.js

@@ -0,0 +1,729 @@
+'use strict';
+
+describe('uiSortable', function() {
+
+  beforeEach(module(function($compileProvider) {
+    if (typeof $compileProvider.debugInfoEnabled === 'function') {
+      $compileProvider.debugInfoEnabled(false);
+    }
+  }));
+
+  // Ensure the sortable angular module is loaded
+  beforeEach(module('ui.sortable'));
+  beforeEach(module('ui.sortable.testHelper'));
+
+  var EXTRA_DY_PERCENTAGE, listContent, hasUndefinedProperties, beforeLiElement, afterLiElement;
+
+  beforeEach(inject(function (sortableTestHelper) {
+    EXTRA_DY_PERCENTAGE = sortableTestHelper.EXTRA_DY_PERCENTAGE;
+    listContent = sortableTestHelper.listContent;
+    hasUndefinedProperties = sortableTestHelper.hasUndefinedProperties;
+    beforeLiElement = sortableTestHelper.extraElements && sortableTestHelper.extraElements.beforeLiElement;
+    afterLiElement = sortableTestHelper.extraElements && sortableTestHelper.extraElements.afterLiElement;
+  }));
+
+  tests.description = 'Callbacks related';
+  function tests (useExtraElements) {
+
+    var host;
+
+    beforeEach(inject(function() {
+      host = $('<div id="test-host"></div>');
+      $('body').append(host);
+
+      if (!useExtraElements) {
+        beforeLiElement = afterLiElement = '';
+      }
+    }));
+
+    afterEach(function() {
+      host.remove();
+      host = null;
+    });
+
+    it('should cancel sorting of node "Two"', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement,
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        $(element).remove();
+      });
+    });
+
+    it('should cancel sorting of node "Two" and "helper: function" that returns an element is used', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            helper: function (e, item) {
+              return item.clone();
+            },
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        $(element).remove();
+      });
+    });
+
+    it('should cancel sorting of node "Two" when then helper is appended to the `body`', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            helper: function (e, item) {
+              return item.clone().appendTo('body');
+            },
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        $(element).remove();
+      });
+    });
+
+    it('should cancel sorting of node "Two" and "helper: function" that returns a list element is used', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            helper: function (e, item) {
+              return item;
+            },
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // try again
+        li = element.find('[ng-repeat]:eq(1)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        $(element).remove();
+      });
+    });
+
+    it('should update model from update() callback', function() {
+      inject(function($compile, $rootScope) {
+        var element, logsElement;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        logsElement = $compile(''.concat(
+          '<ul ng-model="logs">',
+          beforeLiElement,
+          '<li ng-repeat="log in logs" id="l-{{$index}}">{{ log }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            update: function(e, ui) {
+              $rootScope.logs.push('Moved element ' + ui.item.sortable.model);
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+          $rootScope.logs = [];
+        });
+
+        host.append(element).append(logsElement);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Three', 'Two']);
+        expect($rootScope.logs).toEqual(['Moved element Two']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect($rootScope.logs).toEqual(listContent(logsElement));
+
+        $(element).remove();
+        $(logsElement).remove();
+      });
+    });
+
+    // ensure scope.apply() is called after a stop() callback
+    it('should update model from stop() callback', function() {
+      inject(function($compile, $rootScope) {
+        var element, logsElement;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        logsElement = $compile(''.concat(
+          '<ul ng-model="logs">',
+          beforeLiElement,
+          '<li ng-repeat="log in logs" id="l-{{$index}}">{{ log }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            stop: function(e, ui) {
+              $rootScope.logs.push('Moved element ' + ui.item.sortable.model);
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+          $rootScope.logs = [];
+        });
+
+        host.append(element).append(logsElement);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Three', 'Two']);
+        expect($rootScope.logs).toEqual(['Moved element Two']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect($rootScope.logs).toEqual(listContent(logsElement));
+
+        $(element).remove();
+        $(logsElement).remove();
+      });
+    });
+
+    it('should call the create() callback when initialized', function() {
+      inject(function($compile, $rootScope) {
+        var element;
+        $rootScope.$apply(function() {
+          $rootScope.items = ['One', 'Two', 'Three'];
+          $rootScope.opts = {
+            create: function() {
+
+            }
+          };
+          spyOn($rootScope.opts, 'create');
+          element = $compile(''.concat(
+            '<ul ui-sortable="opts" ng-model="items">',
+            beforeLiElement,
+            '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+            afterLiElement +
+            '</ul>'))($rootScope);
+        });
+
+        host.append(element);
+
+        expect($rootScope.opts.create).toHaveBeenCalled();
+
+        $(element).remove();
+      });
+    });
+
+    it('should properly set ui.item.sortable properties', function() {
+      inject(function($compile, $rootScope) {
+        var element, updateCallbackExpectations;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+              updateCallbackExpectations(ui.item.sortable);
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        $rootScope.$apply(function() {
+        });
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        updateCallbackExpectations = function(uiItemSortable) {
+          expect(uiItemSortable.model).toEqual('Two');
+          expect(uiItemSortable.index).toEqual(1);
+          expect(uiItemSortable.source.length).toEqual(1);
+          expect(uiItemSortable.source[0]).toBe(host.children()[0]);
+          expect(uiItemSortable.sourceModel).toBe($rootScope.items);
+          expect(uiItemSortable.isCanceled()).toBe(true);
+          expect(uiItemSortable.isCustomHelperUsed()).toBe(false);
+        };
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        updateCallbackExpectations = undefined;
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        updateCallbackExpectations = function(uiItemSortable) {
+          expect(uiItemSortable.model).toEqual('One');
+          expect(uiItemSortable.index).toEqual(0);
+          expect(uiItemSortable.source.length).toEqual(1);
+          expect(uiItemSortable.source[0]).toBe(host.children()[0]);
+          expect(uiItemSortable.sourceModel).toBe($rootScope.items);
+          expect(uiItemSortable.isCanceled()).toBe(false);
+          expect(uiItemSortable.isCustomHelperUsed()).toBe(false);
+        };
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+        updateCallbackExpectations = undefined;
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        updateCallbackExpectations = function(uiItemSortable) {
+          expect(uiItemSortable.model).toEqual('One');
+          expect(uiItemSortable.index).toEqual(2);
+          expect(uiItemSortable.source.length).toEqual(1);
+          expect(uiItemSortable.source[0]).toBe(host.children()[0]);
+          expect(uiItemSortable.sourceModel).toBe($rootScope.items);
+          expect(uiItemSortable.isCanceled()).toBe(false);
+          expect(uiItemSortable.isCustomHelperUsed()).toBe(false);
+        };
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        updateCallbackExpectations = undefined;
+
+        $(element).remove();
+      });
+    });
+
+    it('should call all callbacks with the proper context', function() {
+      inject(function($compile, $rootScope) {
+        var element, callbackContexts = {};
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            helper: function(e, item) {
+              callbackContexts.helper = this;
+              return item;
+            },
+            create: function() {
+              callbackContexts.create = this;
+            },
+            start: function() {
+              callbackContexts.start = this;
+            },
+            activate: function() {
+              callbackContexts.activate = this;
+            },
+            beforeStop: function() {
+              callbackContexts.beforeStop = this;
+            },
+            update: function() {
+              callbackContexts.update = this;
+            },
+            deactivate: function() {
+              callbackContexts.deactivate = this;
+            },
+            stop: function() {
+              callbackContexts.stop = this;
+            }
+          };
+          spyOn($rootScope.opts, 'helper').and.callThrough();
+          spyOn($rootScope.opts, 'create').and.callThrough();
+          spyOn($rootScope.opts, 'start').and.callThrough();
+          spyOn($rootScope.opts, 'activate').and.callThrough();
+          spyOn($rootScope.opts, 'beforeStop').and.callThrough();
+          spyOn($rootScope.opts, 'update').and.callThrough();
+          spyOn($rootScope.opts, 'deactivate').and.callThrough();
+          spyOn($rootScope.opts, 'stop').and.callThrough();
+          $rootScope.items = ['One', 'Two', 'Three'];
+          element = $compile(''.concat(
+            '<ul ui-sortable="opts" ng-model="items">',
+            beforeLiElement,
+            '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+            afterLiElement +
+            '</ul>'))($rootScope);
+        });
+
+        host.append(element);
+
+        $rootScope.$apply(function() {
+        });
+        var li = element.find('[ng-repeat]:eq(0)');
+        var dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+
+        expect($rootScope.opts.helper).toHaveBeenCalled();
+        expect($rootScope.opts.create).toHaveBeenCalled();
+        expect($rootScope.opts.start).toHaveBeenCalled();
+        expect($rootScope.opts.activate).toHaveBeenCalled();
+        expect($rootScope.opts.beforeStop).toHaveBeenCalled();
+        expect($rootScope.opts.update).toHaveBeenCalled();
+        expect($rootScope.opts.deactivate).toHaveBeenCalled();
+        expect($rootScope.opts.stop).toHaveBeenCalled();
+
+        expect(callbackContexts.helper).toEqual(element[0]);
+        expect(callbackContexts.create).toEqual(element[0]);
+        expect(callbackContexts.start).toEqual(element[0]);
+        expect(callbackContexts.activate).toEqual(element[0]);
+        expect(callbackContexts.beforeStop).toEqual(element[0]);
+        expect(callbackContexts.update).toEqual(element[0]);
+        expect(callbackContexts.deactivate).toEqual(element[0]);
+        expect(callbackContexts.stop).toEqual(element[0]);
+
+        $(element).remove();
+      });
+    });
+
+    it('should properly free ui.item.sortable object', function() {
+      inject(function($compile, $rootScope) {
+        var element, uiItem, uiItemSortable_Destroy;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            start: function (e, ui) {
+              uiItem = ui.item;
+              spyOn(ui.item.sortable, '_destroy').and.callThrough();
+              uiItemSortable_Destroy = ui.item.sortable._destroy;
+            },
+            update: function(e, ui) {
+              if (ui.item.sortable.model === 'Two') {
+                ui.item.sortable.cancel();
+              }
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect(uiItemSortable_Destroy).toHaveBeenCalled();
+        expect(hasUndefinedProperties(uiItem.sortable)).toBe(true);
+        uiItem = uiItemSortable_Destroy = undefined;
+
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect(uiItemSortable_Destroy).toHaveBeenCalled();
+        expect(hasUndefinedProperties(uiItem.sortable)).toBe(true);
+        uiItem = uiItemSortable_Destroy = undefined;
+
+
+        li = element.find('[ng-repeat]:eq(2)');
+        dy = -(2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Two', 'Three']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect(uiItemSortable_Destroy).toHaveBeenCalled();
+        expect(hasUndefinedProperties(uiItem.sortable)).toBe(true);
+        uiItem = uiItemSortable_Destroy = undefined;
+
+        $(element).remove();
+      });
+    });
+
+    it('should provide the item.sortable properties on helper callback', function() {
+      inject(function($compile, $rootScope) {
+        var element, helperItem, itemSortable_Restore, sortableAfterRestore, helperCallbackExpectations;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            helper: function(e, item) {
+              helperItem = item;
+
+              var oldRestore = item.sortable._restore;
+              item.sortable._restore = function () {
+                oldRestore.apply(this, arguments);
+                // hold the value of the sortable object
+                // right after the _restore method completes
+                sortableAfterRestore = item.sortable;
+              };
+
+              spyOn(item.sortable, '_restore').and.callThrough();
+              itemSortable_Restore = item.sortable._restore;
+              helperCallbackExpectations(item.sortable);
+              return item.clone();
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+        });
+
+        host.append(element);
+
+        $rootScope.$apply(function() {
+        });
+
+        var li = element.find('[ng-repeat]:eq(0)');
+        var dy = (2 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        helperCallbackExpectations = function(helperItemSortable) {
+          expect(helperItemSortable.model).toEqual('One');
+          expect(helperItemSortable.index).toEqual(0);
+          expect(helperItemSortable.source.length).toEqual(1);
+          expect(helperItemSortable.source[0]).toBe(host.children()[0]);
+          expect(helperItemSortable.sourceModel).toBe($rootScope.items);
+        };
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Two', 'Three', 'One']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect(itemSortable_Restore).toHaveBeenCalled();
+        expect(hasUndefinedProperties(helperItem.sortable)).toBe(true);
+        // this happens after the update callback, so everything is udnefined
+        expect(typeof sortableAfterRestore).toBe('function');
+        helperItem = itemSortable_Restore = sortableAfterRestore = helperCallbackExpectations = undefined;
+
+        $(element).remove();
+      });
+    });
+
+    it('should properly reset a deleted callback option', function() {
+      inject(function($compile, $rootScope) {
+        var element, logsElement;
+        element = $compile(''.concat(
+          '<ul ui-sortable="opts" ng-model="items">',
+          beforeLiElement,
+          '<li ng-repeat="item in items" id="s-{{$index}}">{{ item }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        logsElement = $compile(''.concat(
+          '<ul ng-model="logs">',
+          beforeLiElement,
+          '<li ng-repeat="log in logs" id="l-{{$index}}">{{ log }}</li>',
+          afterLiElement +
+          '</ul>'))($rootScope);
+        $rootScope.$apply(function() {
+          $rootScope.opts = {
+            stop: function(e, ui) {
+              $rootScope.logs.push('Moved element ' + ui.item.sortable.model);
+            }
+          };
+          $rootScope.items = ['One', 'Two', 'Three'];
+          $rootScope.logs = [];
+        });
+
+        host.append(element).append(logsElement);
+
+        var li = element.find('[ng-repeat]:eq(1)');
+        var dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['One', 'Three', 'Two']);
+        expect($rootScope.logs).toEqual(['Moved element Two']);
+        expect($rootScope.items).toEqual(listContent(element));
+        expect($rootScope.logs).toEqual(listContent(logsElement));
+
+        $rootScope.$digest();
+          
+        $rootScope.$apply(function() {
+          $rootScope.opts = {};
+        });
+
+        li = element.find('[ng-repeat]:eq(0)');
+        dy = (1 + EXTRA_DY_PERCENTAGE) * li.outerHeight();
+        li.simulate('drag', { dy: dy });
+        expect($rootScope.items).toEqual(['Three', 'One', 'Two']);
+        expect($rootScope.items).toEqual(listContent(element));
+        // the log should be the same
+        expect($rootScope.logs).toEqual(['Moved element Two']);
+        expect($rootScope.logs).toEqual(listContent(logsElement));
+
+        $(element).remove();
+        $(logsElement).remove();
+      });
+    });
+
+  }
+
+  [0, 1].forEach(function(useExtraElements){
+    var testDescription = tests.description;
+
+    if (useExtraElements) {
+      testDescription += ' with extra elements';
+    }
+
+    describe(testDescription, function(){
+      tests(useExtraElements);
+    });
+  });
+
+});