sproutcore 0.9.0

data/frameworks/sproutcore/foundation/json.js

@@ -0,0 +1,296 @@
+/*
+    json.js
+    2007-03-20
+
+    Public Domain
+
+    This file adds these methods to JavaScript:
+
+        array.toJSONString()
+        boolean.toJSONString()
+        date.toJSONString()
+        number.toJSONString()
+        object.toJSONString()
+        string.toJSONString()
+            These methods produce a JSON text from a JavaScript value.
+            It must not contain any cyclical references. Illegal values
+            will be excluded.
+
+            The default conversion for dates is to an ISO string. You can
+            add a toJSONString method to any date object to get a different
+            representation.
+
+        string.parseJSON(filter)
+            This method parses a JSON text to produce an object or
+            array. It can throw a SyntaxError exception.
+
+            The optional filter parameter is a function which can filter and
+            transform the results. It receives each of the keys and values, and
+            its return value is used instead of the original value. If it
+            returns what it received, then structure is not modified. If it
+            returns undefined then the member is deleted.
+
+            Example:
+
+            // Parse the text. If a key contains the string 'date' then
+            // convert the value to a date.
+
+            myData = text.parseJSON(function (key, value) {
+                return key.indexOf('date') >= 0 ? new Date(value) : value;
+            });
+
+    It is expected that these methods will formally become part of the
+    JavaScript Programming Language in the Fourth Edition of the
+    ECMAScript standard in 2008.
+
+    This file will break programs with improper for..in loops. See
+    http://yuiblog.com/blog/2006/09/26/for-in-intrigue/
+
+    This is a reference implementation. You are free to copy, modify, or
+    redistribute.
+
+    Use your own copy. It is extremely unwise to load untrusted third party
+    code into your pages.
+*/
+
+// Augment the basic prototypes if they have not already been augmented.
+
+if (!Object.toJSONString) {
+
+    Array.prototype.toJSONString = function () {
+        var a = ['['],  // The array holding the text fragments.
+            b,          // A boolean indicating that a comma is required.
+            i,          // Loop counter.
+            l = this.length,
+            v;          // The value to be stringified.
+
+        function p(s) {
+
+// p accumulates text fragments in an array. It inserts a comma before all
+// except the first fragment.
+
+            if (b) {
+                a.push(',');
+            }
+            a.push(s);
+            b = true;
+        }
+
+// For each value in this array...
+
+        for (i = 0; i < l; i += 1) {
+            v = this[i];
+            switch (typeof v) {
+
+// Serialize a JavaScript object value. Ignore objects thats lack the
+// toJSONString method. Due to a specification error in ECMAScript,
+// typeof null is 'object', so watch out for that case.
+
+            case 'object':
+                if (v) {
+                    if (typeof v.toJSONString === 'function') {
+                        p(v.toJSONString());
+                    } else p(Object.toJSONString(v)) ;
+                } else {
+                    p("null");
+                }
+                break;
+
+// Otherwise, serialize the value.
+
+            case 'string':
+            case 'number':
+            case 'boolean':
+                p(v.toJSONString());
+
+// Values without a JSON representation are ignored.
+
+            }
+        }
+
+// Join all of the fragments together and return.
+
+        a.push(']');
+        return a.join('');
+    };
+
+
+    Boolean.prototype.toJSONString = function () {
+        return String(this);
+    };
+
+
+    Date.prototype.toJSONString = function () {
+
+// Ultimately, this method will be equivalent to the date.toISOString method.
+
+        function f(n) {
+
+// Format integers to have at least two digits.
+
+            return n < 10 ? '0' + n : n;
+        }
+
+        return '"' + this.getFullYear() + '-' +
+                f(this.getMonth() + 1) + '-' +
+                f(this.getDate()) + 'T' +
+                f(this.getHours()) + ':' +
+                f(this.getMinutes()) + ':' +
+                f(this.getSeconds()) + '"';
+    };
+
+
+    Number.prototype.toJSONString = function () {
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+        return isFinite(this) ? String(this) : "null";
+    };
+
+
+    Object.toJSONString = function (object) {
+        var a = ['{'],  // The array holding the text fragments.
+            b,          // A boolean indicating that a comma is required.
+            k,          // The current key.
+            v;          // The current value.
+
+        function p(s) {
+
+// p accumulates text fragment pairs in an array. It inserts a comma before all
+// except the first fragment pair.
+
+            if (b) {
+                a.push(',');
+            }
+            a.push(k.toJSONString(), ':', s);
+            b = true;
+        }
+
+// Iterate through all of the keys in the object, ignoring the proto chain.
+
+        for (k in object) {
+            if (object.hasOwnProperty(k)) {
+                v = object[k];
+                switch (typeof v) {
+
+// Serialize a JavaScript object value. Ignore objects that lack the
+// toJSONString method. Due to a specification error in ECMAScript,
+// typeof null is 'object', so watch out for that case.
+
+                case 'object':
+                    if (v) {
+                        if (typeof v.toJSONString === 'function') {
+                            p(v.toJSONString());
+                        } else p(Object.toJSONString(v)) ;
+                    } else {
+                        p("null");
+                    }
+                    break;
+
+            case 'string':
+            case 'number':
+            case 'boolean':
+                    p(v.toJSONString());
+
+// Values without a JSON representation are ignored.
+
+                }
+            }
+        }
+
+// Join all of the fragments together and return.
+
+        a.push('}');
+        return a.join('');
+    };
+
+
+    (function (s) {
+
+// Augment String.prototype. We do this in an immediate anonymous function to
+// avoid defining global variables.
+
+// m is a table of character substitutions.
+
+        var m = {
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '"' : '\\"',
+            '\\': '\\\\'
+        };
+
+
+        s.parseJSON = function (filter) {
+
+// Parsing happens in three stages. In the first stage, we run the text against
+// a regular expression which looks for non-JSON characters. We are especially
+// concerned with '()' and 'new' because they can cause invocation, and '='
+// because it can cause mutation. But just to be safe, we will reject all
+// unexpected characters.
+
+            try {
+                if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
+                        test(this)) {
+
+// In the second stage we use the eval function to compile the text into a
+// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+// in JavaScript: it can begin a block or an object literal. We wrap the text
+// in parens to eliminate the ambiguity.
+
+                    var j = eval('(' + this + ')');
+
+// In the optional third stage, we recursively walk the new structure, passing
+// each name/value pair to a filter function for possible transformation.
+
+                    if (typeof filter === 'function') {
+
+                        function walk(k, v) {
+                            if (v && typeof v === 'object') {
+                                for (var i in v) {
+                                    if (v.hasOwnProperty(i)) {
+                                        v[i] = walk(i, v[i]);
+                                    }
+                                }
+                            }
+                            return filter(k, v);
+                        }
+
+                        j = walk('', j);
+                    }
+                    return j;
+                }
+            } catch (e) {
+
+// Fall through if the regexp test fails.
+
+            }
+            throw new SyntaxError("parseJSON");
+        };
+
+
+        s.toJSONString = function () {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can simply slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe
+// sequences.
+
+            if (/["\\\x00-\x1f]/.test(this)) {
+                return '"' + this.replace(/([\x00-\x1f\\"])/g, function(a, b) {
+                    var c = m[b];
+                    if (c) {
+                        return c;
+                    }
+                    c = b.charCodeAt();
+                    return '\\u00' +
+                        Math.floor(c / 16).toString(16) +
+                        (c % 16).toString(16);
+                }) + '"';
+            }
+            return '"' + this + '"';
+        };
+    })(String.prototype);
+}

data/frameworks/sproutcore/foundation/mock.js

@@ -0,0 +1,42 @@
+require('Core');
+require('foundation/object');
+
+/**
+  @namespace Mocks for unit testing
+  @author Skip Baney
+  @copyright 2006-2007, Sprout Systems, Inc. and contributors.
+  @version 0.1
+  
+  Mock objects provide basic support for unit testing.  Look for subclasses.
+  
+*/
+SC.Mock = {};
+
+/**
+* Base DOM event mock
+* @extends SC.Object
+*/
+SC.Mock.DOMEvent = SC.Object.extend(
+/** @scope SC.Mock.DOMEvent.prototype */ 
+{
+  type:    null,
+  target:  null,
+  stopped: false,
+  preventDefault: function() {},
+  stopPropagation: function() {}
+});
+
+/**
+* Mock for key events
+* @extends SC.Mock.DOMEvent
+*/
+SC.Mock.KeyEvent = SC.Mock.DOMEvent.extend(
+/** @scope SC.Mock.KeyEvent.prototype */ 
+{
+  keyCode:  0,
+  altKey:   false,
+  ctrlKey:  false,
+  shiftKey: false,
+  metaKey:  false
+});
+

data/frameworks/sproutcore/foundation/node_descriptor.js

@@ -0,0 +1,56 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('Core') ;
+
+// This object can generate HTML DOM elements from a hash-based description of 
+// the nodes.  See the NodeDescriptor wiki page for complete docs.
+//
+// See https://wiki.sproutit.com/engineering/show/NodeDescriptor 
+//
+SC.NodeDescriptor = {
+  create: function(descriptor, opts) {
+    if (!opts) opts = {} ;
+    // collect info from descriptor
+    var tag = opts.tag || descriptor.tag || 'div' ;
+    var className = opts.cssClass || descriptor.cssClass ;
+    var elementId = opts.id || descriptor.id ;
+    var style = opts.style || descriptor.style ;
+    var innerHTML = opts.innerHTML || descriptor.innerHTML ;
+    if (!innerHTML) {
+      var childNodes = opts.childNodes || descriptor.childNodes ;
+    } 
+
+    // create element
+    var ret = $(document.createElement(tag)) ;
+    if (className) ret.className = className ;
+    if (elementId) ret.id = elementId ;
+    if (style) {
+      for (var name in style) element.style[name.camelize()] = style[name];
+    }
+    
+    // apply extra attributes
+    for(var attr in descriptor) {
+      if (this.ignoredProperties.indexOf(attr) == -1) {
+        ret.setAttribute(attr,descriptor[attr]) ;
+      }
+    }
+    
+    // build child nodes, if they exist.
+    if (innerHTML) {
+      ret.innerHTML = innerHTML ;
+    } else if (childNodes) {
+      var that = this ;
+      childNodes.each(function(desc) {
+        ret.appendChild(that.create(desc)) ;
+      }) ;
+    }
+    
+    return ret ;
+  },
+  
+  ignoredProperties: ['tag','cssClass','id','style','childNodes','innerHTML']
+}
+