spade 0.0.1

data/sproutcore/frameworks/core_foundation/system/utils.js

@@ -0,0 +1,151 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+// These are helpful utility functions for calculating range and rect values
+sc_require('system/browser');
+
+SC.mixin( /** @scope SC */ {
+
+  /**
+    Takes a URL of any type and normalizes it into a fully qualified URL with
+    hostname.  For example:
+
+    {{{
+      "some/path" => "http://localhost:4020/some/path"
+      "/some/path" => "http://localhost:4020/some/path"
+      "http://localhost:4020/some/path" => "http://localhost:4020/some/path"
+    }}}
+
+    @param url {String} the URL
+    @returns {String} the normalized URL
+  */
+  normalizeURL: function(url) {
+    if (url.slice(0,1) == '/') {
+      url = window.location.protocol + '//' + window.location.host + url ;
+    } else if ((url.slice(0,5) == 'http:') || (url.slice(0,6) == 'https:')) {
+      // no change
+    } else {
+      url = window.location.href + '/' + url ;
+    }
+    return url ;
+  },
+
+  /** Return true if the number is between 0 and 1 */
+  isPercentage: function(val){
+    return (val<1 && val>0);
+  },
+
+  /** Return the left edge of the frame */
+  minX: function(frame) {
+    return frame.x || 0;
+  },
+
+  /** Return the right edge of the frame. */
+  maxX: function(frame) {
+    return (frame.x || 0) + (frame.width || 0);
+  },
+
+  /** Return the midpoint of the frame. */
+  midX: function(frame) {
+    return (frame.x || 0) + ((frame.width || 0) / 2) ;
+  },
+
+  /** Return the top edge of the frame */
+  minY: function(frame) {
+    return frame.y || 0 ;
+  },
+
+  /** Return the bottom edge of the frame */
+  maxY: function(frame) {
+    return (frame.y || 0) + (frame.height || 0) ;
+  },
+
+  /** Return the midpoint of the frame */
+  midY: function(frame) {
+    return (frame.y || 0) + ((frame.height || 0) / 2) ;
+  },
+
+  /** Returns the point that will center the frame X within the passed frame. */
+  centerX: function(innerFrame, outerFrame) {
+    return (outerFrame.width - innerFrame.width) / 2 ;
+  },
+
+  /** Return the point that will center the frame Y within the passed frame. */
+  centerY: function(innerFrame, outerFrame) {
+    return (outerFrame.height - innerFrame.height) /2  ;
+  },
+
+  /**
+    The offset of an element.
+
+    This function returns the left and top offset of an element with respect to either the document, the
+    viewport or the element's parent element.  In standard SproutCore applications, the coordinates of the
+    viewport are equivalent to the document, but a HTML5 application that wishes to use this component
+    of SproutCore might need to properly distinguish between the two.
+
+    For a useful discussion on the concepts of offsets and coordinates, see:
+    http://www.quirksmode.org/mobile/viewports.html.
+
+    @param {DOMElement|jQuery|String} elem the element to find the offset of.
+      This is passed to `jQuery()`, so any value supported by `jQuery()` will work.
+    @param {String} relativeToFlag flag to determine which relative element to determine offset by.
+      One of either: 'document', 'viewport' or 'parent' (default: 'document').
+    @returns {Object} the offset of the element as an Object (ie. Hash) in the form { left: value, top: value }.
+   */
+  offset: function(elem, relativeToFlag) {
+    var userAgent,
+        index,
+        mobileBuildNumber,
+        result;
+
+    relativeToFlag = relativeToFlag || 'document';
+
+    if (relativeToFlag === 'parent') {
+      result = jQuery(elem).position();
+    } else {
+      result = jQuery(elem).offset();
+
+      // jQuery does not workaround a problem with Mobile Safari versions prior to 4.1 that add the scroll
+      // offset to the results of getBoundingClientRect.
+      //
+      // See http://dev.jquery.it/ticket/6446
+      if (SC.browser.mobileSafari) {
+        userAgent = navigator.userAgent;
+        index = userAgent.indexOf('Mobile/');
+        mobileBuildNumber = userAgent.substring(index + 7, index + 9);
+
+        if (parseInt(SC.browser.mobileSafari, 0) <= 532 || (mobileBuildNumber <= "8A")) {
+          result.left = result.left - window.pageXOffset;
+          result.top = result.top - window.pageYOffset;
+        }
+      }
+
+      // Subtract the scroll offset for viewport coordinates
+      if (relativeToFlag === 'viewport') {
+        result.left = result.left - window.pageXOffset;
+        result.top = result.top - window.pageYOffset;
+      }
+    }
+
+    return result;
+  },
+
+  /** @deprecated
+    Deprecated. SC.offset() is more accurate, more flexible in the value for the element parameter and
+    easier to understand.
+
+    @param el The DOM element
+    @returns {Point} A hash with x, y offsets.
+  */
+  viewportOffset: function(el) {
+    console.warn("SC.viewportOffset() has been deprecated in favor of SC.offset().  Please use SC.offset() from here on.");
+    var result = SC.offset(el, 'viewport');
+
+    return {x: result.left, y: result.top};
+  }
+
+}) ;

data/sproutcore/frameworks/core_foundation/system/utils/rect.js

@@ -0,0 +1,98 @@
+SC.mixin( /** @scope SC */ {
+  /** A Point at {0,0} */
+  ZERO_POINT: { x: 0, y: 0 },
+
+  /** Check if the given point is inside the rect. */
+  pointInRect: function(point, f) {
+    return  (point.x >= SC.minX(f)) &&
+            (point.y >= SC.minY(f)) &&
+            (point.x <= SC.maxX(f)) &&
+            (point.y <= SC.maxY(f)) ;
+  },
+
+  /** Return true if the two frames match.  You can also pass only points or sizes.
+
+    @param r1 {Rect} the first rect
+    @param r2 {Rect} the second rect
+    @param delta {Float} an optional delta that allows for rects that do not match exactly. Defaults to 0.1
+    @returns {Boolean} true if rects match
+   */
+  rectsEqual: function(r1, r2, delta) {
+    if (!r1 || !r2) return (r1 == r2) ;
+    if (!delta && delta !== 0) delta = 0.1;
+    if ((r1.y != r2.y) && (Math.abs(r1.y - r2.y) > delta)) return NO ;
+    if ((r1.x != r2.x) && (Math.abs(r1.x - r2.x) > delta)) return NO ;
+    if ((r1.width != r2.width) && (Math.abs(r1.width - r2.width) > delta)) return NO ;
+    if ((r1.height != r2.height) && (Math.abs(r1.height - r2.height) > delta)) return NO ;
+    return YES ;
+  },
+
+  /** Returns the insersection between two rectangles.
+
+    @param r1 {Rect} The first rect
+    @param r2 {Rect} the second rect
+    @returns {Rect} the intersection rect.  width || height will be 0 if they do not interset.
+  */
+  intersectRects: function(r1, r2) {
+    // find all four edges
+    var ret = {
+      x: Math.max(SC.minX(r1), SC.minX(r2)),
+      y: Math.max(SC.minY(r1), SC.minY(r2)),
+      width: Math.min(SC.maxX(r1), SC.maxX(r2)),
+      height: Math.min(SC.maxY(r1), SC.maxY(r2))
+    } ;
+
+    // convert edges to w/h
+    ret.width = Math.max(0, ret.width - ret.x) ;
+    ret.height = Math.max(0, ret.height - ret.y) ;
+    return ret ;
+  },
+
+  /** Returns the union between two rectangles
+
+    @param r1 {Rect} The first rect
+    @param r2 {Rect} The second rect
+    @returns {Rect} The union rect.
+  */
+  unionRects: function(r1, r2) {
+    // find all four edges
+    var ret = {
+      x: Math.min(SC.minX(r1), SC.minX(r2)),
+      y: Math.min(SC.minY(r1), SC.minY(r2)),
+      width: Math.max(SC.maxX(r1), SC.maxX(r2)),
+      height: Math.max(SC.maxY(r1), SC.maxY(r2))
+    } ;
+
+    // convert edges to w/h
+    ret.width = Math.max(0, ret.width - ret.x) ;
+    ret.height = Math.max(0, ret.height - ret.y) ;
+    return ret ;
+  },
+
+  /** Duplicates the passed rect.
+
+    This is faster than Object.clone().
+
+    @param r {Rect} The rect to clone.
+    @returns {Rect} The cloned rect
+  */
+  cloneRect: function(r) {
+    return { x: r.x, y: r.y, width: r.width, height: r.height } ;
+  },
+
+  /** Returns a string representation of the rect as {x, y, width, height}.
+
+    @param r {Rect} The rect to stringify.
+    @returns {String} A string representation of the rect.
+  */
+  stringFromRect: function(r) {
+    if (!r) {
+      return "(null)";
+    }
+    else {
+      return '{x:'+r.x+', y:'+r.y+', width:'+r.width+', height:'+r.height+'}';
+    }
+  }
+
+
+});

data/sproutcore/frameworks/core_foundation/tests/controllers/array/array_case.js

@@ -0,0 +1,218 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*globals throws */
+
+var content, controller, extra;
+
+var TestObject = SC.Object.extend({
+  title: "test",
+  toString: function() { return "TestObject(%@)".fmt(this.get("title")); }
+});
+
+
+// ..........................................................
+// EMPTY
+//
+
+module("SC.ArrayController - array_case - EMPTY", {
+  setup: function() {
+    content = [];
+    controller = SC.ArrayController.create({ content: content });
+    extra = TestObject.create({ title: "FOO" });
+  },
+
+  teardown: function() {
+    controller.destroy();
+  }
+});
+
+test("state properties", function() {
+  equals(controller.get("hasContent"), YES, 'c.hasContent');
+  equals(controller.get("canRemoveContent"), YES, "c.canRemoveContent");
+  equals(controller.get("canReorderContent"), YES, "c.canReorderContent");
+  equals(controller.get("canAddContent"), YES, "c.canAddContent");
+});
+
+// addObject should append to end of array + notify observers on Array itself
+test("addObject", function() {
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  SC.run(function() { controller.addObject(extra); });
+
+  same(content, [extra], 'addObject(extra) should work');
+  equals(callCount, 1, 'should notify observer that content has changed');
+  equals(content.get('length'), 1, 'should update length of controller');
+});
+
+test("removeObject", function() {
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  SC.run(function() { controller.removeObject(extra); });
+
+  same(content, [], 'removeObject(extra) should have no effect');
+  equals(callCount, 0, 'should not notify observer since content did not change');
+});
+
+test("basic array READ operations", function() {
+  equals(controller.get("length"), 0, 'length should be empty');
+  equals(controller.objectAt(0), undefined, "objectAt() should return undefined");
+});
+
+test("basic array WRITE operations", function() {
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  controller.replace(0,1,[extra]);
+
+  same(content, [extra], 'should modify content');
+  equals(callCount, 1, 'should notify observer that content has changed');
+  equals(content.get('length'), 1, 'should update length of controller');
+});
+
+test("arrangedObjects", function() {
+  equals(controller.get("arrangedObjects"), controller, 'c.arrangedObjects should return receiver');
+});
+
+
+// ..........................................................
+// NON-EMPTY ARRAY
+//
+
+module("SC.ArrayController - array_case - NON-EMPTY", {
+  setup: function() {
+    content = "1 2 3 4 5".w().map(function(x) {
+      return TestObject.create({ title: x });
+    });
+
+    controller = SC.ArrayController.create({ content: content });
+    extra = TestObject.create({ title: "FOO" });
+  },
+
+  teardown: function() {
+    controller.destroy();
+  }
+});
+
+test("state properties", function() {
+  equals(controller.get("hasContent"), YES, 'c.hasContent');
+  equals(controller.get("canRemoveContent"), YES, "c.canRemoveContent");
+  equals(controller.get("canReorderContent"), YES, "c.canReorderContent");
+  equals(controller.get("canAddContent"), YES, "c.canAddContent");
+});
+
+// addObject should append to end of array + notify observers on Array itself
+test("addObject", function() {
+  var expected = content.slice();
+  expected.push(extra);
+
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  SC.run(function() { controller.addObject(extra); });
+
+  same(content, expected, 'addObject(extra) should work');
+  equals(callCount, 1, 'should notify observer that content has changed');
+  equals(content.get('length'), expected.length, 'should update length of controller');
+});
+
+test("removeObject", function() {
+  var expected = content.slice(), obj = expected[3];
+  expected.removeObject(obj);
+
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  SC.run(function() { controller.removeObject(obj); });
+
+  same(content, expected, 'removeObject(extra) should remove object');
+  equals(callCount, 1, 'should notify observer that content has changed');
+  equals(content.get('length'), expected.length, 'should update length of controller');
+});
+
+test("basic array READ operations", function() {
+  equals(controller.get("length"), content.length, 'length should be empty');
+
+  var loc = content.length+1; // verify 1 past end as well
+  while(--loc>=0) {
+    equals(controller.objectAt(loc), content[loc], "objectAt(%@) should return same value at content[%@]".fmt(loc, loc));
+  }
+});
+
+test("basic array WRITE operations", function() {
+  var expected = content.slice();
+  expected.replace(3,1,[extra]);
+
+  var callCount = 0;
+  controller.addObserver('[]', function() { callCount++; });
+
+  controller.replace(3,1,[extra]);
+
+  same(content, expected, 'should modify content');
+  equals(callCount, 1, 'should notify observer that content has changed');
+  equals(content.get('length'), expected.length, 'should update length of controller');
+});
+
+test("arrangedObjects", function() {
+  equals(controller.get("arrangedObjects"), controller, 'c.arrangedObjects should return receiver');
+});
+
+test("array orderBy using function", function(){
+  var testFunc = function(a,b){
+    if(a.get('title') > b.get('title')) return -1;
+    else if (a.get('title') == b.get('title')) return 0;
+    else return 1;
+  };
+  var expected = content.slice();
+  expected.sort(testFunc);
+
+  var testController = SC.ArrayController.create({
+    content: content,
+    orderBy: testFunc
+  });
+  same(testController.get('arrangedObjects').toArray(), expected, 'arrangedObjects should be sortable by a custom function');
+});
+
+// ..........................................................
+// ADD SPECIAL CASES HERE
+//
+
+test("verify rangeObserver fires when content is deleted", function() {
+
+  content = "1 2 3 4 5".w().map(function(x) {
+    return TestObject.create({ title: x });
+  });
+
+  controller = SC.ArrayController.create({ content: content });
+
+  var cnt = 0,
+      observer = SC.Object.create({ method: function() { cnt++; } });
+  controller.addRangeObserver(SC.IndexSet.create(0,2), observer, observer.method);
+
+  SC.RunLoop.begin();
+  content.length = 0 ;
+  content.enumerableContentDidChange();
+  SC.RunLoop.end();
+
+  equals(cnt, 1, 'range observer should have fired once');
+});
+
+
+// ..........................................................
+// VERIFY SC.ARRAY COMPLIANCE
+//
+
+SC.ArraySuite.generate("SC.ArrayController", {
+  newObject: function(amt) {
+    if (amt === undefined || typeof amt === SC.T_NUMBER) {
+      amt = this.expected(amt);
+    }
+    return SC.ArrayController.create({ content: amt });
+  }
+});