RubyGems - spade - Versions diffs - 0.0.1 → 0.0.2 - Mend

spade 0.0.1 → 0.0.2

Files changed (1660) hide show

data/sproutcore/frameworks/core_foundation/ext/object.js DELETED Viewed

@@ -1,83 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-// Extensions to the core SC.Object class
-SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
-  /**
-    Invokes the named method after the specified period of time.
-    This is a convenience method that will create a single run timer to
-    invoke a method after a period of time.  The method should have the
-    signature:
-    {{{
-      methodName: function(timer)
-    }}}
-    If you would prefer to pass your own parameters instead, you can instead
-    call invokeLater() directly on the function object itself.
-    @param methodName {String} method name to perform.
-    @param interval {Number} period from current time to schedule.
-    @returns {SC.Timer} scheduled timer.
-  */
-  invokeLater: function(methodName, interval) {
-    if (interval === undefined) { interval = 1 ; }
-    var f = methodName, args, func;
-    // if extra arguments were passed - build a function binding.
-    if (arguments.length > 2) {
-      args = SC.$A(arguments).slice(2);
-      if (SC.typeOf(f) === SC.T_STRING) { f = this[methodName] ; }
-      func = f ;
-      f = function() { return func.apply(this, args); } ;
-    }
-    // schedule the timer
-    return SC.Timer.schedule({ target: this, action: f, interval: interval });
-  },
-  /**
-    Lookup the named property path and then invoke the passed function,
-    passing the resulting value to the function.
-    This method is a useful way to handle deferred loading of properties.
-    If you want to defer loading a property, you can override this method.
-    When the method is called, passing a deferred property, you can load the
-    property before invoking the callback method.
-    You can even swap out the receiver object.
-    The callback method should have the signature:
-    function callback(objectAtPath, sourceObject) { ... }
-    You may pass either a function itself or a target/method pair.
-    @param {String} pathName
-    @param {Object} target target or method
-    @param {Function|String} method
-    @returns {SC.Object} receiver
-  */
-  invokeWith: function(pathName, target, method) {
-    // normalize target/method
-    if (method === undefined) {
-      method = target; target = this;
-    }
-    if (!target) { target = this ; }
-    if (SC.typeOf(method) === SC.T_STRING) { method = target[method]; }
-    // get value
-    var v = this.getPath(pathName);
-    // invoke method
-    method.call(target, v, this);
-    return this ;
-  }
-});

data/sproutcore/frameworks/core_foundation/ext/run_loop.js DELETED Viewed

@@ -1,163 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-// Create anonymous subclass of SC.RunLoop to add support for processing
-// view queues and Timers.
-SC.RunLoop = SC.RunLoop.extend(
-/** @scope SC.RunLoop.prototype */ {
-  /**
-    The time the current run loop began executing.
-    All timers scheduled during this run loop will begin executing as if
-    they were scheduled at this time.
-    @property {Number}
-  */
-  startTime: function() {
-    if (!this._start) { this._start = Date.now(); }
-    return this._start ;
-  }.property(),
-  /*
-    Override to fire and reschedule timers once per run loop.
-    Note that timers should fire only once per run loop to avoid the
-    situation where a timer might cause an infinite loop by constantly
-    rescheduling itself everytime it is fired.
-  */
-  endRunLoop: function() {
-    this.fireExpiredTimers(); // fire them timers!
-    var ret = sc_super(); // do everything else
-    this.scheduleNextTimeout(); // schedule a timout if timers remain
-    return ret;
-  },
-  // ..........................................................
-  // TIMER SUPPORT
-  //
-  /**
-    Schedules a timer to execute at the specified runTime.  You will not
-    usually call this method directly.  Instead you should work with SC.Timer,
-    which will manage both creating the timer and scheduling it.
-    Calling this method on a timer that is already scheduled will remove it
-    from the existing schedule and reschedule it.
-    @param {SC.Timer} timer the timer to schedule
-    @param {Time} runTime the time offset when you want this to run
-    @returns {SC.RunLoop} receiver
-  */
-  scheduleTimer: function(timer, runTime) {
-    // if the timer is already in the schedule, remove it.
-    this._timerQueue = timer.removeFromTimerQueue(this._timerQueue);
-    // now, add the timer ot the timeout queue.  This will walk down the
-    // chain of timers to find the right place to insert it.
-    this._timerQueue = timer.scheduleInTimerQueue(this._timerQueue, runTime);
-    return this ;
-  },
-  /**
-    Removes the named timer from the timeout queue.  If the timer is not
-    currently scheduled, this method will have no effect.
-    @param {SC.Timer} timer the timer to schedule
-    @returns {SC.RunLoop} receiver
-  */
-  cancelTimer: function(timer) {
-    this._timerQueue = timer.removeFromTimerQueue(this._timerQueue) ;
-    return this ;
-  },
-  /** @private - shared array used by fireExpiredTimers to avoid memory */
-  TIMER_ARRAY: [],
-  /**
-    Invokes any timers that have expired since this method was last called.
-    Usually you will not call this method directly, but it will be invoked
-    automatically at the end of the run loop.
-    @returns {Boolean} YES if timers were fired, NO otherwise
-  */
-  fireExpiredTimers: function() {
-    if (!this._timerQueue || this._firing) { return NO; } // nothing to do
-    // max time we are allowed to run timers
-    var now = this.get('startTime'),
-        timers = this.TIMER_ARRAY,
-        idx, len, didFire;
-    // avoid recursive calls
-    this._firing = YES;
-    // collect timers to fire.  we do this one time up front to avoid infinite
-    // loops where firing a timer causes it to schedule itself again, causing
-    // it to fire again, etc.
-    this._timerQueue = this._timerQueue.collectExpiredTimers(timers, now);
-    // now step through timers and fire them.
-    len = timers.length;
-    for(idx=0;idx<len;idx++) { timers[idx].fire(); }
-    // cleanup
-    didFire = timers.length > 0 ;
-    timers.length = 0 ; // reset for later use...
-    this._firing = NO ;
-    return didFire;
-  },
-  /** @private
-    Invoked at the end of a runloop, if there are pending timers, a timeout
-    will be scheduled to fire when the next timer expires.  You will not
-    usually call this method yourself.  It is invoked automatically at the
-    end of a run loop.
-    @returns {Boolean} YES if a timeout was scheduled
-  */
-  scheduleNextTimeout: function() {
-    var timer = this._timerQueue ;
-    var ret = NO ;
-    // if no timer, and there is an existing timeout, cancel it
-    if (!timer) {
-      if (this._timeout) { clearTimeout(this._timeout); }
-    // otherwise, determine if the timeout needs to be rescheduled.
-    } else {
-      var nextTimeoutAt = timer._timerQueueRunTime ;
-      if (this._timeoutAt !== nextTimeoutAt) { // need to reschedule
-        if (this._timeout) { clearTimeout(this._timeout); } // clear existing...
-        // reschedule
-        var delay = Math.max(0, nextTimeoutAt - Date.now());
-        this._timeout = setTimeout(this._timeoutDidFire, delay);
-        this._timeoutAt = nextTimeoutAt ;
-      }
-      ret = YES ;
-    }
-    return ret ;
-  },
-  /** @private
-    Invoked when a timeout actually fires.  Simply cleanup, then begin and end
-    a runloop. This will fire any expired timers and reschedule.  Note that
-    this function will be called with 'this' set to the global context,
-    hence the need to lookup the current run loop.
-  */
-  _timeoutDidFire: function() {
-    var rl = SC.RunLoop.currentRunLoop;
-    rl._timeout = rl._timeoutAt = null ; // cleanup
-    SC.run();  // begin/end runloop to trigger timers.
-  }
-});
-// Recreate the currentRunLoop with the new methods
-SC.RunLoop.currentRunLoop = SC.RunLoop.create();

data/sproutcore/frameworks/core_foundation/mixins/delegate_support.js DELETED Viewed

@@ -1,110 +0,0 @@
-// ==========================================================================
-// Project:   SproutCore Costello - Property Observing Library
-// Copyright: ©2006-2011 Strobe Inc. and contributors.
-//            Portions ©2008-2010 Apple Inc. All rights reserved.
-// License:   Licensed under MIT license (see license.js)
-// ==========================================================================
-/**
-  @namespace
-  Support methods for the Delegate design pattern.
-  The Delegate design pattern makes it easy to delegate a portion of your
-  application logic to another object.  This is most often used in views to
-  delegate various application-logic decisions to controllers in order to
-  avoid having to bake application-logic directly into the view itself.
-  The methods provided by this mixin make it easier to implement this pattern
-  but they are not required to support delegates.
-  h2. The Pattern
-  The delegate design pattern typically means that you provide a property,
-  usually ending in "delegate", that can be set to another object in the
-  system.
-  When events occur or logic decisions need to be made that you would prefer
-  to delegate, you can call methods on the delegate if it is set.  If the
-  delegate is not set, you should provide some default functionality instead.
-  Note that typically delegates are not observable, hence it is not necessary
-  to use get() to retrieve the value of the delegate.
-  @since SproutCore 1.0
-*/
-SC.DelegateSupport = {
-  /**
-    Selects the delegate that implements the specified method name.  Pass one
-    or more delegates.  The receiver is automatically included as a default.
-    This can be more efficient than using invokeDelegateMethod() which has
-    to marshall arguments into a delegate call.
-    @param {String} methodName
-    @param {Object...} delegate one or more delegate arguments
-    @returns {Object} delegate or null
-  */
-  delegateFor: function(methodName) {
-    var idx = 1,
-        len = arguments.length,
-        ret ;
-    while(idx<len) {
-      ret = arguments[idx];
-      if (ret && ret[methodName] !== undefined) return ret ;
-      idx++;
-    }
-    return (this[methodName] !== undefined) ? this : null;
-  },
-  /**
-    Invokes the named method on the delegate that you pass.  If no delegate
-    is defined or if the delegate does not implement the method, then a
-    method of the same name on the receiver will be called instead.
-    You can pass any arguments you want to pass onto the delegate after the
-    delegate and methodName.
-    @param {Object} delegate a delegate object.  May be null.
-    @param {String} methodName a method name
-    @param {Object...} args (OPTIONAL) any additional arguments
-    @returns {Object} value returned by delegate
-  */
-  invokeDelegateMethod: function(delegate, methodName, args) {
-    args = SC.A(arguments); args = args.slice(2, args.length) ;
-    if (!delegate || !delegate[methodName]) delegate = this ;
-    var method = delegate[methodName];
-    return method ? method.apply(delegate, args) : null;
-  },
-  /**
-    Search the named delegates for the passed property.  If one is found,
-    gets the property value and returns it.  If none of the passed delegates
-    implement the property, search the receiver for the property as well.
-    @param {String} key the property to get.
-    @param {Object} delegate one or more delegate
-    @returns {Object} property value or undefined
-  */
-  getDelegateProperty: function(key, delegate) {
-    var idx = 1,
-        len = arguments.length,
-        ret ;
-    while(idx<len) {
-      ret = arguments[idx++];
-      if (ret && ret[key] !== undefined) {
-        return ret.get ? ret.get(key) : ret[key] ;
-      }
-    }
-    return (this[key] !== undefined) ? this.get(key) : undefined ;
-  }
-};

data/sproutcore/frameworks/core_foundation/mixins/responder_context.js DELETED Viewed

@@ -1,269 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-sc_require('system/responder');
-/** @namespace
-  The root object for a responder chain.  A responder context can dispatch
-  actions directly to a first responder; walking up the responder chain until
-  it finds a responder that can handle the action.
-  If no responder can be found to handle the action, it will attempt to send
-  the action to the defaultResponder.
-  You can have as many ResponderContext's as you want within your application.
-  Every SC.Pane and SC.Application automatically implements this mixin.
-  Note that to implement this, you should mix SC.ResponderContext into an
-  SC.Responder or SC.Responder subclass.
-  @since SproutCore 1.0
-*/
-SC.ResponderContext = {
-  // ..........................................................
-  // PROPERTIES
-  //
-  isResponderContext: YES,
-  /** @property
-    When set to YES, logs tracing information about all actions sent and
-    responder changes.
-  */
-  trace: NO,
-  /** @property
-    The default responder.  Set this to point to a responder object that can
-    respond to events when no other view in the hierarchy handles them.
-    @type SC.Responder
-  */
-  defaultResponder: null,
-  /** @property
-    The next responder for an app is always its defaultResponder.
-  */
-  nextResponder: function() {
-    return this.get('defaultResponder');
-  }.property('defaultResponder').cacheable(),
-  /** @property
-    The first responder.  This is the first responder that should receive
-    actions.
-  */
-  firstResponder: null,
-  // ..........................................................
-  // METHODS
-  //
-  /**
-    Finds the next responder for the passed responder based on the responder's
-    nextResponder property.  If the property is a string, then lookup the path
-    in the receiver.
-  */
-  nextResponderFor: function(responder) {
-    var next = responder.get('nextResponder');
-    if (typeof next === SC.T_STRING) {
-      next = SC.objectForPropertyPath(next, this);
-    } else if (!next && (responder !== this)) next = this ;
-    return next ;
-  },
-  /**
-    Finds the responder name by searching the responders one time.
-  */
-  responderNameFor: function(responder) {
-    if (!responder) return "(No Responder)";
-    else if (responder._scrc_name) return responder._scrc_name;
-    // none found, let's go hunting...look three levels deep
-    var n = this.NAMESPACE;
-    this._findResponderNamesFor(this, 3, n ? [this.NAMESPACE] : []);
-    return responder._scrc_name || responder.toString(); // try again
-  },
-  _findResponderNamesFor: function(responder, level, path) {
-    var key, value;
-    for(key in responder) {
-      if (key === 'nextResponder') continue ;
-      value = responder[key];
-      if (value && value.isResponder) {
-        if (value._scrc_name) continue ;
-        path.push(key);
-        value._scrc_name = path.join('.');
-        if (level>0) this._findResponderNamesFor(value, level-1, path);
-        path.pop();
-      }
-    }
-  },
-  /**
-    Makes the passed responder into the new firstResponder for this
-    responder context.  This will cause the current first responder to lose
-    its responder status and possibly keyResponder status as well.
-    When you change the first responder, this will send callbacks to
-    responders up the chain until you reach a shared responder, at which point
-    it will stop notifying.
-    @param {SC.Responder} responder
-    @param {Event} evt that cause this to become first responder
-    @returns {SC.ResponderContext} receiver
-  */
-  makeFirstResponder: function(responder, evt) {
-    var current = this.get('firstResponder'),
-        last    = this.get('nextResponder'),
-        trace   = this.get('trace'),
-        common ;
-    if (this._locked) {
-      if (trace) {
-        SC.Logger.log('%@: AFTER ACTION: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
-      }
-      this._pendingResponder = responder;
-      return ;
-    }
-    if (trace) {
-      SC.Logger.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
-    }
-    if (responder) responder.set("becomingFirstResponder", YES);
-    this._locked = YES;
-    this._pendingResponder = null;
-    // Find the nearest common responder in the responder chain for the new
-    // responder.  If there are no common responders, use last responder.
-    // Note: start at the responder itself: it could be the common responder.
-    common = responder ? responder : null;
-    while (common) {
-      if (common.get('hasFirstResponder')) break;
-      common = (common===last) ? null : this.nextResponderFor(common);
-    }
-    if (!common) common = last;
-    // Cleanup old first responder
-    this._notifyWillLoseFirstResponder(current, current, common, evt);
-    if (current) current.set('isFirstResponder', NO);
-    // Set new first responder.  If new firstResponder does not have its
-    // responderContext property set, then set it.
-    // but, don't tell anyone until we have _also_ updated the hasFirstResponder state.
-    this.beginPropertyChanges();
-    this.set('firstResponder', responder) ;
-    if (responder) responder.set('isFirstResponder', YES);
-    this._notifyDidBecomeFirstResponder(responder, responder, common);
-    // now, tell everyone the good news!
-    this.endPropertyChanges();
-    this._locked = NO ;
-    if (this._pendingResponder) {
-      this.makeFirstResponder(this._pendingResponder);
-      this._pendingResponder = null;
-    }
-    if (responder) responder.set("becomingFirstResponder", NO);
-    return this ;
-  },
-  _notifyWillLoseFirstResponder: function(responder, cur, root, evt) {
-    if (cur === root) return ; // nothing to do
-    cur.willLoseFirstResponder(responder, evt);
-    cur.set('hasFirstResponder', NO);
-    var next = this.nextResponderFor(cur);
-    if (next) this._notifyWillLoseFirstResponder(responder, next, root);
-  },
-  _notifyDidBecomeFirstResponder: function(responder, cur, root) {
-    if (cur === root) return ; // nothing to do
-    var next = this.nextResponderFor(cur);
-    if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
-    cur.set('hasFirstResponder', YES);
-    cur.didBecomeFirstResponder(responder);
-  },
-  /**
-    Re-enters the current responder (calling willLoseFirstResponder and didBecomeFirstResponder).
-  */
-  resetFirstResponder: function() {
-    var current = this.get('firstResponder');
-    if (!current) return;
-    current.willLoseFirstResponder();
-    current.didBecomeFirstResponder();
-  },
-  /**
-    Send the passed action down the responder chain, starting with the
-    current first responder.  This will look for the first responder that
-    actually implements the action method and returns YES or no value when
-    called.
-    @param {String} action name of action
-    @param {Object} sender object sending the action
-    @param {Object} context optional additonal context info
-    @returns {SC.Responder} the responder that handled it or null
-  */
-  sendAction: function(action, sender, context) {
-    var working = this.get('firstResponder'),
-        last    = this.get('nextResponder'),
-        trace   = this.get('trace'),
-        handled = NO,
-        responder;
-    this._locked = YES;
-    if (trace) {
-      SC.Logger.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
-    }
-    if (!handled && !working && this.tryToPerform) {
-      handled = this.tryToPerform(action, sender, context);
-    }
-    while (!handled && working) {
-      if (working.tryToPerform) {
-        handled = working.tryToPerform(action, sender, context);
-      }
-      if (!handled) {
-        working = (working===last) ? null : this.nextResponderFor(working);
-      }
-    }
-    if (trace) {
-      if (!handled) SC.Logger.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
-      else SC.Logger.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
-    }
-    this._locked = NO ;
-    if (responder = this._pendingResponder) {
-      this._pendingResponder= null ;
-      this.makeFirstResponder(responder);
-    }
-    return working ;
-  }
-};