parsejs 0.0.1

data/spec/fixtures/sproutcore-core.js

@@ -0,0 +1,195 @@
+// ==========================================================================
+// Project:  SproutCore Runtime
+// Copyright: ©2011 Strobe Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+
+
+// NOTE: this object should never be included directly.  Instead use SC.
+// SC.Object.  We only define this separately so that SC.Set can depend on it
+
+
+
+var rewatch = SC.rewatch;
+var classToString = SC.Mixin.prototype.toString;
+var set = SC.set, get = SC.get;
+var o_create = SC.platform.create,
+    meta = SC.meta;
+
+function makeCtor() {
+
+  // Note: avoid accessing any properties on the object since it makes the
+  // method a lot faster.  This is glue code so we want it to be as fast as
+  // possible.
+
+  var isPrepared = false, initMixins, init = false, hasChains = false;
+
+  var Class = function() {
+    if (!isPrepared) { get(Class, 'proto'); } // prepare prototype...
+    if (initMixins) {
+      this.reopen.apply(this, initMixins);
+      initMixins = null;
+      rewatch(this); // ålways rewatch just in case
+      this.init.apply(this, arguments);
+    } else {
+      if (hasChains) {
+        rewatch(this);
+      } else {
+        this[SC.GUID_KEY] = undefined;
+      }
+      if (init===false) { init = this.init; } // cache for later instantiations
+      init.apply(this, arguments);
+    }
+  };
+
+  Class.toString = classToString;
+  Class._prototypeMixinDidChange = function() { isPrepared = false; };
+  Class._initMixins = function(args) { initMixins = args; };
+
+  SC.defineProperty(Class, 'proto', SC.computed(function() {
+    if (!isPrepared) {
+      isPrepared = true;
+      Class.PrototypeMixin.applyPartial(Class.prototype);
+      hasChains = !!meta(Class.prototype, false).chains; // avoid rewatch
+    }
+    return this.prototype;
+  }));
+
+  return Class;
+
+}
+
+var CoreObject = makeCtor();
+
+CoreObject.PrototypeMixin = SC.Mixin.create({
+
+  reopen: function() {
+    SC.Mixin._apply(this, arguments, true);
+    return this;
+  },
+
+  isInstance: true,
+
+  init: function() {},
+
+  isDestroyed: false,
+
+  /**
+    Destroys an object by setting the isDestroyed flag and removing its
+    metadata, which effectively destroys observers and bindings.
+
+    If you try to set a property on a destroyed object, an exception will be
+    raised.
+
+    Note that destruction is scheduled for the end of the run loop and does not
+    happen immediately.
+
+    @returns {SC.Object} receiver
+  */
+  destroy: function() {
+    set(this, 'isDestroyed', true);
+    SC.run.schedule('destroy', this, this._scheduledDestroy);
+    return this;
+  },
+
+  /**
+    Invoked by the run loop to actually destroy the object. This is
+    scheduled for execution by the `destroy` method.
+
+    @private
+  */
+  _scheduledDestroy: function() {
+    this[SC.META_KEY] = null;
+  },
+
+  bind: function(to, from) {
+    if (!(from instanceof SC.Binding)) { from = SC.Binding.from(from); }
+    from.to(to).connect(this);
+    return from;
+  },
+
+  toString: function() {
+    return '<'+this.constructor.toString()+':'+SC.guidFor(this)+'>';
+  }
+});
+
+CoreObject.__super__ = null;
+
+var ClassMixin = SC.Mixin.create({
+
+  ClassMixin: SC.required(),
+
+  PrototypeMixin: SC.required(),
+
+  isClass: true,
+
+  isMethod: false,
+
+  extend: function() {
+    var Class = makeCtor(), proto;
+    Class.ClassMixin = SC.Mixin.create(this.ClassMixin);
+    Class.PrototypeMixin = SC.Mixin.create(this.PrototypeMixin);
+
+    Class.ClassMixin.ownerConstructor = Class;
+    Class.PrototypeMixin.ownerConstructor = Class;
+
+    var PrototypeMixin = Class.PrototypeMixin;
+    PrototypeMixin.reopen.apply(PrototypeMixin, arguments);
+
+    Class.superclass = this;
+    Class.__super__  = this.prototype;
+
+    proto = Class.prototype = o_create(this.prototype);
+    proto.constructor = Class;
+    SC.generateGuid(proto, 'sc');
+    meta(proto).proto = proto; // this will disable observers on prototype
+    SC.rewatch(proto); // setup watch chains if needed.
+
+
+    Class.subclasses = SC.Set ? new SC.Set() : null;
+    if (this.subclasses) { this.subclasses.add(Class); }
+
+    Class.ClassMixin.apply(Class);
+    return Class;
+  },
+
+  create: function() {
+    var C = this;
+    if (arguments.length>0) { this._initMixins(arguments); }
+    return new C();
+  },
+
+  reopen: function() {
+    var PrototypeMixin = this.PrototypeMixin;
+    PrototypeMixin.reopen.apply(PrototypeMixin, arguments);
+    this._prototypeMixinDidChange();
+    return this;
+  },
+
+  reopenClass: function() {
+    var ClassMixin = this.ClassMixin;
+    ClassMixin.reopen.apply(ClassMixin, arguments);
+    SC.Mixin._apply(this, arguments, false);
+    return this;
+  },
+
+  detect: function(obj) {
+    if ('function' !== typeof obj) { return false; }
+    while(obj) {
+      if (obj===this) { return true; }
+      obj = obj.superclass;
+    }
+    return false;
+  }
+
+});
+
+CoreObject.ClassMixin = ClassMixin;
+ClassMixin.apply(CoreObject);
+
+SC.CoreObject = CoreObject;
+
+
+
+

data/spec/fixtures/sproutcore-each-proxy.js

@@ -0,0 +1,218 @@
+// ==========================================================================
+// Project:  SproutCore Runtime
+// Copyright: ©2011 Strobe Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+require('sproutcore-runtime/system/object');
+require('sproutcore-runtime/mixins/array');
+
+
+
+var set = SC.set, get = SC.get, guidFor = SC.guidFor;
+
+var EachArray = SC.Object.extend(SC.Array, {
+
+  init: function(content, keyName, owner) {
+    this._super();
+    this._keyName = keyName;
+    this._owner   = owner;
+    this._content = content;
+  },
+
+  objectAt: function(idx) {
+    var item = this._content.objectAt(idx);
+    return item && get(item, this._keyName);
+  },
+
+  length: function() {
+    var content = this._content;
+    return content ? get(content, 'length') : 0;
+  }.property('[]').cacheable()
+
+});
+
+var IS_OBSERVER = /^.+:(before|change)$/;
+
+function addObserverForContentKey(content, keyName, proxy, idx, loc) {
+  var objects = proxy._objects, guid;
+  if (!objects) objects = proxy._objects = {};
+
+  while(--loc>=idx) {
+    var item = content.objectAt(loc);
+    if (item) {
+      SC.addBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+      SC.addObserver(item, keyName, proxy, 'contentKeyDidChange');
+
+      // keep track of the indicies each item was found at so we can map
+      // it back when the obj changes.
+      guid = guidFor(item);
+      if (!objects[guid]) objects[guid] = [];
+      objects[guid].push(loc);
+    }
+  }
+}
+
+function removeObserverForContentKey(content, keyName, proxy, idx, loc) {
+  var objects = proxy._objects;
+  if (!objects) objects = proxy._objects = {};
+  var indicies, guid;
+
+  while(--loc>=idx) {
+    var item = content.objectAt(loc);
+    if (item) {
+      SC.removeBeforeObserver(item, keyName, proxy, 'contentKeyWillChange');
+      SC.removeObserver(item, keyName, proxy, 'contentKeyDidChange');
+
+      guid = guidFor(item);
+      indicies = objects[guid];
+      indicies[indicies.indexOf(loc)] = null;
+    }
+  }
+}
+
+/**
+  @private
+  @class
+
+  This is the object instance returned when you get the @each property on an
+  array.  It uses the unknownProperty handler to automatically create
+  EachArray instances for property names.
+
+  @extends SC.Object
+*/
+SC.EachProxy = SC.Object.extend({
+
+  init: function(content) {
+    this._super();
+    this._content = content;
+    content.addArrayObserver(this);
+
+    // in case someone is already observing some keys make sure they are
+    // added
+    SC.watchedEvents(this).forEach(function(eventName) {
+      this.didAddListener(eventName);
+    }, this);
+  },
+
+  /**
+    You can directly access mapped properties by simply requesting them.
+    The unknownProperty handler will generate an EachArray of each item.
+  */
+  unknownProperty: function(keyName, value) {
+    var ret;
+    ret = new EachArray(this._content, keyName, this);
+    new SC.Descriptor().setup(this, keyName, ret);
+    this.beginObservingContentKey(keyName);
+    return ret;
+  },
+
+  // ..........................................................
+  // ARRAY CHANGES
+  // Invokes whenever the content array itself changes.
+
+  arrayWillChange: function(content, idx, removedCnt, addedCnt) {
+    var keys = this._keys, key, array, lim;
+
+    lim = removedCnt>0 ? idx+removedCnt : -1;
+    SC.beginPropertyChanges(this);
+    for(key in keys) {
+      if (!keys.hasOwnProperty(key)) continue;
+
+      if (lim>0) removeObserverForContentKey(content, key, this, idx, lim);
+
+      array = get(this, key);
+      SC.propertyWillChange(this, key);
+      if (array) array.arrayContentWillChange(idx, removedCnt, addedCnt);
+    }
+
+    SC.propertyWillChange(this._content, '@each');
+    SC.endPropertyChanges(this);
+  },
+
+  arrayDidChange: function(content, idx, removedCnt, addedCnt) {
+    var keys = this._keys, key, array, lim;
+
+    lim = addedCnt>0 ? idx+addedCnt : -1;
+    SC.beginPropertyChanges(this);
+    for(key in keys) {
+      if (!keys.hasOwnProperty(key)) continue;
+
+      if (lim>0) addObserverForContentKey(content, key, this, idx, lim);
+
+      array = get(this, key);
+      if (array) array.arrayContentDidChange(idx, removedCnt, addedCnt);
+      SC.propertyDidChange(this, key);
+    }
+    SC.propertyDidChange(this._content, '@each');
+    SC.endPropertyChanges(this);
+  },
+
+  // ..........................................................
+  // LISTEN FOR NEW OBSERVERS AND OTHER EVENT LISTENERS
+  // Start monitoring keys based on who is listening...
+
+  didAddListener: function(eventName) {
+    if (IS_OBSERVER.test(eventName)) {
+      this.beginObservingContentKey(eventName.slice(0, -7));
+    }
+  },
+
+  didRemoveListener: function(eventName) {
+    if (IS_OBSERVER.test(eventName)) {
+      this.stopObservingContentKey(eventName.slice(0, -7));
+    }
+  },
+
+  // ..........................................................
+  // CONTENT KEY OBSERVING
+  // Actual watch keys on the source content.
+
+  beginObservingContentKey: function(keyName) {
+    var keys = this._keys;
+    if (!keys) keys = this._keys = {};
+    if (!keys[keyName]) {
+      keys[keyName] = 1;
+      var content = this._content,
+          len = get(content, 'length');
+      addObserverForContentKey(content, keyName, this, 0, len);
+    } else {
+      keys[keyName]++;
+    }
+  },
+
+  stopObservingContentKey: function(keyName) {
+    var keys = this._keys;
+    if (keys && (keys[keyName]>0) && (--keys[keyName]<=0)) {
+      var content = this._content,
+          len     = get(content, 'length');
+      removeObserverForContentKey(content, keyName, this, 0, len);
+    }
+  },
+
+  contentKeyWillChange: function(obj, keyName) {
+    // notify array.
+    var indexes = this._objects[guidFor(obj)],
+        array   = get(this, keyName),
+        len = array && indexes ? indexes.length : 0, idx;
+
+    for(idx=0;idx<len;idx++) {
+      array.arrayContentWillChange(indexes[idx], 1, 1);
+    }
+  },
+
+  contentKeyDidChange: function(obj, keyName) {
+    // notify array.
+    var indexes = this._objects[guidFor(obj)],
+        array   = get(this, keyName),
+        len = array && indexes ? indexes.length : 0, idx;
+
+    for(idx=0;idx<len;idx++) {
+      array.arrayContentDidChange(indexes[idx], 1, 1);
+    }
+
+    SC.propertyDidChange(this, keyName);
+  }
+
+});
+

data/spec/fixtures/sproutcore-native-array.js

@@ -0,0 +1,139 @@
+// ==========================================================================
+// Project:  SproutCore Runtime
+// Copyright: ©2011 Strobe Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+
+require('sproutcore-runtime/mixins/observable');
+require('sproutcore-runtime/mixins/mutable_array');
+require('sproutcore-runtime/mixins/copyable');
+
+
+
+var get = SC.get, set = SC.set;
+  
+// Add SC.Array to Array.prototype.  Remove methods with native 
+// implementations and supply some more optimized versions of generic methods
+// because they are so common.
+var NativeArray = SC.Mixin.create(SC.MutableArray, SC.Observable, SC.Copyable, {
+
+  // because length is a built-in property we need to know to just get the 
+  // original property.
+  get: function(key) {
+    if (key==='length') return this.length;
+    else if ('number' === typeof key) return this[key];
+    else return this._super(key);  
+  },
+  
+  objectAt: function(idx) {
+    return this[idx];
+  },
+    
+  // primitive for array support.
+  replace: function(idx, amt, objects) {
+
+    if (this.isFrozen) throw SC.FROZEN_ERROR ;
+
+    // if we replaced exactly the same number of items, then pass only the
+    // replaced range.  Otherwise, pass the full remaining array length
+    // since everything has shifted
+    var len = objects ? get(objects, 'length') : 0;
+    if (this.isBilly) { debugger; }
+    this.arrayContentWillChange(idx, amt, len);
+    
+    if (!objects || objects.length === 0) {
+      this.splice(idx, amt) ;
+    } else {
+      var args = [idx, amt].concat(objects) ;
+      this.splice.apply(this,args) ;
+    }
+
+    this.arrayContentDidChange(idx, amt, len);
+    return this ;
+  },
+
+  // If you ask for an unknown property, then try to collect the value
+  // from member items.
+  unknownProperty: function(key, value) {
+    var ret;// = this.reducedProperty(key, value) ;
+    if ((value !== undefined) && ret === undefined) {
+      ret = this[key] = value;
+    }
+    return ret ;
+  },
+
+  // If browser did not implement indexOf natively, then override with
+  // specialized version
+  indexOf: function(object, startAt) {
+    var idx, len = this.length;
+
+    if (startAt === undefined) startAt = 0;
+    else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+    if (startAt < 0) startAt += len;
+
+    for(idx=startAt;idx<len;idx++) {
+      if (this[idx] === object) return idx ;
+    }
+    return -1;
+  },
+
+  lastIndexOf: function(object, startAt) {
+    var idx, len = this.length;
+
+    if (startAt === undefined) startAt = len-1;
+    else startAt = (startAt < 0) ? Math.ceil(startAt) : Math.floor(startAt);
+    if (startAt < 0) startAt += len;
+
+    for(idx=startAt;idx>=0;idx--) {
+      if (this[idx] === object) return idx ;
+    }
+    return -1;
+  },
+  
+  copy: function() {
+    return this.slice();
+  }
+});
+
+// Remove any methods implemented natively so we don't override them
+var ignore = ['length'];
+NativeArray.keys().forEach(function(methodName) {
+  if (Array.prototype[methodName]) ignore.push(methodName);
+});
+
+if (ignore.length>0) {
+  NativeArray = NativeArray.without.apply(NativeArray, ignore);
+}
+
+/**
+  The NativeArray mixin contains the properties needed to to make the native
+  Array support SC.MutableArray and all of its dependent APIs.  Unless you 
+  have SC.EXTEND_PROTOTYPES set to false, this will be applied automatically.
+  Otherwise you can apply the mixin at anytime by calling 
+  `SC.NativeArray.activate`.
+  
+  @namespace
+  @extends SC.MutableArray
+  @extends SC.Array
+  @extends SC.Enumerable
+  @extends SC.MutableEnumerable
+  @extends SC.Copyable
+  @extends SC.Freezable
+*/
+SC.NativeArray = NativeArray;
+
+/**
+  Activates the mixin on the Array.prototype if not already applied.  Calling
+  this method more than once is safe.
+  
+  @returns {void}
+*/
+SC.NativeArray.activate = function() {
+  NativeArray.apply(Array.prototype);
+};
+
+if (SC.EXTEND_PROTOTYPES) SC.NativeArray.activate();
+
+
+