sproutcore 1.4.5-java → 1.5.0-java

data/lib/frameworks/sproutcore/frameworks/runtime/system/object.js

@@ -1,7 +1,7 @@
 // ==========================================================================
 // Project:   SproutCore Costello - Property Observing Library
 // Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
@@ -17,17 +17,45 @@ SC.BENCHMARK_OBJECTS = NO;
 
 // ..........................................................
 // PRIVATE HELPER METHODS
-// 
+//
 // Private helper methods.  These are not kept as part of the class
 // definition because SC.Object is copied frequently and we want to keep the
 // number of class methods to a minimum.
 
+SC._detect_base = function _detect_base(func, parent, name) {
+  return function invoke_superclass_method() {
+    var base = parent[name], args;
+
+    if (!base) {
+      throw new Error("No '" + name + "' method was found on the superclass");
+    }
+
+    // NOTE: It is possible to cache the base, so that the first
+    // call to sc_super will avoid doing the lookup again. However,
+    // since the cost of the extra method dispatch is low and is
+    // only incurred on sc_super, but also creates another possible
+    // weird edge-case (when a class is enhanced after first used),
+    // we'll leave it off for now unless profiling demonstrates that
+    // it's a hotspot.
+    //if(base && func === base) { func.base = function() {}; }
+    //else { func.base = base; }
+
+    if(func.isEnhancement) {
+      args = Array.prototype.slice.call(arguments, 1);
+    } else {
+      args = arguments;
+    }
+
+    return base.apply(this, args);
+  };
+};
+
 /** @private
   Augments a base object by copying the properties from the extended hash.
-  In addition to simply copying properties, this method also performs a 
+  In addition to simply copying properties, this method also performs a
   number of optimizations that can make init'ing a new object much faster
   including:
-  
+
   - concatenating concatenatedProperties
   - prepping a list of bindings, observers, and dependent keys
   - caching local observers so they don't need to be manually constructed.
@@ -36,9 +64,8 @@ SC.BENCHMARK_OBJECTS = NO;
   @param {Hash} extension
   @returns {Hash} base hash
 */
-SC._object_extend = function _object_extend(base, ext) {
-  if (!ext) throw "SC.Object.extend expects a non-null value.  Did you forget to 'sc_require' something?  Or were you passing a Protocol to extend() as if it were a mixin?";
-
+SC._object_extend = function _object_extend(base, ext, proto) {
+  if (!ext) { throw "SC.Object.extend expects a non-null value.  Did you forget to 'sc_require' something?  Or were you passing a Protocol to extend() as if it were a mixin?"; }
   // set _kvo_cloned for later use
   base._kvo_cloned = null;
 
@@ -62,18 +89,18 @@ SC._object_extend = function _object_extend(base, ext) {
   }
 
   // setup arrays for bindings, observers, and properties.  Normally, just
-  // save the arrays from the base.  If these need to be changed during 
+  // save the arrays from the base.  If these need to be changed during
   // processing, then they will be cloned first.
   var bindings = base._bindings, clonedBindings = NO;
   var observers = base._observers, clonedObservers = NO;
   var properties = base._properties, clonedProperties = NO;
   var paths, pathLoc, local ;
 
-  // outlets are treated a little differently because you can manually 
+  // outlets are treated a little differently because you can manually
   // name outlets in the passed in hash. If this is the case, then clone
   // the array first.
   var outlets = base.outlets, clonedOutlets = NO ;
-  if (ext.outlets) { 
+  if (ext.outlets) {
     outlets = (outlets || SC.EMPTY_ARRAY).concat(ext.outlets);
     clonedOutlets = YES ;
   }
@@ -84,10 +111,10 @@ SC._object_extend = function _object_extend(base, ext) {
     if (key === '_kvo_cloned') continue; // do not copy
 
     // avoid copying builtin methods
-    if (!ext.hasOwnProperty(key)) continue ; 
+    if (!ext.hasOwnProperty(key)) continue ;
 
     // get the value.  use concats if defined
-    var value = (concats.hasOwnProperty(key) ? concats[key] : null) || ext[key] ;
+    var value = (concats.hasOwnProperty(key) ? concats[key] : null) || ext[key];
 
     // Possibly add to a bindings.
     if (key.length > 7 && key.slice(-7) === "Binding") {
@@ -102,10 +129,11 @@ SC._object_extend = function _object_extend(base, ext) {
     // Also add observers, outlets, and properties for functions...
     } else if (value && (value instanceof Function)) {
 
-      // add super to funcs.  Be sure not to set the base of a func to 
+      // add super to funcs.  Be sure not to set the base of a func to
       // itself to avoid infinite loops.
       if (!value.superclass && (value !== (cur=base[key]))) {
-        value.superclass = value.base = cur || K;
+        value.superclass = cur || K;
+        value.base = proto ? SC._detect_base(value, proto, key) : cur || K;
       }
 
       // handle regular observers
@@ -118,7 +146,7 @@ SC._object_extend = function _object_extend(base, ext) {
 
       // handle local properties
       }
-      
+
       if (paths = value.localPropertyPaths) {
         pathLoc = paths.length;
         while(--pathLoc >= 0) {
@@ -129,7 +157,7 @@ SC._object_extend = function _object_extend(base, ext) {
 
       // handle computed properties
       }
-      
+
       if (value.dependentKeys) {
         if (!clonedProperties) {
           properties = (properties || SC.EMPTY_ARRAY).slice() ;
@@ -139,20 +167,24 @@ SC._object_extend = function _object_extend(base, ext) {
 
       // handle outlets
       }
-      
+
       if (value.autoconfiguredOutlet) {
         if (!clonedOutlets) {
           outlets = (outlets || SC.EMPTY_ARRAY).slice();
           clonedOutlets = YES ;
         }
-        outlets[outlets.length] = key ;          
+        outlets[outlets.length] = key ;
+      }
+
+      if (value.isEnhancement) {
+        value = SC._enhance(base[key] || K, value);
       }
     }
 
     // copy property
     base[key] = value ;
   }
-  
+
   // Manually set base on toString() because some JS engines (such as IE8) do
   // not enumerate it
   if (ext.hasOwnProperty('toString')) {
@@ -167,7 +199,7 @@ SC._object_extend = function _object_extend(base, ext) {
   }
 
 
-  // copy bindings, observers, and properties 
+  // copy bindings, observers, and properties
   base._bindings = bindings || [];
   base._observers = observers || [] ;
   base._properties = properties || [] ;
@@ -176,44 +208,59 @@ SC._object_extend = function _object_extend(base, ext) {
   return base ;
 } ;
 
+SC._enhance = function(originalFunction, enhancement) {
+  return function() {
+    var args = Array.prototype.slice.call(arguments, 0);
+    var self = this;
+
+    args.unshift(function() { return originalFunction.apply(self, arguments); });
+    return enhancement.apply(this, args);
+  };
+};
+
 /** @class
 
   Root object for the SproutCore framework.  SC.Object is the root class for
   most classes defined by SproutCore.  It builds on top of the native object
-  support provided by JavaScript to provide support for class-like 
-  inheritance, automatic bindings, properties observers, and more.  
-  
-  Most of the classes you define in your application should inherit from 
+  support provided by JavaScript to provide support for class-like
+  inheritance, automatic bindings, properties observers, and more.
+
+  Most of the classes you define in your application should inherit from
   SC.Object or one of its subclasses.  If you are writing objects of your
-  own, you should read this documentation to learn some of the details of 
+  own, you should read this documentation to learn some of the details of
   how SC.Object's behave and how they differ from other frameworks.
-  
-  h2. About SproutCore Classes
-  
-  JavaScript is not a class-based language.  Instead it uses a type of 
-  inheritence inspired by self called "prototypical" inheritance. 
+
+  About SproutCore Classes
+  ===
+
+  JavaScript is not a class-based language.  Instead it uses a type of
+  inheritence inspired by self called "prototypical" inheritance.
   ...
 
-  h2. Using SproutCore objects with other JavaScript object.
-  
+  Using SproutCore objects with other JavaScript object.
+  ===
+
   You can create a SproutCore object just like any other object...
   obj = new SC.Object() ;
-  
-  @extends SC.Observable 
+
+  @extends SC.Observable
   @since SproutCore 1.0
 */
-SC.Object = function(props) { return this._object_init(props); };
+SC.Object = function(props) {
+  this.__sc_super__ = SC.Object.prototype;
+  return this._object_init(props);
+};
 
 SC.mixin(SC.Object, /** @scope SC.Object */ {
 
   /**
-    Adds the passed properties to the object's class definition.  You can 
-    pass as many hashes as you want, including Mixins, and they will be 
+    Adds the passed properties to the object's class definition.  You can
+    pass as many hashes as you want, including Mixins, and they will be
     added in the order they are passed.
 
     This is a shorthand for calling SC.mixin(MyClass, props...);
-    
-    @params {Hash} props the properties you want to add.
+
+    @param {Hash} props the properties you want to add.
     @returns {Object} receiver
   */
   mixin: function(props) {
@@ -229,45 +276,49 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
   /**
     Points to the superclass for this class.  You can use this to trace a
     class hierarchy.
-    
-    @property {SC.Object}
+
+    @type SC.Object
   */
   superclass: null,
-  
+
   /**
     Creates a new subclass of the receiver, adding any passed properties to
     the instance definition of the new class.  You should use this method
-    when you plan to create several objects based on a class with similar 
+    when you plan to create several objects based on a class with similar
     properties.
 
-    h2. Init
+    Init:
 
-    If you define an init() method, it will be called when you create 
+    If you define an init() method, it will be called when you create
     instances of your new class.  Since SproutCore uses the init() method to
     do important setup, you must be sure to always call sc_super() somewhere
     in your init() to allow the normal setup to proceed.
 
-    @params {Hash} props the methods of properties you want to add
+    @param {Hash} props the methods of properties you want to add
     @returns {Class} A new object class
   */
-  extend: function(props) {   
+  extend: function(props) {
     var bench = SC.BENCHMARK_OBJECTS ;
     if (bench) SC.Benchmark.start('SC.Object.extend') ;
 
-    // build a new constructor and copy class methods.  Do this before 
+    // build a new constructor and copy class methods.  Do this before
     // adding any other properties so they are not overwritten by the copy.
-    var prop, ret = function(props) { return this._object_init(props); } ;
+    var prop, ret = function(props) {
+      this.__sc_super__ = ret.prototype;
+      return this._object_init(props);
+    } ;
     for(prop in this) {
       if (!this.hasOwnProperty(prop)) continue ;
       ret[prop] = this[prop];
     }
-    
+
     // manually copy toString() because some JS engines do not enumerate it
     if (this.hasOwnProperty('toString')) ret.toString = this.toString;
 
     // now setup superclass, guid
     ret.superclass = this ;
-    SC.generateGuid(ret); // setup guid
+    ret.__sc_super__ = this.prototype;
+    SC.generateGuid(ret, "sc"); // setup guid
 
     ret.subclasses = SC.Set.create();
     this.subclasses.add(ret); // now we can walk a class hierarchy
@@ -275,57 +326,61 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
     // setup new prototype and add properties to it
     var base = (ret.prototype = SC.beget(this.prototype));
     var idx, len = arguments.length;
-    for(idx=0;idx<len;idx++) SC._object_extend(base, arguments[idx]) ;
+    for(idx=0;idx<len;idx++) { SC._object_extend(base, arguments[idx], ret.__sc_super__) ; }
     base.constructor = ret; // save constructor
 
     if (bench) SC.Benchmark.end('SC.Object.extend') ;
     return ret ;
   },
 
+  reopen: function(props) {
+    return SC._object_extend(this.prototype, props, this.__sc_super__);
+  },
+
   /**
     Creates a new instance of the class.
 
     Unlike most frameworks, you do not pass parameters to the init function
-    for an object.  Instead, you pass a hash of additional properties you 
+    for an object.  Instead, you pass a hash of additional properties you
     want to have assigned to the object when it is first created.  This is
     functionally like creating an anonymous subclass of the receiver and then
     instantiating it, but more efficient.
 
-    You can use create() like you would a normal constructor in a 
-    class-based system, or you can use it to create highly customized 
-    singleton objects such as controllers or app-level objects.  This is 
-    often more efficient than creating subclasses and then instantiating 
+    You can use create() like you would a normal constructor in a
+    class-based system, or you can use it to create highly customized
+    singleton objects such as controllers or app-level objects.  This is
+    often more efficient than creating subclasses and then instantiating
     them.
 
     You can pass any hash of properties to this method, including mixins.
-    
-    @param {Hash} props 
+
+    @param {Hash} props
       optional hash of method or properties to add to the instance.
-      
+
     @returns {SC.Object} new instance of the receiver class.
   */
   create: function() {
-    var C=this, ret = new C(arguments); 
+    var C=this, ret = new C(arguments);
     if (SC.ObjectDesigner) {
       SC.ObjectDesigner.didCreateObject(ret, SC.$A(arguments));
     }
-    return ret ; 
+    return ret ;
   },
   /**
     Walk like a duck.  You can use this to quickly test classes.
-    
-    @property {Boolean}
+
+    @type Boolean
   */
   isClass: YES,
 
   /**
-    Set of subclasses that extend from this class.  You can observe this 
+    Set of subclasses that extend from this class.  You can observe this
     array if you want to be notified when the object is extended.
-    
-    @property {SC.Set}
+
+    @type SC.Set
   */
   subclasses: SC.Set.create(),
-  
+
   /** @private */
   toString: function() { return SC._object_className(this); },
 
@@ -333,23 +388,21 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
   // PROPERTY SUPPORT METHODS
   //
 
-  /** 
-    Returns YES if the receiver is a subclass of the named class.  If the 
+  /**
+    Returns YES if the receiver is a subclass of the named class.  If the
     receiver is the class passed, this will return NO since the class is not
     a subclass of itself.  See also kindOf().
 
-    h2. Example
-    
-    {{{
-      ClassA = SC.Object.extend();
-      ClassB = ClassA.extend();
+    Example:
+
+          ClassA = SC.Object.extend();
+          ClassB = ClassA.extend();
+
+          ClassB.subclassOf(ClassA) => YES
+          ClassA.subclassOf(ClassA) => NO
 
-      ClassB.subclassOf(ClassA) => YES
-      ClassA.subclassOf(ClassA) => NO
-    }}}
-    
     @param {Class} scClass class to compare
-    @returns {Boolean} 
+    @returns {Boolean}
   */
   subclassOf: function(scClass) {
     if (this === scClass) return NO ;
@@ -357,11 +410,11 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
     while(t = t.superclass) if (t === scClass) return YES ;
     return NO ;
   },
-  
+
   /**
-    Returns YES if the passed object is a subclass of the receiver.  This is 
+    Returns YES if the passed object is a subclass of the receiver.  This is
     the inverse of subclassOf() which you call on the class you want to test.
-    
+
     @param {Class} scClass class to compare
     @returns {Boolean}
   */
@@ -370,41 +423,45 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
   },
 
   /**
-    Returns YES if the receiver is the passed class or is a subclass of the 
+    Returns YES if the receiver is the passed class or is a subclass of the
     passed class.  Unlike subclassOf(), this method will return YES if you
-    pass the receiver itself, since class is a kind of itself.  See also 
+    pass the receiver itself, since class is a kind of itself.  See also
     subclassOf().
 
-    h2. Example
+    Example:
 
-    {{{
-      ClassA = SC.Object.extend();
-      ClassB = ClassA.extend();
+          ClassA = SC.Object.extend();
+          ClassB = ClassA.extend();
+
+          ClassB.kindOf(ClassA) => YES
+          ClassA.kindOf(ClassA) => YES
 
-      ClassB.kindOf(ClassA) => YES
-      ClassA.kindOf(ClassA) => YES
-    }}}
-    
     @param {Class} scClass class to compare
-    @returns {Boolean} 
+    @returns {Boolean}
   */
-  kindOf: function(scClass) { 
+  kindOf: function(scClass) {
     return (this === scClass) || this.subclassOf(scClass) ;
   },
-  
+
   // ..........................................................
   // Designers
-  //   
+  //
   /**
     This method works just like extend() except that it will also preserve
     the passed attributes.
-    
+
     @param {Hash} attrs Attributes to add to view
     @returns {Class} SC.Object subclass to create
     @function
-  */ 
+  */
   design: function() {
-    if (this.isDesign) return this; // only run design one time
+    if (this.isDesign) {
+      //@ if (debug)
+      SC.Logger.warn("SC.Object#design called twice for %@.".fmt(this));
+      //@ endif
+      return this;
+    }
+
     var ret = this.extend.apply(this, arguments);
     ret.isDesign = YES ;
     if (SC.ObjectDesigner) {
@@ -416,62 +473,60 @@ SC.mixin(SC.Object, /** @scope SC.Object */ {
 
 // ..........................................
 // DEFAULT OBJECT INSTANCE
-// 
+//
 SC.Object.prototype = {
-  
+
   _kvo_enabled: YES,
-  
+
   /** @private
     This is the first method invoked on a new instance.  It will first apply
     any added properties to the new instance and then calls the real init()
     method.
-    
+
     @param {Array} extensions an array-like object with hashes to apply.
     @returns {Object} receiver
   */
   _object_init: function(extensions) {
     // apply any new properties
     var idx, len = (extensions) ? extensions.length : 0;
-    for(idx=0;idx<len;idx++) SC._object_extend(this, extensions[idx]) ;
-    SC.generateGuid(this) ; // add guid
+    for(idx=0;idx<len;idx++) { SC._object_extend(this, extensions[idx], this.__sc_super__) ; }
+    SC.generateGuid(this, "sc") ; // add guid
     this.init() ; // call real init
-    
+
     // Call 'initMixin' methods to automatically setup modules.
     var inits = this.initMixin; len = (inits) ? inits.length : 0 ;
     for(idx=0;idx < len; idx++) inits[idx].call(this);
-    
+
     return this ; // done!
   },
-  
+
   /**
-    You can call this method on an object to mixin one or more hashes of 
-    properties on the receiver object.  In addition to simply copying 
-    properties, this method will also prepare the properties for use in 
+    You can call this method on an object to mixin one or more hashes of
+    properties on the receiver object.  In addition to simply copying
+    properties, this method will also prepare the properties for use in
     bindings, computed properties, etc.
-    
+
     If you plan to use this method, you should call it before you call
-    the inherited init method from SC.Object or else your instance may not 
+    the inherited init method from SC.Object or else your instance may not
     function properly.
-    
-    h2. Example
-    
-    {{{
-      // dynamically apply a mixin specified in an object property
-      var MyClass = SC.Object.extend({
-         extraMixin: null,
-         
-         init: function() {
-           this.mixin(this.extraMixin);
-           sc_super();
-         }
-      });
-      
-      var ExampleMixin = { foo: "bar" };
-      
-      var instance = MyClass.create({ extraMixin: ExampleMixin }) ;
-      
-      instance.get('foo') => "bar"
-    }}}
+
+    Example:
+
+          // dynamically apply a mixin specified in an object property
+          var MyClass = SC.Object.extend({
+             extraMixin: null,
+
+             init: function() {
+               this.mixin(this.extraMixin);
+               sc_super();
+             }
+          });
+
+          var ExampleMixin = { foo: "bar" };
+
+          var instance = MyClass.create({ extraMixin: ExampleMixin }) ;
+
+          instance.get('foo') => "bar"
 
     @param {Hash} ext a hash to copy.  Only one.
     @returns {Object} receiver
@@ -489,18 +544,18 @@ SC.Object.prototype = {
   },
 
   /**
-    This method is invoked automatically whenever a new object is 
+    This method is invoked automatically whenever a new object is
     instantiated.  You can override this method as you like to setup your
-    new object.  
+    new object.
 
-    Within your object, be sure to call sc_super() to ensure that the 
-    built-in init method is also called or your observers and computed 
+    Within your object, be sure to call sc_super() to ensure that the
+    built-in init method is also called or your observers and computed
     properties may not be configured.
 
-    Although the default init() method returns the receiver, the return 
+    Although the default init() method returns the receiver, the return
     value is ignored.
 
-    @returns {void}
+    
   */
   init: function() {
     this.initObservable();
@@ -508,22 +563,22 @@ SC.Object.prototype = {
   },
 
   /**
-    Set to NO once this object has been destroyed. 
-    
-    @property {Boolean}
+    Set to NO once this object has been destroyed.
+
+    @type Boolean
   */
   isDestroyed: NO,
 
   /**
     Call this method when you are finished with an object to teardown its
-    contents.  Because JavaScript is garbage collected, you do not usually 
+    contents.  Because JavaScript is garbage collected, you do not usually
     need to call this method.  However, you may choose to do so for certain
-    objects, especially views, in order to let them reclaim memory they 
+    objects, especially views, in order to let them reclaim memory they
     consume immediately.
 
     If you would like to perform additional cleanup when an object is
     finished, you may override this method.  Be sure to call sc_super().
-    
+
     @returns {SC.Object} receiver
   */
   destroy: function() {
@@ -543,27 +598,27 @@ SC.Object.prototype = {
 
   /**
     Walk like a duck. Always YES since this is an object and not a class.
-    
-    @property {Boolean}
+
+    @type Boolean
   */
   isObject: true,
 
   /**
     Returns YES if the named value is an executable function.
 
-    @param methodName {String} the property name to check
+    @param {String} methodName the property name to check
     @returns {Boolean}
   */
   respondsTo: function( methodName ) {
     return !!(this[methodName] instanceof Function);
   },
-  
+
   /**
-    Attemps to invoke the named method, passing the included two arguments.  
-    Returns NO if the method is either not implemented or if the handler 
-    returns NO (indicating that it did not handle the event).  This method 
-    is invoked to deliver actions from menu items and to deliver events.  
-    You can override this method to provide additional handling if you 
+    Attemps to invoke the named method, passing the included two arguments.
+    Returns NO if the method is either not implemented or if the handler
+    returns NO (indicating that it did not handle the event).  This method
+    is invoked to deliver actions from menu items and to deliver events.
+    You can override this method to provide additional handling if you
     prefer.
 
     @param {String} methodName
@@ -575,90 +630,84 @@ SC.Object.prototype = {
     return this.respondsTo(methodName) && (this[methodName](arg1, arg2) !== NO);
   },
 
-  /**  
+  /**
     EXPERIMENTAL:  You can use this to invoke a superclass implementation in
     any method.  This does not work in Safari 2 or earlier.  If you need to
     target these methods, you should use one of the alternatives below:
 
     - *With Build Tools:* sc_super();
     - *Without Build Tools:* arguments.callee.base.apply(this, arguments);
-    
-    h2. Example
-    
+
+    Example
+
     All of the following methods will call the superclass implementation of
     your method:
-    
-    {{{
-      SC.Object.create({
-        
-        // DOES NOT WORK IN SAFARI 2 OR EARLIER
-        method1: function() {
-          this.superclass();
-        },
-        
-        // REQUIRES SC-BUILD TOOLS
-        method2: function() {
-          sc_super();
-        },
-        
-        // WORKS ANYTIME
-        method3: function() {
-          arguments.callee.base.apply(this, arguments);
-        }
-      });
-    }}}
 
-    @params args {*args} any arguments you want to pass along.
+          SC.Object.create({
+
+            // DOES NOT WORK IN SAFARI 2 OR EARLIER
+            method1: function() {
+              this.superclass();
+            },
+
+            // REQUIRES SC-BUILD TOOLS
+            method2: function() {
+              sc_super();
+            },
+
+            // WORKS ANYTIME
+            method3: function() {
+              arguments.callee.base.apply(this, arguments);
+            }
+          });
+
+    @param {*args} args any arguments you want to pass along.
     @returns {Object} return value from super
   */
   superclass: function(args) {
-    var caller = arguments.callee.caller; 
+    var caller = arguments.callee.caller;
     if (!caller) throw "superclass cannot determine the caller method" ;
     return caller.superclass ? caller.superclass.apply(this, arguments) : null;
   },
 
-  /**  
+  /**
     returns YES if the receiver is an instance of the named class.  See also
     kindOf().
 
-    h2. Example
-    
-    {{{
-      var ClassA = SC.Object.extend();
-      var ClassB = SC.Object.extend();
-      
-      var instA = ClassA.create();
-      var instB = ClassB.create();
-      
-      instA.instanceOf(ClassA) => YES
-      instB.instanceOf(ClassA) => NO
-    }}}
-    
+    Example
+
+          var ClassA = SC.Object.extend();
+          var ClassB = SC.Object.extend();
+
+          var instA = ClassA.create();
+          var instB = ClassB.create();
+
+          instA.instanceOf(ClassA) => YES
+          instB.instanceOf(ClassA) => NO
+
     @param {Class} scClass the class
     @returns {Boolean}
   */
   instanceOf: function(scClass) {
-    return this.constructor === scClass ;  
+    return this.constructor === scClass ;
   },
 
-  /**  
-    Returns true if the receiver is an instance of the named class or any 
+  /**
+    Returns true if the receiver is an instance of the named class or any
     subclass of the named class.  See also instanceOf().
 
-    h2. Example
-    
-    {{{
-      var ClassA = SC.Object.extend();
-      var ClassB = SC.Object.extend();
-      
-      var instA = ClassA.create();
-      var instB = ClassB.create();
-      
-      instA.kindOf(ClassA) => YES
-      instB.kindOf(ClassA) => YES
-    }}}
-
-    @param scClass {Class} the class
+    Example
+
+          var ClassA = SC.Object.extend();
+          var ClassB = SC.Object.extend();
+
+          var instA = ClassA.create();
+          var instB = ClassB.create();
+
+          instA.kindOf(ClassA) => YES
+          instB.kindOf(ClassA) => YES
+
+    @param {Class} scClass the class
     @returns {Boolean}
   */
   kindOf: function(scClass) { return this.constructor.kindOf(scClass); },
@@ -671,36 +720,36 @@ SC.Object.prototype = {
       var string = "%@:%@".fmt(klassName, SC.guidFor(this));
       if (klassName) this._object_toString = string ;
       else return string ;
-    } 
+    }
     return this._object_toString ;
   },
 
-  /**  
+  /**
     Activates any outlet connections in object and syncs any bindings.  This
     method is called automatically for view classes but may be used for any
     object.
+
     
-    @returns {void}
   */
-  awake: function(key) {
+  awake: function() {
     var outlets = this.outlets,
         i, len, outlet;
     for (i = 0, len = outlets.length;  i < len;  ++i) {
       outlet = outlets[i];
       this.get(outlet);
     }
-    this.bindings.invoke('sync'); 
+    this.bindings.invoke('sync');
   },
 
   /**
     Invokes the passed method or method name one time during the runloop.  You
-    can use this method to schedule methods that need to execute but may be 
+    can use this method to schedule methods that need to execute but may be
     too expensive to execute more than once, such as methods that update the
     DOM.
-    
+
     Note that in development mode only, the object and method that call this
     method will be recorded, for help in debugging scheduled code.
-    
+
     @param {Function|String} method method or method name
     @returns {SC.Object} receiver
   */
@@ -708,40 +757,38 @@ SC.Object.prototype = {
     SC.RunLoop.currentRunLoop.invokeOnce(this, method) ;
     return this ;
   },
-  
+
   /**
-    Invokes the passed method once at the beginning of the next runloop, 
+    Invokes the passed method once at the beginning of the next runloop,
     before any other methods (including events) are processed. This is useful
     for situations where you know you need to update something, but due to
     the way the run loop works, you can't actually do the update until the
     run loop has completed.
-    
-    A simple example is setting the selection on a collection controller to a 
+
+    A simple example is setting the selection on a collection controller to a
     newly created object. Because the collection controller won't have its
-    content collection updated until later in the run loop, setting the 
+    content collection updated until later in the run loop, setting the
     selection immediately will have no effect. In this situation, you could do
     this instead:
-    
-    {{{
-      // Creates a new MyRecord object and sets the selection of the
-      // myRecord collection controller to the new object.
-      createObjectAction: function(sender, evt) {
-        // create a new record and add it to the store
-        var obj = MyRecord.newRecord() ;
-        
-        // update the collection controller's selection
-        MyApp.myRecordCollectionController.invokeLast( function() {
-          this.set('selection', [obj]) ;
-        });
-      }
-    }}}
-    
+
+          // Creates a new MyRecord object and sets the selection of the
+          // myRecord collection controller to the new object.
+          createObjectAction: function(sender, evt) {
+            // create a new record and add it to the store
+            var obj = MyRecord.newRecord() ;
+
+            // update the collection controller's selection
+            MyApp.myRecordCollectionController.invokeLast( function() {
+              this.set('selection', [obj]) ;
+            });
+          }
+
     You can call invokeLast as many times as you like and the method will
     only be invoked once.
-    
+
     Note that in development mode only, the object and method that call this
     method will be recorded, for help in debugging scheduled code.
-    
+
     @param {Function|String} method method or method name
     @returns {SC.Object} receiver
   */
@@ -749,19 +796,19 @@ SC.Object.prototype = {
     SC.RunLoop.currentRunLoop.invokeLast(this, method) ;
     return this ;
   },
-  
+
   /**
     The properties named in this array will be concatenated in subclasses
     instead of replaced.  This allows you to name special properties that
     should contain any values you specify plus values specified by parents.
 
-    It is used by SproutCore and is available for your use, though you 
-    should limit the number of properties you include in this list as it 
+    It is used by SproutCore and is available for your use, though you
+    should limit the number of properties you include in this list as it
     adds a slight overhead to new class and instance creation.
 
-    @property {Array}
+    @type Array
   */
-  concatenatedProperties: ['concatenatedProperties', 'initMixin', 'destroyMixin']  
+  concatenatedProperties: ['concatenatedProperties', 'initMixin', 'destroyMixin']
 
 } ;
 
@@ -773,10 +820,10 @@ SC.mixin(SC.Object.prototype, SC.Observable) ;
 
 // ..........................................................
 // CLASS NAME SUPPORT
-// 
+//
 
 /** @private
-  This is a way of performing brute-force introspection.  This searches 
+  This is a way of performing brute-force introspection.  This searches
   through all the top-level properties looking for classes.  When it finds
   one, it saves the class path name.
 */
@@ -807,8 +854,14 @@ function findClassNames() {
       var path = (root) ? [root,key].join('.') : key ;
       var value = object[key] ;
 
+      try {
+        var type = SC.typeOf(value);
+      } catch (e) {
+        // Firefox gives security errors when trying to run typeOf on certain objects
+        break;
+      }
 
-      switch(SC.typeOf(value)) {
+      switch(type) {
       case SC.T_CLASS:
         if (!value._object_className) value._object_className = path;
         if (levels>=0) searchObject(path, value, levels) ;
@@ -842,22 +895,22 @@ function findClassNames() {
   searchObject(null, window, 2) ;
 }
 
-/**  
+/**
   Same as the instance method, but lets you check instanceOf without
   having to first check if instanceOf exists as a method.
-  
+
   @param {Object} scObject the object to check instance of
   @param {Class} scClass the class
   @returns {Boolean} if object1 is instance of class
 */
 SC.instanceOf = function(scObject, scClass) {
-  return !!(scObject && scObject.constructor === scClass) ;  
-} ; 
+  return !!(scObject && scObject.constructor === scClass) ;
+} ;
 
 /**
-  Same as the instance method, but lets you check kindOf without having to 
+  Same as the instance method, but lets you check kindOf without having to
   first check if kindOf exists as a method.
-  
+
   @param {Object} scObject object to check kind of
   @param {Class} scClass the class to check
   @returns {Boolean} if object is an instance of class or subclass
@@ -870,7 +923,7 @@ SC.kindOf = function(scObject, scClass) {
 /** @private
   Returns the name of this class.  If the name is not known, triggers
   a search.  This can be expensive the first time it is called.
-  
+
   This method is used to allow classes to determine their own name.
 */
 SC._object_className = function(obj) {
@@ -878,10 +931,10 @@ SC._object_className = function(obj) {
   if (!obj._object_className) findClassNames() ;
   if (obj._object_className) return obj._object_className ;
 
-  // if no direct classname was found, walk up class chain looking for a 
+  // if no direct classname was found, walk up class chain looking for a
   // match.
   var ret = obj ;
-  while(ret && !ret._object_className) ret = ret.superclass; 
+  while(ret && !ret._object_className) ret = ret.superclass;
   return (ret && ret._object_className) ? ret._object_className : 'Anonymous';
 } ;