RubyGems - sproutit-sproutcore - Versions diffs - 1.0.20090721145236 → 1.0.20090721145251 - Mend

sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

Files changed (933) hide show

data/frameworks/sproutcore/frameworks/deprecated/lib/index.rhtml ADDED Viewed

@@ -0,0 +1,75 @@
+<% # SPROUTCORE DEFAULT INDEX TEMPLATE
+   # This template provide provides a basic wrapper for a SproutCore client.
+   # Most of the time, it will be sufficient for your own needs.  However, if
+   # you need to create your own template, you can do so by copying this file
+   # into your client, naming it 'index.rhtml' and then adding the options
+   # :index => 'index' to your client declaration in routes.rb.
+   #
+   # See the comments in this file for more information on what you can
+   # change.
+-%>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+<%  # @title will be defined if you passed :title in routes.rb -%>
+    <title><%= (@title.to_s || bundle_name.to_s || '').capitalize %></title>
+<% #
+	 # This line should appear in your head area to include the stylesheets
+	 # generated by your client.  If you need to include your own
+	 # stylesheets, you don't need to change it here.  Instead, use the
+	 # :requires option in routes.rb.
+-%>
+    <script src="<%= static_url('detect-browser') %>" type="text/javascript"></script>
+    <%= stylesheets_for_client %>
+<%= @content_for_page_styles %>
+  </head>
+  <body class="<%= @theme || 'sc-theme' %> focus">
+    <script type="text/javascript">
+    var SC; if (!SC) SC = {} ;
+    if (SC.setupBodyClassNames) SC.setupBodyClassNames() ;
+    </script>
+<% #
+   # This is where you root body element will appear.  To cause your
+   # content to appear here, just declare content_for('body') in one of
+   # your partials.
+-%>
+    <!-- Main Page Body -->
+    <%= @content_for_body %>
+<% #
+   # This is where the resources you delcare will appear.  You must
+   # include the following three lines verbatim for the resources you
+   # declare to be properly used.
+-%>
+    <!-- Resources to be removed from DOM on page load -->
+    <div id="resources" style="display:none; visibility: hidden;">
+      <%= @content_for_resources -%>
+    </div>
+<% #
+   # This line should appear at the bottom of your page to include your
+   # generated JavaScript and any libraries you reference.  If you need
+   # to include other javascripts, add them to the :requires option of
+   # your client in routes.rb instead of changing it here.
+-%>
+    <!-- Include Site Javascript -->
+    <%= javascripts_for_client %>
+<%= @content_for_page_javascript %>
+<% #
+   # The following lines to the closing body tag must be included at the
+   # very end of your file.  This will actually setup the JavaScript
+   # views on your page and register SproutCore to start on page load.
+-%>
+<!-- Render Page Views -->
+<%= render_page_views %>
+    <!-- Start SproutCore on Page Load -->
+    <script type="text/javascript">window.onload = SC.didLoad;</script>
+<%= @content_for_final %>
+	</body>
+</html>

data/frameworks/sproutcore/frameworks/deprecated/lib/menu_views.rb ADDED Viewed

@@ -0,0 +1,93 @@
+############################################################
+# MENU VIEW HELPERS
+#
+# The view helpers defined in this file help you create popup menus.  You can
+# define a menu in your RHTML helper to be used somewhere else with code like
+# this:
+#
+# This is the quick way to define a menu item.  Use this approach if you just
+# want to create a menu with item names and perform an action:
+#
+# <% menu_view :action_menu, :validate=>'My.controller.validate' do |m| %>
+#   <%= m.item :item_1, 'Item 1', :action => 'doSomething' %>
+#   <%= m.separator_item %>
+#   <%= m.item :item_2, 'Item 2', :action => 'doAnother Thing' %>
+# <% end %>
+#
+require_helpers 'core_views'
+require_helpers 'button_views'
+# This will create a popup menu.  You should define internal outlets
+# for the menu items.  More options to follow.
+view_helper :popup_menu_view do
+  var :tag, 'ul'
+  view 'SC.PopupMenuView'
+end
+# Creates a menu item view.  Normally you don't want to create these
+# directly.  Instead use the menu_view helpers.
+#
+# OPTIONS:
+# :action =>
+#   The action to invoke when the menu item is selected.
+#
+# :label =>
+#   The label for the menu item.
+#
+# :icon =>
+#   The icon for the menu item.  No icon will show if this is not set.
+#
+# :shortcut =>
+#   You must pass the actualy bit of HTML you want to display as a keyboard
+#   shortcut
+#
+#   THE FOLLOWING PREVIOUS BEHAVIOR IS CURRENTLY DISABLED
+#   The shortcut key for this menu item.  Shortcuts are only active when
+#   the anchorview the popup menu is attached to is part of the in-focus
+#   pane.  Shortcuts should be named in the standard input manager
+#   syntax like this: alt_ctrl_shift_k (for Alt-Ctrl-Shift-K)
+#
+#   Note that on the web, Cmd (on the Mac) and Ctrl are equivalent.
+#   Always use ctrl when defining shortcuts.
+#
+# :enabled (bindable) =>
+#   Determines if the menu item will be enabled or not.  This is generally
+#   handled by your validate method or through bindings.
+#
+# :selected (bindable) =>
+#   Determines if the menu item is selected or not.  May also be a mixed
+#   state.  This is generally handled by your validate method or through
+#   bindings.
+#
+# :alt =>
+#   name another item in this menu that is the alternate form of the
+#   receiver.  If the alt item is enabled, this one will be hidden and
+#   visa versa.
+#
+view_helper :menu_item_view, :extends => :button_view do
+  # JavaScript
+  view 'SC.MenuItemView'
+  # HTML
+  var :tag, 'li'
+  var :shortcut
+  # var(:shortcut) { |sc| sc.split('_').map { |x| x.capitalize } * '-' }
+  css_class_names << 'menu-item'
+  @my_href = @href || 'javascript:;'
+  @href = nil
+  @inner_html = [
+    %(<a href="#{@my_href}">),
+      '<span class="inner">',
+        @image,
+        %(<span class="label">#{@label}</span>),
+      '</span>',
+      '<span class="sel">&#x2713;</span>',
+      '<span class="mixed">-</span>',
+      %(<span class="shortcut">#{@shortcut}</span>),
+    '</a>'
+  ] * ''
+end

data/frameworks/sproutcore/frameworks/deprecated/server/rails_server.js ADDED Viewed

@@ -0,0 +1,80 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+require('server/rest_server') ;
+/**
+  @class
+  This server extends SC.RestServer and leverages Rails feature to protect
+  your controller actions from CSRF attacks by using the authenticity token
+  from rails in requests from SproutCore. For more information about this
+  feature from Rails see the documentation in rails for module
+  ActionController::RequestForgeryProtection.
+  To use this server create it like for example:
+  {{{
+    Contacts = SC.Object.create({
+      server: SC.RailsServer.create({ prefix: ['Contacts'] })
+    }) ;
+  }}}
+  In order for SproutCore to send the authenticity token in the body of
+  requests there is one prerequisite: you must initialize the SproutCore app
+  by setting the following two variables:
+  | SC.RAILS_AUTH_TOKEN_NAME  | Should be set to the name of the authenticity token |
+  | SC.AUTH_TOKEN | Should be set to the value of the authenticity token |
+  Following is a description of how this can be achieved. Stick the following
+  code in one of your controllers:
+  {{{
+    # Passes the authenticity token for use in javascript
+    def auth_token
+      respond_to do |wants|
+        wants.js do
+          if protect_against_forgery?
+            render :text => "var SC = SC || {};
+              SC.RAILS_AUTH_TOKEN_NAME = '#{request_forgery_protection_token}';
+              SC.RAILS_AUTH_TOKEN = '#{form_authenticity_token}';"
+          end
+        end
+      end
+    end
+  }}}
+  And make it accessible via your rails routes.rb file, for example:
+  {{{
+    map.connect 'auth-token.js', :controller => 'application', :action => 'auth_token'
+  }}}
+  Lastly, add a reference to the script to the :javascript_libs property
+  in your sc-config file, for example:
+  {{{
+    c[:javascript_libs] = ['/sc/auth-token.js']
+  }}}
+  @extends SC.RestServer
+  @author Lawrence Pit
+  @copyright 2006-2008, Sprout Systems, Inc. and contributors.
+  @since SproutCore 1.0
+*/
+SC.RailsServer = SC.RestServer.extend({
+  urlFor: function(resource, action, ids, params, method) {
+    if (method != 'get' && SC.RAILS_AUTH_TOKEN_NAME) {
+      params[SC.RAILS_AUTH_TOKEN_NAME] = SC.RAILS_AUTH_TOKEN;
+    }
+    return sc_super();
+  }
+}) ;

data/frameworks/sproutcore/frameworks/deprecated/server/rest_server.js ADDED Viewed

@@ -0,0 +1,178 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+require('server/server') ;
+/**
+  @class
+  Usually you wouldn't need to call any of the methods on this class or it's
+  superclass, except for calling the +listFor+ method. The other methods are
+  called for you when you work with your model objects. For example, calling
+  myObject.commit(); will call the commitRecords method on this server if you
+  had defined this server to be to the +dataSource+ of myObject.
+  To have an SC model reflect data on a backend server attach an instance of
+  this class to your application. For example:
+  {{{
+    Contacts = SC.Object.create({
+      server: SC.RestServer.create({ prefix: ['Contacts'] })
+    }) ;
+  }}}
+  Then attach that server as the +dataSource+ to each model class that you
+  want to have reflected. Also define a +resourceURL+ which defines the URL
+  where the collection of your model can be queried. For example:
+  {{{
+    Contacts.Contact = SC.Record.extend(
+      dataSource: Contacts.server,
+      resourceURL: 'sc/contacts',
+      properties: ['guid','firstName','lastName'],
+      primaryKey: 'guid'
+    }) ;
+  }}}
+  When you work with your models, behind the scenes SC will use 5 main methods
+  on this server. Each is listed below, together with the HTTP method used in
+  the call to the backend server and the URL that is being called. The URL is
+  based on the example given above.
+      listFor             GET    /sc/contacts
+      createRecords       POST   /sc/contacts
+      refreshRecords
+      for one record      GET    /sc/contacts/12345
+      refreshRecords
+      for many records    GET    /sc/contacts?ids=1,2,3,4,5,6
+      commitRecords
+      for one record      PUT    /sc/contacts/12345
+      commitRecords
+      for many records    PUT    /sc/contacts?ids=1,2,3,4,5
+      destroyRecords
+      for one record      DELETE /sc/contacts/12345
+      destroyRecords
+      for many records    DELETE /sc/contacts?ids=1,2,3,4,5
+  The above is the default behaviour of this server. If you want different
+  URLs to be generated then extend this class and override the +urlFor+
+  method.
+  Another way to override the above is to tell SC where member resources can
+  be refreshed, committed and destroyed. For example, when SC calls
+  {{{
+    GET /sc/contacts
+  }}}
+  you could reply as follows:
+  {{{
+    records: [
+      {  guid: '123',
+        type: "Contact",
+        refreshURL: "/contacts?refresh=123",
+        updateURL: "/contacts/123?update=Y",
+        destroyURL: "/contacts/123",
+        firstName: "Charles",
+        ...
+      }],
+      ...
+    }
+  }}}
+  Then when contact 123 needs to be refreshed later on by SC, it will call:
+  {{{
+    GET /contacts?refresh=123
+  }}}
+  instead of GET /contacts/123. Note that this only works for members on your
+  resource. If a collection of contacts needed to be refreshed it would still
+  call for example GET /contacts?id=123,456,789 instead of making 3 separate
+  calls.
+  Because some browsers cannot actually perform an HTTP PUT or HTTP DELETE it
+  will actually perform an HTTP POST but will put an additional key,value pair
+  in the post data packet. For HTTP PUT it will add _method='put' and for
+  HTTP DELETE it will add _method='delete' in the post data.
+  Via the SC.Server#request method you can also call collection and member
+  functions on your resource. Use the +action+ parameter for this. For
+  example, server.request('contacts', 'archive', null, params, 'delete')
+  would call:
+  {{{
+    DELETE /contacts/archive
+  }}}
+  And server.request('contacts', 'give', [12345], {'amount': 1000}, 'put')
+  would call:
+  {{{
+   PUT /contacts/12345/give
+  }}}
+  with post data amount=1000.
+  Alternatively explicitely define the URL to use by setting the +url+
+  property in the +params+ argument that is passed to the server.request
+  method. For example:
+  {{{
+    Contacts.server.request(null,null,null, {url: '/sc/archive'}, 'delete')
+  }}}
+  would call:
+  {{{
+    DELETE /sc/archive
+  }}}
+  @extends SC.Server
+  @author Lawrence Pit
+  @copyright 2006-2008, Sprout Systems, Inc. and contributors.
+  @since SproutCore 1.0
+*/
+SC.RestServer = SC.Server.extend({
+  /**
+    @see SC.Server.urlFor
+  **/
+  urlFor: function(resource, action, ids, params, method) {
+    url = resource;
+    if (ids && ids.length == 1) url = url + '/' + ids[0];
+    if (action && action != '') url = url + '/' + action;
+    return url;
+  },
+  /* privates, overrides the values in SC.Server */
+  _listForAction: '',
+  _listForMethod: 'get',
+  _createAction: '',
+  _createMethod: 'post',
+  _refreshAction: '',
+  _refreshMethod: 'get',
+  _commitAction: '',
+  _commitMethod: 'put',
+  _destroyAction: '',
+  _destroyMethod: 'delete'
+}) ;

data/frameworks/sproutcore/frameworks/deprecated/server/server.js ADDED Viewed

@@ -0,0 +1,673 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+require('core') ;
+SC.URL_ENCODED_FORMAT = 'url-encoded' ;
+SC.JSON_FORMAT = 'json';
+// The Server object knows how to send requests to the server and how to
+// get things back from the server.  It automatically handles situations
+// such as 304 caching and queuing requests to send to the server later if
+// the computer becomes disconnected from the internet.
+// The Server object is designed to work with a resource oriented application.
+// That is, you do someting like this:
+//
+// Server.request('resource','verb',{ parameters })
+// or
+// Server.create('resource',{ parameters })
+// Server.refresh('resource',{ parameters })
+// Server.update('resource',{ parameters })
+// Server.destroy('resource',{ parameters })
+//
+// parameters include:
+// onSuccess -- passes back returned text
+// onFailure --
+//
+//
+// SC.Record.refresh
+// SC.Record.commit --> create/update
+// SC.Record.destroy
+SC.Server = SC.Object.extend({
+  // Set this to the prefix for your app.  Server will use this to convert
+  // record_type properties into recordTypes.
+  prefix: null,
+  // Set this string to the format to be used to set your resource and verb.
+  urlFormat: '/%@/%@',
+  // Set this string to either rails or json to set the post transport protocol
+  postFormat: SC.URL_ENCODED_FORMAT,
+  // Set this string to true when escaping the JSON string is necessary
+  escapeJSON: true,
+  // call this in your main to preload any data sent from the server with the
+  // initial page load.
+  preload: function(clientData) {
+    if ((!clientData) || (clientData.size == 0)) return ;
+    this.refreshRecordsWithData(clientData,SC.Record,null,false);
+  },
+  // This is the root method for accessing a server resource.  Pass in the
+  // resource URL, verb name, and any parameters.  There are several special-
+  // purpose parameters used also:
+  //
+  // onSuccess -- function invoked when request completes. Expects the format
+  //              didSucceed(status,ajaxRequest,cacheCode,context)
+  // onFailure -- function invoked when request fails. Same format.
+  // requestContext -- simply passed back.
+  // cacheCode -- String indicating the time of the last refresh.
+  // url -- override the default url building with this url.
+  //
+  request: function(resource, action, ids, params, method) {
+    // Get Settings and Options
+    if (!params) params = {} ;
+    var opts = {} ;
+    var onSuccess = params.onSuccess; delete params.onSuccess;
+    var onNotModified = params.onNotModified; delete params.onNotModified ;
+    var onFailure = params.onFailure ; delete params.onFailure ;
+    var context = params.requestContext ; delete params.requestContext ;
+    var accept = params.accept ; delete params.accept ;
+    var cacheCode = params.cacheCode; delete params.cacheCode ;
+    // enable JSON for every operation
+    var records = params.records ;
+    if ((this.get('postFormat') == SC.JSON_FORMAT) && records) {
+      params.records = (this.get('escapeJSON')) ? escape(records.toJSONString()) : records.toJSONString() ;
+    }
+    var url = params.url; delete params.url;
+    opts.requestHeaders = {'Accept': 'application/json, text/javascript, application/xml, text/xml, text/html, */*'} ;
+    if (accept) opts.requestHeaders['Accept'] = accept ;
+    if (cacheCode) opts.requestHeaders['Sproutit-Cache'] = cacheCode ;
+    opts.method = method || 'get' ;
+    if (!url) url = this.urlFor(resource, action, ids, params, opts.method) ;
+    // handle ids
+    if (ids && ids.length > 1) {
+      params.ids = [ids].flatten().join(',') ;
+    }
+    // adds a custom HTTP header for remote requests
+    opts.requestHeaders = {'X-SproutCore-Version' : '1.0'} ;
+    // convert parameters.
+    var parameters = this._toQueryString(params) ;
+    if (parameters && parameters.length > 0) opts.parameters = parameters ;
+    var request ; // save for later
+    // Save callback functions.
+    opts.onSuccess = function(request) {
+      // var cacheCode = request.getHeader('Last-Modified') ;
+      // if ((transport.status == '200') && (transport.responseText == '304 Not Modified')) {
+      //   if (onNotModified) onNotModified(transport.status, transport, cacheCode,context);
+      // } else {
+        if (onSuccess) onSuccess(request.status, request, cacheCode,context);
+      // }
+    } ;
+    opts.onFailure = function(request) {
+      // var cacheCode = request.getHeader('Last-Modified') ;
+      if (onFailure) onFailure(request.status, request, cacheCode,context);
+    } ;
+    console.log('REQUEST: %@ %@'.fmt(opts.method, url)) ;
+    var that = this ;
+    var processRequestChange = function() {
+      if (request.readyState == 4) {
+          if (request.status == 200) opts.onSuccess.apply(that, [request]) ;
+          else opts.onFailure.apply(that, [request]) ;
+      }
+    };
+    var ajaxRequest = function(url, opts) {
+      var opts = opts || {} ;
+      request = false;
+      if (window.XMLHttpRequest && !(window.ActiveXObject)) {
+        try {
+          request = new XMLHttpRequest();
+        } catch(e) {
+          request = false;
+        }
+      // branch for IE/Windows ActiveX version
+      } else if (window.ActiveXObject) {
+        try {
+          request = new ActiveXObject("Msxml2.XMLHTTP");
+        } catch(e) {
+          try {
+            request = new ActiveXObject("Microsoft.XMLHTTP");
+          } catch(e) {
+            request = false;
+          }
+        }
+      }
+      if (request) {
+        request.onreadystatechange = processRequestChange ;
+        request.open(opts.method, url, true) ;
+        request.send(opts.parameters || '') ;
+      }
+    }
+    ajaxRequest(url, opts) ;
+  },
+  /**
+    Generates the URL that is going to be called by this server. Note that you
+    should only return relative URLs. You can only call resources that are on
+    the same domain as where this script was downloaded from.
+    @param {String} resource  the URL where the collection of the resource can be queried
+    @param {String} action    the action that should be performed on the resource
+    @param {Array} ids        array of identifiers of your model instances
+    @param {Array} params     parameters that were passed to the SC.Server#request method
+    @param {String} method    the HTTP method that will be used
+    @returns {String} the URL to use in the request to the backend server
+  **/
+  urlFor: function(resource, action, ids, params, method) {
+    var idPart = (ids && ids.length == 1) ? ids[0] : '';
+    return this.urlFormat.format(resource, action) + idPart;
+  },
+  // RECORD METHODS
+  // These methods do the basic record changes.
+  // ..........................................
+  // LIST
+  // This is the method called by a collection to get an updated list of
+  // records.
+  listFor: function(opts) {
+    var recordType = opts.recordType ;
+    var resource = recordType.resourceURL() ;
+    if (!resource) return false ;
+    var order = opts.order || 'id' ;
+    if (!(order instanceof Array)) order = [order] ;
+    order = order.map(function(str){
+      return str.decamelize() ; //rubyify
+    }).join(',') ;
+    params = {} ;
+    if (opts.conditions) {
+      var conditions = this._decamelizeData(opts.conditions) ;
+      for(var key in conditions) {
+        params[key] = conditions[key] ;
+      }
+    }
+    params.requestContext = opts ;
+    params.onSuccess = this._listSuccess.bind(this) ;
+    params.onNotModified = this._listNotModified.bind(this) ;
+    params.onFailure = this._listFailure.bind(this) ;
+    if (opts.cacheCode) params.cacheCode = opts.cacheCode ;
+    if (opts.offset) params.offset = opts.offset;
+    if (opts.limit) params.limit = opts.limit ;
+    if (order) params.order = order ;
+    this.request(resource, this._listForAction, null, params, this._listMethod) ;
+  },
+  _listForAction: 'list',
+  _listMethod: 'get',
+  _listSuccess: function(status, transport, cacheCode, context) {
+    var json = eval('json='+transport.responseText) ;
+    if (!json) { console.log('invalid json!'); return; }
+    // first, build any records passed back
+    if (json.records) {
+      this.refreshRecordsWithData(json.records,context.recordType,cacheCode,false);
+    }
+    // next, convert the list of ids into records.
+    var recs = (json.ids) ? json.ids.map(function(guid) {
+      return SC.Store.getRecordFor(guid,context.recordType) ;
+    }) : [] ;
+    // now invoke callback
+    if (context.callback) context.callback(recs,json.count,cacheCode) ;
+  },
+  _listNotModified: function(status, transport, cacheCode, context) {
+    if (context.callback) context.callback(null,null,null) ;
+  },
+  _listFailure: function(status, transport, cacheCode, records) {
+    console.log('listFailed!') ;
+  },
+  // ..........................................
+  // CREATE
+  // send the records back to create them. added a special parameter to
+  // the hash for each record, _guid, which will be used onSuccess.
+  createRecords: function(records) {
+    if (!records || records.length == 0) return ;
+    records = this._recordsByResource(records) ; // sort by resource.
+    for(var resource in records) {
+      if (resource == '*') continue ;
+      var curRecords = records[resource] ;
+      // collect data for records
+      var server = this ; var context = {} ;
+      var data = curRecords.map(function(rec) {
+        var recData = server._decamelizeData(rec.getPropertyData()) ;
+        recData._guid = SC.guidFor(rec) ;
+        context[SC.guidFor(rec)] = rec ;
+        return recData ;
+      }) ;
+      // issue request
+      this.request(resource, this._createAction, null, {
+        requestContext: context,
+        onSuccess: this._createSuccess.bind(this),
+        onFailure: this._createFailure.bind(this),
+        records: data
+      }, this._createMethod) ;
+    }
+  },
+  _createAction: 'create',
+  _createMethod: 'post',
+  // This method is called when a create is successful.  It first goes through
+  // and assigns the primaryKey to each record.
+  _createSuccess: function(status, transport, cacheCode, context) {
+    var json = eval('json='+transport.responseText) ;
+    if (!(json instanceof Array)) json = [json] ;
+    // first go through and assign the primaryKey to each record.
+    if (!context) context = {} ;
+    json.forEach(function(data) {
+      var guid = SC.guidFor(data) ;
+      var rec = (guid) ? context[guid] : null ;
+      if (rec) {
+        var pk = rec.get('primaryKey') ;
+        var dataKey = (pk == 'guid') ? 'id' : pk.decamelize().toLowerCase().replace(/\-/g,'_') ;
+        rec.set(pk,data[dataKey]) ;
+        rec.set('newRecord',false) ;
+      }
+    }) ;
+    // now this method will work so go do it.
+    this.refreshRecordsWithData(json,context._recordType,cacheCode,true) ;
+  },
+  _createFailure: function(status, transport, cacheCode, records) {
+    console.log('createFailed!') ;
+  },
+  // ..........................................
+  // REFRESH
+  refreshRecords: function(records) {
+    if (!records || records.length == 0) return ;
+    records = this._recordsByResource(records) ; // sort by resource.
+    for(var resource in records) {
+      if (resource == '*') continue ;
+      var curRecords = records[resource] ;
+      // collect resource ids, sort records into hash, and get cacheCode.
+      var cacheCode = null ; var ids = [] ; var context = {} ;
+      var primaryKey = curRecords[0].get('primaryKey') ; // assumes all the same
+      curRecords.forEach(function(r) {
+        cacheCode = cacheCode || r._cacheCode ;
+        var key = r.get(primaryKey);
+        if (key) { ids.push(key); context[key] = r; }
+      });
+      context._recordType = this._instantiateRecordType(curRecords[0].get('type'), this.prefix, null) ; // default rec type.
+      params = {
+        requestContext: context,
+        cacheCode: ((cacheCode=='') ? null : cacheCode),
+        onSuccess: this._refreshSuccess.bind(this),
+        onFailure: this._refreshFailure.bind(this)
+      };
+      if (ids.length == 1 && curRecords[0].refreshURL) params['url'] = curRecords[0].refreshURL;
+      // issue request
+      this.request(resource, this._refreshAction, ids, params, this._refreshMethod) ;
+    }
+  },
+  _refreshAction: 'show',
+  _refreshMethod: 'get',
+  // This method is called when a refresh is successful.  It expects an array
+  // of hashes, which it will convert to records.
+  _refreshSuccess: function(status, transport, cacheCode, context) {
+    var json = eval('json='+transport.responseText) ;
+    if (!(json instanceof Array)) json = [json] ;
+    this.refreshRecordsWithData(json,context._recordType,cacheCode,true) ;
+  },
+  _refreshFailure: function(status, transport, cacheCode, records) {
+    console.log('refreshFailed!') ;
+  },
+  // ..........................................
+  // COMMIT
+  commitRecords: function(records) {
+    if (!records || records.length == 0) return ;
+    records = this._recordsByResource(records) ; // sort by resource.
+    for(var resource in records) {
+      if (resource == '*') continue ;
+      var curRecords = records[resource] ;
+      // collect data for records
+      var server = this ;
+      // start format differences
+      var data = null;
+      switch(this.get('postFormat')){
+        case SC.URL_ENCODED_FORMAT:
+          data = curRecords.map(function(rec) {
+            return server._decamelizeData(rec.getPropertyData()) ;
+          }) ;
+          break;
+        case SC.JSON_FORMAT:
+          // get all records and put them into an array
+          var objects = [];
+          for(rec in curRecords){
+            if (!curRecords.hasOwnProperty(rec)) continue ;
+            objects.push(curRecords[rec].get('attributes') || {});
+          }
+          // convert to JSON and escape if this.escapeJSON is true
+          if(this.get('escapeJSON')){
+            data = escape(objects.toJSONString());
+          } else {
+            data = objects.toJSONString();
+          }
+          break;
+        default:
+          break;
+      }
+      // end format differences
+      if (data) {
+        var ids = [];
+        if (curRecords.length == 1) {
+          var primaryKey = curRecords[0].get('primaryKey') ;
+          var key = curRecords[0].get(primaryKey);
+          if (key) ids.push(key);
+        }
+        params = {
+          requestContext: records,
+          onSuccess: this._commitSuccess.bind(this),
+          onFailure: this._commitFailure.bind(this),
+          records: data
+        };
+        if (ids.length == 1 && curRecords[0].updateURL) params['url'] = curRecords[0].updateURL;
+        // issue request
+        this.request(resource, this._commitAction, ids, params, this._commitMethod) ;
+      }
+    }
+  },
+  _commitAction: 'update',
+  _commitMethod: 'post',
+  // This method is called when a refresh is successful.  It expects an array
+  // of hashes, which it will convert to records.
+  _commitSuccess: function(status, transport, cacheCode, context) {
+    var json = eval('json='+transport.responseText) ;
+    if (!(json instanceof Array)) json = [json] ;
+    this.refreshRecordsWithData(json,context._recordType,cacheCode,true) ;
+  },
+  _commitFailure: function(status, transport, cacheCode, records) {
+    console.log('commitFailed!') ;
+  },
+  // ..........................................
+  // DESTROY
+  destroyRecords: function(records) {
+    if (!records || records.length == 0) return ;
+    records = this._recordsByResource(records) ; // sort by resource.
+    for(var resource in records) {
+      var curRecords = records[resource] ;
+      if (resource == '*') {
+        curRecords.forEach(function(rec){
+          rec.set('isDeleted',true) ;
+          SC.Store.removeRecord(rec) ;
+        });
+        continue ;
+      }
+      // collect resource ids, sort records into hash, and get cacheCode.
+      var ids = [] ; var key ;
+      var primaryKey = curRecords[0].get('primaryKey') ;
+      curRecords.forEach(function(rec) {
+        if ((key = rec.get(primaryKey)) && (!rec.get('newRecord'))) {
+          ids.push(key) ;
+        }
+        rec.set('isDeleted',true) ;
+        SC.Store.removeRecord(rec) ;
+      }) ;
+      // issue request -- we may not have ids to send tho (for ex, if all
+      // records were newRecords.)
+      if (ids && ids.length > 0) {
+        params = {
+          requestContext: records,
+          onSuccess: this._destroySuccess.bind(this),
+          onFailure: this._destroyFailure.bind(this)
+        };
+        if (ids.length == 1 && curRecords[0].destroyURL) params['url'] = curRecords[0].destroyURL;
+        this.request(resource, this._destroyAction, ids, params, this._destroyMethod) ;
+      }
+    }
+  },
+  _destroyAction: 'destroy',
+  _destroyMethod: 'post',
+  _destroySuccess: function(status, transport, cacheCode, records) {
+    console.log('destroySuccess!') ;
+  },
+  _destroyFailure: function(status, transport, cacheCode, records) {
+    console.log('destroyFailed!') ;
+  },
+  // ..........................................
+  // SUPPORT
+  // This method is called by the various handlers once they have extracted
+  // their data.
+  refreshRecordsWithData: function(dataAry,recordType,cacheCode,loaded) {
+    var server = this ;
+    // Loop through the data Array and prepare each element
+    var prepedDataAry = [];
+    for (var idx = 0; idx < dataAry.length; idx++)
+    {
+      var currElem = server._prepareDataForRecords(dataAry[idx], server, recordType);
+      if (currElem !== null) prepedDataAry.push(currElem);
+    }
+    // now update.
+    SC.Store.updateRecords(prepedDataAry,server,recordType,loaded) ;
+  },
+  // ................................
+  // PRIVATE METHODS
+  _prepareDataForRecords: function(data, server, defaultType) {
+    if (data === null) {
+        return null;
+    } else if (SC.typeOf(data) == SC.T_ARRAY) {
+      var that = this;
+      return data.map( function(d) {
+        return that._prepareDataForRecords(d, server, defaultType) ;
+      }) ;
+    } else if (SC.typeOf(data) == SC.T_HASH) {
+      data = server._camelizeData(data) ; // camelize the keys received back.
+      if (data.id) {
+        // convert the 'id' property to 'guid'
+        data.guid = data.id;
+        delete data.id;
+      }
+      data.recordType = server._instantiateRecordType(data.type, server.prefix, defaultType);
+      if (data.recordType) {
+        return data;
+      } else {
+        console.log("Data RecordType could not be instantiated!: "+data.type) ;
+        return null; // could not process.
+      }
+    } else {
+      console.log("Unknown data type in SC.Server#_prepareDataForRecords. Should be array or hash.") ;
+      return null; // could not process.
+    }
+  },
+  _instantiateRecordType: function(recordType, prefix, defaultType) {
+    if (recordType) {
+      var recordName = recordType.capitalize() ;
+      if (prefix) {
+        for (var prefixLoc = 0; prefixLoc < prefix.length; prefixLoc++) {
+          var prefixParts = prefix[prefixLoc].split('.');
+          var namespace = window;
+          for (var prefixPartsLoc = 0; prefixPartsLoc < prefixParts.length; prefixPartsLoc++) {
+            var namespace = namespace[prefixParts[prefixPartsLoc]] ;
+          }
+          if (namespace !== window) return namespace[recordName] ;
+        }
+      } else return window[recordName] ;
+    } else return defaultType;
+  },
+  // places records from array into hash, sorted by resourceURL.
+  _recordsByResource: function(records) {
+    var ret = {} ;
+    records.forEach(function(rec) {
+      var recs = ret[rec.resourceURL || '*'] || [] ;
+      recs.push(rec)  ;
+      ret[rec.resourceURL || '*'] = recs ;
+    }) ;
+    return ret ;
+  },
+  _camelizeData: function(data) {
+    if (data == null) return data ;
+    // handle array
+    var that = this ;
+    if (data instanceof Array) return data.map(function(d){
+      return that._camelizeData(d) ;
+    }) ;
+    // handle other objects
+    if (typeof(data) == "object") {
+      var ret = {} ;
+      for(var key in data) {
+        var value = that._camelizeData(data[key]) ;
+        if (key == 'id') key = 'guid' ;
+        ret[key.replace(/_/g,'-').camelize()] = value ;
+      }
+      return ret ;
+    }
+    // otherwise just return value
+    return data ;
+  },
+  _decamelizeData: function(data) {
+    if (data == null) return data ;
+    // handle array
+    var that = this ;
+    if (data instanceof Array) return data.map(function(d){
+      return that._decamelizeData(d) ;
+    }) ;
+    // handle other objects
+    if (typeof(data) == "object") {
+      var ret = {} ;
+      for(var key in data) {
+        var value = that._decamelizeData(data[key]) ;
+        if (key == 'guid') key = 'id' ;
+        ret[key.decamelize()] = value ;
+      }
+      return ret ;
+    }
+    // otherwise just return value
+    return data ;
+  },
+  // converts a string, array, or hash into a query string.  root is the
+  // root string applied to each element key.  Used for nesting.
+  _toQueryString: function(params,rootKey) {
+    // handle nulls
+    if (params == null) {
+      return rootKey + '=';
+    // handle arrays
+    } else if (params instanceof Array) {
+      var ret = [] ;
+      for(var loc=0;loc<params.length;loc++) {
+        var key = (rootKey) ? (rootKey + '['+loc+']') : loc ;
+        ret.push(this._toQueryString(params[loc],key)) ;
+      }
+      return ret.join('&') ;
+    // handle objects
+    } else if (typeof(params) == "object") {
+      var ret = [];
+      for(var cur in params) {
+        var key = (rootKey) ? (rootKey + '['+cur+']') : cur ;
+        ret.push(this._toQueryString(params[cur],key)) ;
+      }
+      return ret.join('&') ;
+    // handle other values
+    } else return [rootKey,params].join('=') ;
+  },
+  init: function() {
+    sc_super();
+    SC.Server.addServer(this);
+  }
+}) ;
+SC.Server.servers = [];
+SC.Server.addServer = function(server) {
+  var ary = SC.Server.servers;
+  ary.push(server);
+  SC.Server.servers = ary;
+};