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

sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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;
+};