well_rested-core 0.0.3.pre

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in well_rested-core.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Christian Rohrer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# WellRested::Core
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'well_rested-core'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install well_rested-core
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/well_rested/api.rb

@@ -0,0 +1,365 @@
+require 'rest-client'
+require 'json'
+require 'active_support/core_ext/object/to_query'
+require 'key_transformer'
+require 'cgi'
+
+require 'well_rested/utils'
+
+module WellRested
+  # All REST requests are made through an API object.
+  # API objects store cross-resource settings such as user and password (for HTTP basic auth).
+  class API
+    include WellRested  # for logger
+    include WellRested::Utils
+
+    attr_accessor :user
+    attr_accessor :password
+    attr_accessor :default_path_parameters
+    attr_accessor :client
+    attr_reader   :last_response
+    attr_accessor :unique_id
+    attr_accessor :version
+
+    def initialize(path_params = {}, session_params = {}, version = "")
+      self.default_path_parameters = path_params.with_indifferent_access
+      self.client = RestClient
+      self.unique_id = session_params.try(:uid) || 'unauthorized'
+      self.version = version
+    end
+
+    ##
+    # Issue a request of method 'method' (:get, :put, :post, :delete) for the resource identified by 'klass'.
+    # If it is a PUT or a POST, the payload_hash should be specified.
+    def request(klass, method, path, payload_hash = {}, headers = {})
+      auth = (self.user or self.password) ? "#{CGI.escape(user)}:#{CGI.escape(password)}@" : ''
+
+      # If path starts with a slash, assume it is relative to the default server.
+      if path[0..0] == '/'
+        url = "#{klass.protocol}://#{auth}#{klass.server}#{path}"
+      else
+        # Otherwise, treat it as a fully qualified URL and do not modify it.
+        url = path
+      end
+
+      hash = klass.attribute_formatter.encode(payload_hash)
+      payload = klass.body_formatter.encode(hash)
+
+      #logger.info "#{method.to_s.upcase} #{url} (#{payload.inspect})"
+
+      if [:put, :post].include?(method)  # RestClient.put and .post take an extra payload argument.
+        client.send(method, url, payload, request_headers.merge(headers)) do |response, request, result, &block|
+          @last_response = response
+          response.return!(request, result, &block)
+        end
+      else
+        client.send(method, url, request_headers.merge(headers)) do |response, request, result, &block|
+          @last_response = response
+          response.return!(request, result, &block)
+        end
+      end
+    end
+
+    ##
+    # GET a single resource.
+    # 'klass' is a class that descends from WellRested::Base
+    # 'path_params_or_url' is either a url string or a hash of params to substitute into the url pattern specified in klass.path
+    #    e.g. if klass.path is '/accounts/:account_id/users', then the path_params hash should include 'account_id'
+    # 'query_params' is an optional hash of query parameters
+    #
+    # If path_params includes 'id', it will be added to the end of the path (e.g. /accounts/1/users/1)
+    # If path_params_or_url is a hash, query_params will be added on the end (e.g. { :option => 'x' }) produces a url with ?option=x
+    # If it is a string, query_params is ignored.
+    #
+    # Returns an object of class klass representing that resource.
+    # If the resource is not found, raises a RestClient::ResourceNotFound exception.
+    def find(klass, path_params_or_url = {}, query_params = {})
+      if klass.respond_to?(:path_parameters)
+        path_params_or_url = klass.path_parameters
+        klass = klass.class
+      end
+
+      url = url_for(klass, path_params_or_url, query_params)
+      #logger.info "GET #{url}"
+
+      response = client.get(url, request_headers) do |response, request, result, &block|
+        @last_response = response
+        response.return!(request, result, &block) # default RestClient response handling (raise exceptions on errors, etc.)
+      end
+
+      raise "Invalid body formatter for #{klass.name}!" if klass.body_formatter.nil? or !klass.body_formatter.respond_to?(:decode)
+
+      hash = klass.body_formatter.decode(response)
+      decoded_hash = klass.attribute_formatter.nil? ? hash : klass.attribute_formatter.decode(hash)
+      klass.new_from_api(decoded_hash)
+    end
+
+    ##
+    # GET a collection of resources.
+    # This works the same as find, except it expects and returns an array of resources instead of a single resource.
+    def find_many(klass, path_params_or_url = {}, query_params = {})
+      url = url_for(klass, path_params_or_url, query_params)
+
+      logger.info "GET #{url}"
+      # response = client.get(url, request_headers) do |response, request, result, &block|
+      response = client.get(url, request_headers) do |response, request, result, &block|
+      @last_response = response
+        response.return!(request, result, &block)
+      end
+
+      raise "Invalid body formatter for #{klass.name}!" if klass.body_formatter.nil? or !klass.body_formatter.respond_to?(:decode)
+      array = klass.body_formatter.decode(response)
+
+      processed_array = klass.attribute_formatter.nil? ? array : klass.attribute_formatter.decode(array)
+
+      raise "Response did not parse to an array" unless array.is_a?(Array)
+
+      processed_array.map { |e| klass.new_from_api(e) }
+    end
+
+    ##
+    # Create the resource of klass from the given attributes.
+    # The class will be instantiated, and its new_from_api and attributes_for_api methods
+    # will be used to determine which attributes actually get sent.
+    # If url is specified, it overrides the default url.
+    def create(klass, attributes = {}, url = nil)
+      obj = klass.new(default_path_parameters.merge(attributes))
+
+      create_or_update_resource(obj, url)
+    end
+
+    # Save a resource.
+    # Return false if doesn't pass validation.
+    # If the update succeeds, return the resource.
+    # Otherwise, return a hash containing whatever the server returned (usually includes an array of errors).
+    def save(resource, url = nil)
+      # convert any hashes that should be objects into objects before saving,
+      # so that we can use their attributes_for_api methods in case they need to override what gets sent
+      resource.convert_attributes_to_objects
+      create_or_update_resource(resource, url)
+    end
+
+    # DELETE a resource.
+    # There are two main ways to call delete.
+    # 1) The first argument is a class, and the second argument is an array of path_params that resolve to a path to the resource to delete.
+    #    (e.g. for klass Post with path '/users/:user_id/posts', :user_id and :id would be required in path_params_or_url to delete /users/x/posts/y)
+    # 2) The first argument can be an object to delete. It should include all of the path params in its attributes.
+    def delete(klass_or_object, path_params_or_url = {})
+      if klass_or_object.respond_to?(:attributes_for_api) # klass_or_object is an object
+        klass = klass_or_object.class
+        if path_params_or_url.kind_of?(String)
+          url = url_for(klass, path_params_or_url)
+        else
+          params = default_path_parameters.merge(klass_or_object.attributes_for_api)
+          url = url_for(klass, params)
+        end
+      else  # klass_or_object is a class
+        klass = klass_or_object
+        #logger.debug "Calling delete with class #{klass.name} and params: #{path_params.inspect}"
+        if path_params_or_url.kind_of?(String)
+          url = url_for(klass, path_params_or_url)
+        else
+          params = default_path_parameters.merge(path_params_or_url)
+          url = url_for(klass, params)
+        end
+      end
+
+      #logger.info "DELETE #{url}"
+      response = client.delete(url, request_headers) do |response, request, result, &block|
+        @last_response = response
+        response.return!(request, result, &block)
+      end
+    end
+
+    ##
+    # Issue a PUT request to the given url.
+    # The post body is specified by 'payload', which can either be a string, an object, a hash, or an array of hashes.
+    # If it is not a string, it will be recurisvely converted into JSON using any objects' attributes_for_api methods.
+    # TODO: Update this to do something that makes more sense with the formatters.
+    # e.g. def put(url, payload, formatter)
+    def put(url, payload, options = {})
+      default_options = { :json => true }
+      opts = default_options.merge(options)
+
+      payload = payload.kind_of?(String) ? payload : KeyTransformer.camelize_keys(objects_to_attributes(payload)).to_json
+      response = run_update(:put, url, payload)
+
+      if opts[:json] and !response.blank?
+        objs = JSON.parse(response)
+        return KeyTransformer.underscore_keys(objs)
+      end
+
+      return response
+    end
+
+    ##
+    # Issue a POST request to the given url.
+    # The post body is specified by 'payload', which can either be a string, an object, a hash, or an array of hashes.
+    # If it is not a string, it will be recurisvely converted into JSON using any objects' attributes_for_api methods.
+    # TODO: Same issue as with put, get, etc.
+    def post(url, payload, json = true)
+      response = client.post(url, payload, request_headers)
+      return response unless json
+      parsed = JSON.parse(response)
+      KeyTransformer.underscore_keys(parsed)
+    end
+
+    ##
+    # Issue a GET request to the given url.
+    # If json is passed as true, it will be interpreted as JSON and converted into a hash / array of hashes.
+    # Otherwise, the body is returned as a string.
+    # TODO: Same issue as with put. def get(url, body_formatter, attribute_formatter) ?
+    def get(url, json = true)
+      response = client.get(url, request_headers)
+      return response unless json
+      parsed = JSON.parse(response)
+      KeyTransformer.underscore_keys(parsed)
+    end
+
+    # Generate a full URL for the class klass with the given path_params and query_params
+    # In the case of an update, path params will usually be resource.attributes_for_api.
+    # In the case of a find(many), query_params might be count, start, etc.
+    def url_for(klass, path_params_or_url = {}, query_params = {})
+      # CONSIDERATION: Defaults should be settable at the global level on the @api object.
+      # They should be overrideable at the class-level (e.g. User) and again at the time of the method call.
+      # url_for is currently not overrideable at the class level.
+
+      auth = (self.user or self.password) ? "#{CGI.escape(user)}:#{CGI.escape(password)}@" : ''
+
+      if path_params_or_url.kind_of?(String)
+        # if it starts with a slash, we assume its part of a
+        if path_params_or_url[0..0] == '/'
+          url = "#{klass.protocol}://#{auth}#{klass.server}#{path_params_or_url}#{klass.extension}"
+        else
+          # if not, we treat it as fully qualified and do not modify it
+          url = path_params_or_url
+        end
+      else
+        path = self.class.fill_path(klass.path, default_path_parameters.merge(path_params_or_url).with_indifferent_access)
+        url = "#{klass.protocol}://#{auth}#{klass.server}#{path}"
+      end
+      url += '?' + klass.attribute_formatter.encode(query_params).to_query unless query_params.empty?
+      url
+    end
+
+    # Convenience method. Also allows request_headers to be can be set on a per-instance basis.
+    def request_headers
+      self.class.request_headers(self.unique_id, self.version)
+    end
+
+    # Return the default headers sent with all HTTP requests.
+    def self.request_headers(unique_id, version)
+      # Accept necessary for fetching results by result ID, but not in most places.
+      {
+        :content_type => 'application/json',
+        :accept => 'application/json',
+        "Authentication" => unique_id,
+        :version => version
+      }
+    end
+
+    # # 20120627 CR: Add authentication to header
+    # def request_headers_with_authentication(authentication_id)
+    #   self.class.request_headers_with_authentication(authentication_id)
+    # end
+
+    # # Return the default headers sent with all HTTP requests.
+    # def self.request_headers_with_authentication(authentication_id)
+    #   # Accept necessary for fetching results by result ID, but not in most places.
+    #   { :content_type => 'application/json', :accept => 'application/json', :Authentication => authentication_id}
+    # end
+
+
+    # TODO: Move this into a utility module? It can then be called from Base#fill_path or directly if needed.
+    def self.fill_path(path_template, params)
+        raise "Cannot fill nil path" if path_template.nil?
+
+        params = params.with_indifferent_access
+
+        # substitute marked params
+        path = path_template.gsub(/\:\w+/) do |match|
+          sym = match[1..-1].to_sym
+          val = params.include?(sym) ? params[sym] : match
+          raise ArgumentError.new "Blank parameter #{sym} in path #{path}!" if val.blank?
+          val
+        end
+
+        # Raise an error if we have un-filled parameters
+        if path.match(/(\:\w+)/)
+          raise ArgumentError.new "Unfilled parameter in path: #{$1} (path: #{path} params: #{params.inspect})"
+        end
+
+        # ID goes on the end of the resource path but isn't spec'd there
+        path += "/#{params[:id]}" unless params[:id].blank?
+
+        path
+      end
+
+
+    protected  # internal methods follow
+
+    # Create or update a resource.
+    # If an ID is set, PUT will be used, else POST.
+    # If a 200 is returned, the returned attributes will be loaded into the resource, and the resource returned.
+    # Otherwise, the resource will not be modified, and a hash generated from the JSON response will be returned.
+    def create_or_update_resource(resource, url = nil)
+      return false unless resource.valid?
+
+      #logger.info "Creating a #{resource.class}"
+
+      path_params = default_path_parameters.merge(resource.path_parameters)
+      payload_hash = resource.class.attribute_formatter.encode(resource.attributes_for_api)
+      payload = resource.class.body_formatter.encode(payload_hash)
+
+      #logger.debug " payload: #{payload.inspect}"
+
+      if url.nil?
+        url = url_for(resource.class, path_params)  # allow default URL to be overriden by url argument
+      else
+        url = url_for(resource.class, url)
+      end
+
+      # If ID is set in path parameters, do a PUT. Otherwise, do a POST.
+      method = resource.path_parameters[:key].blank? ? :post : :put
+
+      response = run_update(method, url, payload)
+
+      hash = resource.class.body_formatter.decode(response.body)
+      decoded_hash = resource.class.attribute_formatter.decode(hash)
+      logger.info "* Errors: #{decoded_hash['errors'].inspect}" if decoded_hash.include?('errors')
+
+      if response.code.between?(200,299)
+        # If save succeeds, replace resource's attributes with the ones returned.
+        return decoded_hash.map { |hash| resource.class.new_from_api(hash) } if decoded_hash.kind_of?(Array)
+        resource.load_from_api(decoded_hash)
+        return resource
+      elsif decoded_hash.include?('errors')
+        resource.handle_errors(decoded_hash['errors'])
+        return false
+      end
+    end
+
+    def run_update(method, url, payload)
+      logger.debug "#{method.to_s.upcase} #{url} "
+      logger.debug " payload: #{payload.inspect}"
+
+      http_status = nil
+      client.send(method, url, payload, request_headers) do |response, request, result, &block|
+        @last_response = response
+
+        http_status = response.code
+        case response.code
+        when 400
+          #logger.debug "Got 400: #{response.inspect}"
+          response.return!(request, result, &block)
+        when 422
+          #logger.debug "Got 422: errors should be set"
+          response
+        else
+          # default handling (raise exceptions on errors, etc.)
+          response.return!(request, result, &block)
+        end
+      end
+    end
+  end
+end

data/lib/well_rested/base.rb

@@ -0,0 +1,291 @@
+# encoding: utf-8
+
+require 'active_model'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+
+require 'well_rested/json_formatter'
+require 'well_rested/camel_case_formatter'
+require 'well_rested/utils'
+
+module WellRested
+  class Base
+    include Utils
+    include WellRested::Utils
+
+    include ActiveModel::Validations
+    include ActiveModel::Serializers::JSON
+
+    class_attribute :protocol
+    class_attribute :server
+    class_attribute :path
+    class_attribute :schema
+
+    class_attribute :body_formatter
+    class_attribute :attribute_formatter
+    class_attribute :extension   # e.g. .json, .xml
+
+    # class-level defaults
+    self.protocol = 'http'
+    # a body formatter must respond to the methods encode(hash_or_array) => string and decode(string) => hash_or_array
+    self.body_formatter = JSONFormatter.new
+    self.extension = ''
+    # an attribute formatter must respond to encode(attribute_name_string) => string and decode(attribute_name_string) => string
+    self.attribute_formatter = CamelCaseFormatter.new
+
+    attr_reader :attributes
+    attr_accessor :new_record
+
+    ##
+    # Define the schema for this resource.
+    #
+    # Either takes an array, or a list of arguments which we treat as an array.
+    # Each element of the array should be either a symbol or a hash.
+    # If it's a symbol, we create an attribute using the symol as the name and with a null default value.
+    # If it's a hash, we use the keys as attribute names.
+    #   - Any values that are hashes, we use to specify further options (currently, the only option is :default).
+    #   - Any value that is not a hash is treated as a default.
+    #  e.g.
+    #  define_schema :x, :y, :z                            # x, y, and z all default to nil
+    #  define_schema :id, :name => 'John'                  # id defaults to nil, name defaults to 'John'
+    #  define_schema :id, :name => { :default => 'John' }  # same as above
+    def self.define_schema(*args)
+      return schema if args.empty?
+
+      attrs = args.first.is_a?(Array) ? args.first : args
+      self.schema = {}.with_indifferent_access
+      attrs.each do |attr|
+        if attr.is_a?(Symbol)
+          self.schema[attr] = { :default => nil }
+        elsif attr.is_a?(Hash)
+          attr.each do |k,v|
+            if v.is_a?(Hash)
+              self.schema[k] = v
+            else
+              self.schema[k] = { :default => v }
+            end
+          end
+        end
+      end
+
+=begin
+      # Possible alternative to using method_missing:
+      # define getter/setter methods for attributes.
+      @attributes.keys.each do |attr_name|
+        define_method(attr_name) { @attributes[attr_name] }
+        define_method("#{attr_name}=") { |val| @attributes[attr_name] = val }
+      end
+=end
+
+      self.schema
+    end
+
+    def initialize(attrs = {})
+      raise "Attrs must be hash" unless attrs.is_a? Hash
+
+      self.load(attrs, false)
+    end
+
+    # Define an actual method for ID. This is important in Ruby 1.8 where the object_id method is also aliased to id.
+    def id
+      attributes[:id]
+    end
+
+    # borrowed from http://stackoverflow.com/questions/2393697/look-up-all-descendants-of-a-class-in-ruby
+    # Show all subclasses
+    def self.descendants
+      ObjectSpace.each_object(::Class).select { |klass| klass < self }
+    end
+
+    # Create a map of all descendants of Base to lookup classes from names when converting hashes to objects.
+    def self.descendant_map
+      return @descendant_map if @descendant_map
+      @descendant_map = {}.with_indifferent_access
+      self.descendants.each do |des|
+        unless des.name.blank?
+          sep_index = des.name.rindex('::')
+          short_name = sep_index ? des.name[sep_index+2..-1] : des.name
+          @descendant_map[short_name] = des
+        end
+      end
+      @descendant_map
+    end
+
+    # Convenience method for creating an object and calling load_from_api
+    # The API should call this method when creating representations of objects that are already persisted.
+    #
+    # By default, attributes loaded from the API have new_record set to true. This has implications for Rails form handling.
+    # (Rails uses POST for records that it thinks are new, but PUT for records that it thinks are already persisted.)
+    def self.new_from_api(attrs)
+      obj = self.new
+      obj.load_from_api(attrs)
+      return obj
+    end
+
+    # Load this resource from attributes. If these attributes were received from the API, true should be passed for from_api.
+    # This will ensure any object-specific loading behavior is respected.
+    # example:
+    #   res = Resource.new
+    #   res.load(:name => 'New')
+    def load(attrs_to_load, from_api = false)
+      raise "Attrs is not a hash: #{attrs_to_load.inspect}" unless attrs_to_load.kind_of? Hash
+
+      #puts "*** Warning: loading a resource without a schema (#{self.class})!" if schema.nil?
+      #raise "Tried to load attributes for a resource with no schema (#{self.class})!" if schema.nil?
+
+      # We mark a record as new if it doesn't come from the API and it doesn't have an ID.
+      self.new_record = !from_api
+      self.new_record = false if attrs_to_load.include?(:id) or attrs_to_load.include?('id')
+
+      new_attrs = {}.with_indifferent_access
+
+      # Take default values from schema, but allow arbitrary args to be loaded.
+      # We will address the security issue by filtering in attributes_for_api.
+      schema.each { |key, opts| new_attrs[key] = opts[:default] } unless schema.blank?
+      new_attrs.merge!(attrs_to_load)
+
+      @attributes = self.class.hash_to_objects(new_attrs, from_api).with_indifferent_access
+
+      return self
+    end
+
+    # Load attributes from the API.
+    # This method exists to be overridden so that attributes created manually can be handled differently from those loaded from the API.
+    def load_from_api(attrs)
+      load(attrs, true)
+    end
+
+    # Convert attribute hashes that represent objects into objects
+    def convert_attributes_to_objects
+      self.class.hash_to_objects(attributes, self.class)
+    end
+
+    # This method is called by API when a hash including 'errors' is returned along with an HTTP error code.
+    def handle_errors(received_errors)
+      received_errors.each do |err|
+        self.errors.add :base, err
+      end
+    end
+
+    # When we are loading a resource from an API call, we will use this method to instantiate classes based on attribute names.
+    def self.find_resource_class(class_name)
+      klass = Utils.get_class(class_name)
+      #puts "**** descendant map: #{Base.descendant_map.inspect}"
+      return klass if klass.respond_to?(:new_from_api)
+      Base.descendant_map[class_name]
+    end
+
+    # Convert a hash received from the API into an object or array of objects.
+    # e.g. Base.hash_to_objects({'base' => {'name' => 'Test'} }) => {"base"=>#<WellRested::Base:0x10244de70 @attributes={"name"=>"Test"}}
+    def self.hash_to_objects(hash, from_api = false)
+      hash.each do |k,v|
+        if v.kind_of?(Hash)
+          class_name = k.camelize
+          klass = self.find_resource_class(class_name)
+          if klass
+            hash[k] = from_api ? klass.new_from_api(v) : klass.new(v)
+          end
+        elsif v.kind_of?(Array)
+          class_name = k.to_s.singularize.camelize
+          #puts "**** class_name=#{class_name}"
+          klass = find_resource_class(class_name)
+          if klass
+            #puts "**** class exists, instantiation"
+            hash[k] = v.map do |o|
+              if o.kind_of?(Hash)
+                from_api ? klass.new_from_api(o) : klass.new(o)
+              else
+                o
+              end
+            end
+          else
+            #puts "**** class does not exist"
+          end
+        end
+      end
+      hash
+    end
+
+    def self.fill_path(params)
+      API.fill_path(self.path, params)
+    end
+
+    # Return the attributes that we want to send to the server when this resource is saved.
+    # If a schema is defined, only return elements defined in the schema.
+    # Override this for special attribute-handling.
+    def attributes_for_api
+      # by default, filter out nil elements
+      hash = objects_to_attributes(@attributes.reject { |k,v| v.nil? }.with_indifferent_access)
+      # and anything not included in the schema
+      hash.reject! { |k,v| !schema.include?(k) } unless schema.nil?
+      hash
+    end
+
+    # API should use these to generate the path.
+    # Override this to control how path variables get inserted.
+    def path_parameters
+      objects_to_attributes(@attributes.reject { |k,v| v.nil? }.with_indifferent_access)
+    end
+
+    # Run active_model validations on @attributes hash.
+    def read_attribute_for_validation(key)
+      @attributes[key]
+    end
+
+    # Return a string form of this object for rails to use in routes.
+    def to_param
+      self.id.nil? ? nil : self.id.to_s
+    end
+
+    # Return a key for rails to use for... not sure exaclty what.
+    # Should be an array, or nil.
+    def to_key
+      self.id.nil? ? nil : [self.id]
+    end
+
+    # The following 3 methods were copied from active_record/persistence.rb
+    # Returns true if this object hasn't been saved yet -- that is, a record
+    # for the object doesn't exist in the data store yet; otherwise, returns false.
+    def new_record?
+      self.new_record
+    end
+
+    # Alias of new_record? Apparently used by Rails sometimes.
+    def new?
+      self.new_record
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    #def destroyed?
+    #  @destroyed
+    #end
+
+    # Returns if the record is persisted, i.e. it's not a new record and it was
+    # not destroyed.
+    def persisted?
+    #  !(new_record? || destroyed?)
+      !new_record?
+    end
+
+    # Equality is defined as having the same attributes.
+    def ==(other)
+      other.respond_to?(:attributes) ? (self.attributes == other.attributes) : false
+    end
+
+    # Respond to getter and setter methods for attributes.
+    def method_missing(method_sym, *args, &block)
+      method = method_sym.to_s
+      # Is this an attribute getter?
+      if args.empty? and attributes.include?(method)
+        attributes[method]
+      # Is it an attribute setter?
+      elsif args.length == 1 and method[method.length-1..method.length-1] == '=' and attributes.include?(attr_name = method[0..method.length-2])
+        attributes[attr_name] = args.first
+      else
+        super
+      end
+    end
+  end
+end
+

data/lib/well_rested/core_formatter.rb

@@ -0,0 +1,16 @@
+module WellRested
+  class CoreFormatter
+
+    def encode(obj)
+      obj.to_json
+    end
+
+    def decode(serialized_representation)
+      result = JSON.parse(serialized_representation)
+      # 20120628 CR - Core returns the collection results in an array "items" => find_many()
+      # If that doesn't exist, it is a single element, which can be returned as is =>  find()
+      return result["items"] || result
+    end
+
+  end
+end

data/lib/well_rested-core/version.rb

@@ -0,0 +1,5 @@
+module WellRested
+  module Core
+    VERSION = "0.0.3.pre"
+  end
+end

data/lib/well_rested-core.rb

@@ -0,0 +1,34 @@
+require "well_rested-core/version"
+
+# require "well_rested"
+
+# require 'well_rested/core_formatter'
+
+
+# # require external dependencies
+# require 'active_support/core_ext/hash/indifferent_access'
+# require 'active_support/core_ext/hash/reverse_merge'
+
+# # require internal general-use libs
+# require 'key_transformer'
+# require 'generic_utils'
+
+# # require internal libs
+require 'well_rested/api'
+require 'well_rested/base'
+require 'well_rested/utils'
+# require 'well_rested/json_formatter'
+require 'well_rested/core_formatter'
+# require 'well_rested/camel_case_formatter'
+
+# Make sure 'bases' singularizes to 'base' instead of 'basis'.
+# Otherwise, we get an error that no class Basis is found in Base.
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'base', 'bases'
+end
+
+module WellRested
+  module Core
+    autoload :API, 'well_rested/api'
+  end
+end

data/well_rested-core.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/well_rested-core/version', __FILE__)
+
+Gem::Specification.new do |gem|
+
+  gem.add_runtime_dependency 'well_rested', '~> 0.6'
+
+  gem.authors       = ["Christian Rohrer"]
+  gem.email         = ["hydrat@gmail.com"]
+  gem.description   = %q{A fork of the well_rested gem with adaption for the SWITCHtoolbox Core API}
+  gem.summary       = %q{A fork of the well_rested gem with adaption for the SWITCHtoolbox Core API}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "well_rested-core"
+  gem.require_paths = ["lib"]
+  gem.version       = WellRested::Core::VERSION
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: well_rested-core
+version: !ruby/object:Gem::Version
+  version: 0.0.3.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Christian Rohrer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: well_rested
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: A fork of the well_rested gem with adaption for the SWITCHtoolbox Core
+  API
+email:
+- hydrat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/well_rested-core.rb
+- lib/well_rested-core/version.rb
+- lib/well_rested/api.rb
+- lib/well_rested/base.rb
+- lib/well_rested/core_formatter.rb
+- well_rested-core.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A fork of the well_rested gem with adaption for the SWITCHtoolbox Core API
+test_files: []