sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/foundation/system/request.js

@@ -0,0 +1,380 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*global ActiveXObject */
+
+/**
+  Description to come.
+  
+  @since SproutCore 1.0
+*/
+
+SC.Request = SC.Object.extend({
+  
+  isAsynchronous: true,
+  rawResponse: null,
+  error: null,
+  transportClass: null,
+  isJSON: false,
+  
+  /**
+    Sets up the request object
+  */
+  init: function(){
+    sc_super() ;  
+    this._headers = {};
+  },
+  
+  /**
+    To set headers on the request object
+    
+    @param {String} key
+    @param {String} value
+    @returns {SC.Request} receiver
+  */
+  header: function(key, value) {
+    if (typeof key == 'object' && !value) {
+      for (var headerKey in key) {
+        this.header(headerKey,key[headerKey]) ;
+      }
+      return this;
+    }
+    
+    if (typeof key == 'string' && !value) {
+      return this._headers[key] ;
+    }
+    
+    this.propertyWillChange('headers') ;
+    
+    //set value for key
+    this._headers[key] = value ;
+    
+    this.propertyDidChange('headers') ;
+    return this ;
+  },
+  
+  /**
+    Will fire the actual request.
+    
+    @param {String} body (optional)
+    @returns {SC.Request} receiver
+  */  
+  send: function(body) {
+    var request = this ; 
+    if(body) {
+      if(this.get('isJSON')) {
+        body=SC.json.encode(body);
+        if(body===undefined) console.error('There was an error encoding to JSON');
+      }
+      request.set('body', body) ;
+    }
+    SC.Request.manager.sendRequest(request) ;
+    return request ;
+  },
+
+  /**
+    Set up notifications.
+    
+    @param {Object} target
+    @param {String|function} action
+    @param {Hash} params
+    @returns {SC.Request} receiver
+  */
+  notify: function(target, action, params) {
+    if (SC.typeOf(action) === SC.T_STRING) action = target[action];
+    this.set('notifyTarget', target)
+    .set('notifyAction', action)
+    .set('notifyParams', params);
+    return this;
+  },
+  
+  /**
+    Response method
+    
+    @returns {Object} response
+  */
+  response: function() {
+    var response = this.get("rawResponse") ;
+    if (!response || !SC.$ok(response) || response.responseText.trim()==='') {
+        return response ;
+    }
+    
+    if (this.get("isJSON")) {
+      var source = response.responseText ;
+      try{
+        var json = SC.json.decode(source) ;
+      }catch(e){
+        json = response.responseText ;
+      }
+      //TODO cache this value?
+      return json ;
+    }
+    
+    if(response.responseXML) return response.responseXML ;
+    return response.responseText ;
+  }.property('rawResponse').cacheable()
+  
+});
+
+/**
+  Helper method for quickly setting up a GET request.
+  
+  @param {String} address url of request
+  @returns {SC.Request} receiver
+*/
+SC.Request.getUrl = function(address) {
+  var req = SC.Request.create() ;
+  req.set('address', address) ;
+  req.set('type', 'GET') ;
+  
+  return req ;
+};
+
+/**
+  Helper method for quickly setting up a POST request.
+  
+  @param {String} address url of request
+  @param {String} body
+  @returns {SC.Request} receiver
+*/
+SC.Request.postUrl = function(address, body) {
+  var req = SC.Request.create() ;
+  req.set('address',address) ;
+  if(body) req.set('body', body) ;
+  req.set('type', 'POST') ;
+  
+  return req ;
+};
+
+/**
+  Helper method for quickly setting up a DELETE request.
+  
+  @param {String} address url of request
+  @returns {SC.Request} receiver
+*/
+SC.Request.deleteUrl = function(address) {
+  var req = SC.Request.create() ;
+  req.set('address',address) ;
+  req.set('type', 'DELETE') ;
+  
+  return req ;
+};
+
+/**
+  Helper method for quickly setting up a PUT request.
+  
+  @param {String} address url of request
+  @param {String} body
+  @returns {SC.Request} receiver
+*/
+SC.Request.putUrl = function(address, body) {
+  var req = SC.Request.create() ;
+  req.set('address',address) ;
+  if(body) req.set('body', body) ;
+  req.set('type', 'PUT') ;
+  
+  return req ;
+};
+
+/**
+  The request manager.
+  More description to come.
+*/
+SC.Request.manager = SC.Object.create( SC.DelegateSupport, {
+  maxRequests: 2,
+  
+  currentRequests: [],
+  queue: [],
+  
+  canLoadAnotherRequest: function() {
+    return (this.get('numberOfCurrentRequests') < this.get('maxRequests')) ;
+  }.property('numberOfCurrentRequests', 'maxRequests'),
+  
+  numberOfCurrentRequests: function() {
+    return this.get('currentRequests').length ;
+  }.property('currentRequests'),
+  
+  numberOfRequests: function() {
+    return this.get('queue').length ;
+  }.property('queue'),
+  
+  sendRequest: function(request) {
+    if(!request) return;
+    
+    request = { 
+      request: request, 
+      action:  request.get('notifyAction'),
+      target:  request.get('notifyTarget'),
+      params:  request.get('notifyParams') };
+    
+    this.propertyWillChange("queue");
+    this.get('queue').pushObject(request);
+    this.propertyDidChange("queue");
+    
+    this.fireRequestIfNeeded();
+  },
+  
+  removeRequest: function(request) {
+    this.get('queue').removeObject(request);
+    return YES;
+  },  
+  
+  cancelAllRequests: function() {
+    var r, xhrRequest;
+    this.set('queue', []);
+    var activeRequests=this.get('currentRequests');
+    while(r=activeRequests.popObject()){
+      xhrRequest = r.get('request');
+      xhrRequest.abort();
+    }
+    return YES;
+  },
+  
+  fireRequestIfNeeded: function() {
+    if (this.canLoadAnotherRequest()) {
+      this.propertyWillChange('queue') ;
+      var item = this.get('queue').popObject() ;
+      this.propertyDidChange('queue') ;
+      
+      if (item) {
+        var transportClass = item.request.get('transportClass') ;
+        if (!transportClass) transportClass = this.get('transportClass') ;
+        
+        if (transportClass) {
+          var transport = this.transportClass.create(item) ;
+          if (transport) {
+            item.request.set('transport', transport) ;
+            this._transportDidOpen(transport) ;
+          }
+        }
+      }
+    }
+  },
+  
+  _transportDidOpen: function(transport) {
+    this.propertyWillChange('currentRequests') ;
+    this.get('currentRequests').pushObject(transport) ;
+    this.propertyDidChange('currentRequests') ;
+    
+    transport.fire() ;
+  },
+  
+  transportDidClose: function(request) {
+    this.propertyWillChange('currentRequests') ;
+    this.get('currentRequests').removeObject(request) ;
+    this.propertyDidChange('currentRequests') ;
+  }
+  
+});
+
+// abstract superclass, creates no-op objects
+SC.RequestTransport = SC.Object.extend({
+  
+  fire: function() {
+    SC.Request.manager.transportDidClose(this) ;
+  }
+  
+});
+
+SC.XHRRequestTransport = SC.RequestTransport.extend({
+  
+  fire: function() {
+    
+    var tryThese = function() {
+      for (var i=0; i < arguments.length; i++) {
+        try {
+          var item = arguments[i]() ;
+          return item ;
+        } catch (e) {}
+      }
+      return NO;
+    };
+    
+    var rawRequest = tryThese(
+      function() { return new XMLHttpRequest(); },
+      function() { return new ActiveXObject('Msxml2.XMLHTTP'); },
+      function() { return new ActiveXObject('Microsoft.XMLHTTP'); }
+    );
+    
+    var request = this.get('request') ;
+    
+    rawRequest.source = request;
+    
+    
+    //Part of the fix for IE
+    var transport=this;
+    var handleReadyStateChange = function() {
+      return transport.finishRequest(rawRequest) ;
+    };
+    //End of the fix for IE
+    
+    var async = (request.get('isAsynchronous') ? YES : NO) ;
+    if (async) {
+      if (!SC.browser.msie) {
+        SC.Event.add(rawRequest, 'readystatechange', this, handleReadyStateChange, rawRequest) ;
+      } else rawRequest.onreadystatechange = handleReadyStateChange;
+    }
+    
+    
+    
+    rawRequest.open( request.get('type'), request.get('address'), async ) ;
+    
+    // headers need to be set *After* the open call.
+    var headers = request._headers ;
+    for (var headerKey in headers) {
+      rawRequest.setRequestHeader(headerKey, headers[headerKey]) ;
+    }
+    
+    rawRequest.send(request.get('body')) ;
+    
+    if (!async) this.finishRequest(rawRequest) ;
+    
+    return rawRequest ;
+  },
+  
+  didSucceed: function(request) {
+    var status = null ;
+    try {
+        status = request.status || 0;
+    } catch (e) {}
+    return !status || (status >= 200 && status < 300) ;      
+  },
+  
+  finishRequest: function(request) {
+    
+    var readyState = request.readyState ;
+    var didSucceed = !request ? NO : this.didSucceed(request) ;
+    
+    if (readyState == 4) {
+      request._complete = YES ;
+      
+      if (didSucceed) {
+        var response = request ;
+        request.source.set('rawResponse', response) ; 
+      } else {
+        var error = SC.$error("HTTP Request failed", "Fail", -1) ;
+        error.set("request",request) ;
+        request.source.set('rawResponse', error) ;
+      }
+      if (this.target && this.action) {
+        SC.RunLoop.begin();
+        this.action.call(this.target, request.source, this.params);
+        SC.RunLoop.end();
+      }
+      
+      SC.Request.manager.transportDidClose(this) ;
+     }
+     
+     if (readyState == 4) {
+       // avoid memory leak in MSIE: clean up
+       request.onreadystatechange = function() {} ;
+     }
+  }
+
+  
+});
+
+SC.Request.manager.set('transportClass', SC.XHRRequestTransport) ;

data/frameworks/sproutcore/frameworks/foundation/system/responder.js

@@ -0,0 +1,120 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/** @class
+
+  Provides common methods for sending events down a responder chain.
+  Responder chains are used most often to deliver events to user interface
+  elements in your application, but you can also use them to deliver generic
+  events to any part of your application, including controllers.
+
+  @extends SC.Object
+  @since SproutCore 1.0
+*/
+SC.Responder = SC.Object.extend( /** SC.Responder.prototype */ {
+
+  isResponder: YES,
+  
+  /** @property
+    The pane this responder belongs to.  This is used to determine where you 
+    belong to in the responder chain.  Normally you should leave this property
+    set to null.
+  */
+  pane: null,
+  
+  /** @property
+    The app this responder belongs to.  For non-user-interface responder 
+    chains, this is used to determine the context.  Usually this
+    is the property you will want to work with.
+  */
+  responderContext: null,
+  
+  /** @property
+    This is the nextResponder in the responder chain.  If the receiver does 
+    not implement a particular event handler, it will bubble to the next 
+    responder.
+    
+    This can point to an object directly or it can be a string, in which case
+    the path will be resolved from the responderContext root.
+  */
+  nextResponder: null,
+  
+  /** @property 
+    YES if the view is currently first responder.  This property is always 
+    edited by the pane during its makeFirstResponder() method.
+  */
+  isFirstResponder: NO,
+  
+  /** @property
+  
+    YES the responder is somewhere in the responder chain.  This currently
+    only works when used with a ResponderContext.
+    
+    @type {Boolean}
+  */
+  hasFirstResponder: NO,    
+  
+  /** @property
+    Set to YES if your view is willing to accept first responder status.  This is used when calculcating key responder loop.
+  */
+  acceptsFirstResponder: YES,
+  
+  /** 
+    Call this method on your view or responder to make it become first 
+    responder.
+    
+    @returns {SC.Responder} receiver
+  */
+  becomeFirstResponder: function() {  
+    var pane = this.get('pane') || this.get('responderContext');
+    if (pane && this.get('acceptsFirstResponder')) {
+      if (pane.get('firstResponder') !== this) pane.makeFirstResponder(this);
+    } 
+    return this ;
+  },
+  
+  /**
+    Call this method on your view or responder to resign your first responder 
+    status. Normally this is not necessary since you will lose first responder 
+    status automatically when another view becomes first responder.
+    
+    @returns {SC.Responder} receiver
+  */
+  resignFirstResponder: function() {
+    var pane = this.get('pane') || this.get('responderContext');
+    if (pane && (pane.get('firstResponder') === this)) {
+      pane.makeFirstResponder(null);
+    }
+    return YES;  
+  },
+
+  /**
+    Called just before the responder or any of its subresponder's are about to
+    lose their first responder status.  The passed responder is the responder
+    that is about to lose its status. 
+    
+    Override this method to provide any standard teardown when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that is about to change
+    @returns {void}
+  */
+  willLoseFirstResponder: function(responder) {},
+  
+  /**
+    Called just after the responder or any of its subresponder's becomes a 
+    first responder.  
+    
+    Override this method to provide any standard setup when the first 
+    responder changes.
+    
+    @param {SC.Responder} responder the responder that changed
+    @returns {void}
+  */
+  didBecomeFirstResponder: function(responder) {}
+
+});