parse-ruby-client 0.0.1

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Alan deLevie
+
+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,110 @@
+The original creator of parse-ruby-client, [aalpern](http://github.com/aalpern), has decided to stop work on the project. I'm going to give the project new life, first by maintaining the project as a gem, and second by eventually making it power [parse_resource](http://github.com/adelevie/parse_resource) under the hood.
+
+# Ruby Client for parse.com REST API
+
+This file implements a simple Ruby client library for using Parse's REST API.
+Rather than try to implement an ActiveRecord-compatible library, it tries to
+match the structure of the iOS and Android SDKs from Parse.
+
+So far it supports simple GET, PUT, and POST operations on objects. Enough
+to read & write simple data.
+
+## Dependencies
+
+This currently depends on the gems 'json' and 'patron' for JSON support and HTTP, respectively.
+
+# Getting Started
+
+---
+
+To get started, load the parse.rb file and call Parse.init to initialize the client object with
+your application ID and API key values, which you can obtain from the parse.com dashboard.
+
+```ruby
+Parse.init :application_id => "<your_app_id>",
+           :api_key        => "<your_api_key>"
+```
+
+## Creating and Saving Objects
+
+Create an instance of ```Parse::Object``` with your class name supplied as a string, set some keys, and call ```save()```.
+
+```ruby
+game_score = Parse::Object.new "GameScore"
+game_score["score"] 		= 1337
+game_score["playerName"]	= "Sean Plott"
+game_score["cheatMode"] 	= false
+game_score.save
+```
+
+Alternatively, you can initialize the object's initial values with a hash.
+
+```ruby
+game_score = Parse::Object.new "GameScore", {
+	"score" => 1337, "playerName" => "Sean Plott", "cheatMode" => false
+}
+```
+
+Or if you prefer, you can use symbols for the hash keys - they will be converted to strings
+by ```Parse::Object.initialize()```.
+
+```ruby
+game_score = Parse::Object.new "GameScore", {
+		:score => 1337, :playerName => "Sean Plott", :cheatMode => false
+}
+```
+
+## Retrieving Objects
+
+Individual objects can be retrieved with a single call to ```Parse.get()``` supplying the class and object id.
+
+```ruby
+game_score = Parse.get "GameScore", "xWMyZ4YEGZ"
+```
+
+All the objects in a given class can be retrieved by omitting the object ID. Use caution if you have lots
+and lots of objects of that class though.
+
+```ruby
+all_scores = Parse.get "GameScore"
+```
+
+## Queries
+
+Queries are supported by the ```Parse::Query``` class.
+
+```ruby
+# Create some simple objects to query
+(1..100).each { |i|
+  score = Parse::Object.new "GameScore"
+  score["score"] = i
+  score.save
+}
+
+# Retrieve all scores between 10 & 20 inclusive
+Parse::Query.new("GameScore")   \
+  .greater_eq("score", 10)      \
+  .less_eq("score", 20)         \
+  .get
+
+# Retrieve a set of specific scores
+Parse::Query.new("GameScore")           \
+  .value_in("score", [10, 20, 30, 40])  \
+  .get
+
+```
+
+# TODO
+
+- Add some form of debug logging
+- ~~Support for Date, Pointer, and Bytes API [data types](https://www.parse.com/docs/rest#objects-types)~~
+- Users
+- ACLs
+- Login
+
+
+# Resources
+
+- parse.com [REST API documentation](https://parse.com/docs/rest)
+- [parse_resource](https://github.com/adelevie/parse_resource) , an ActiveRecord-compatible wrapper
+  for the API for seamless integration into Rails.

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "parse-ruby-client"
+  gem.homepage = "http://github.com/adelevie/parse-ruby-client"
+  gem.license = "MIT"
+  gem.summary = %Q{A simple Ruby client for the parse.com REST API}
+  gem.description = %Q{A simple Ruby client for the parse.com REST API}
+  gem.email = "adelevie@gmail.com"
+  gem.authors = ["Alan deLevie", "Adam Alpern"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "parse-ruby-client #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/example.rb

@@ -0,0 +1,30 @@
+Parse.init :application_id  => "your_application_id",
+           :api_key         => "your_api_key"
+
+profile = Parse::Object.new "Profile"
+profile["first_name"]    = "John"
+profile["last_name"]     = "Doe"
+profile["username"]      = "jdoe"
+profile["email_address"] = "jdoe@fubar.com"
+profile["birthday"]      = Parse::Date.new "1980-12-25"
+profile.save
+
+profile.increment "login_count"
+
+# Queries
+cls = "GameScore"
+(1..100).each { |i|
+  score = Parse::Object.new cls
+  score["score"] = i
+  score.save
+}
+
+Parse::Query.new(cls)       \
+  .greater_eq("score", 10)  \
+  .less_eq("score", 20)     \
+  .get
+
+Parse::Query.new(cls)                   \
+  .value_in("score", [10, 20, 30, 40])  \
+  .get
+

data/lib/parse.rb

@@ -0,0 +1,19 @@
+## ----------------------------------------------------------------------
+##
+## Ruby client for parse.com
+## A quick library for playing with parse.com's REST API for object storage.
+## See https://parse.com/docs/rest for full documentation on the API.
+##
+## ----------------------------------------------------------------------
+
+require 'json'
+require 'patron'
+require 'date'
+require 'cgi'
+
+cwd = Pathname(__FILE__).dirname
+$:.unshift(cwd.to_s) unless $:.include?(cwd.to_s) || $:.include?(cwd.expand_path.to_s)
+
+require 'parse/object'
+require 'parse/query'
+require 'parse/datatypes'

data/lib/parse/client.rb

@@ -0,0 +1,103 @@
+require 'parse/protocol'
+require 'parse/error'
+require 'parse/util'
+
+module Parse
+
+  # A class which encapsulates the HTTPS communication with the Parse
+  # API server. Currently uses the Patron library for low-level HTTP
+  # communication.
+  class Client
+    attr_accessor :host
+    attr_accessor :application_id
+    attr_accessor :api_key
+    attr_accessor :session
+
+    def initialize(data = {})
+      @host           = data[:host] || Protocol::HOST
+      @application_id = data[:application_id]
+      @api_key        = data[:api_key]
+      @session        = Patron::Session.new
+
+      @session.base_url                 = "https://#{host}"
+      @session.headers["Content-Type"]  = "application/json"
+      @session.headers["Accept"]        = "application/json"
+      @session.headers["User-Agent"]    = "Parse for Ruby, 0.0"
+      @session.headers[Protocol::HEADER_API_KEY]  = @api_key
+      @session.headers[Protocol::HEADER_APP_ID]   = @application_id
+    end
+
+    # Perform an HTTP request for the given uri and method
+    # with common basic response handling. Will raise a
+    # ParseProtocolError if the response has an error status code,
+    # and will return the parsed JSON body on success, if there is one.
+    def request(uri, method = :get, body = nil, query = nil)
+      options = {}
+      if body
+        options[:data] = body
+      end
+      if query
+        options[:query] = query
+      end
+
+      response = @session.request(method, uri, {}, options)
+      if response.status >= 400
+        raise ParseProtocolError, response
+      else
+        if response.body
+          return JSON.parse response.body
+        end
+      end
+    end
+
+    def get(uri)
+      request(uri)
+    end
+
+    def post(uri, body)
+      request(uri, :post, body)
+    end
+
+    def put(uri, body)
+      request(uri, :put, body)
+    end
+
+    def delete(uri)
+      request(uri, :delete)
+    end
+
+  end
+
+
+  # Module methods
+  # ------------------------------------------------------------
+
+  # A singleton client for use by methods in Object.
+  # Always use Parse.client to retrieve the client object.
+  @@client = nil
+
+  # Initialize the singleton instance of Client which is used
+  # by all API methods. Parse.init must be called before saving
+  # or retrieving any objects.
+  def Parse.init(data)
+    @@client = Client.new(data)
+  end
+
+  def Parse.client
+    if !@@client
+      raise ParseError, "API not initialized"
+    end
+    @@client
+  end
+
+  # Perform a simple retrieval of a simple object, or all objects of a
+  # given class. If object_id is supplied, a single object will be
+  # retrieved. If object_id is not supplied, then all objects of the
+  # given class will be retrieved and returned in an Array.
+  def Parse.get(class_name, object_id = nil)
+    data = Parse.client.get( Protocol.class_uri(class_name, object_id) )
+    Parse.parse_json class_name, data
+  end
+
+end
+

data/lib/parse/datatypes.rb

@@ -0,0 +1,74 @@
+require 'base64'
+
+module Parse
+
+  # Pointer
+  # ------------------------------------------------------------
+
+  class Pointer
+    attr_accessor :parse_object_id
+    attr_accessor :class_name
+
+    def initialize(data)
+      @class_name       = data[Protocol::KEY_CLASS_NAME]
+      @parse_object_id  = data[Protocol::KEY_OBJECT_ID]
+    end
+
+    def to_json(*a)
+      {
+          Protocol::KEY_TYPE        => Protocol::TYPE_POINTER,
+          Protocol::KEY_CLASS_NAME  => @class_name,
+          Protocol::KEY_OBJECT_ID   => @parse_object_id
+      }.to_json(*a)
+    end
+
+    # Retrieve the Parse object referenced by this pointer.
+    def get
+      Parse.get @class_name, @parse_object_id
+    end
+  end
+
+  # Date
+  # ------------------------------------------------------------
+
+  class Date
+    attr_accessor :value
+
+    def initialize(data)
+      if data.is_a? DateTime
+        @value = data
+      elsif data.is_a? Hash
+        @value = DateTime.parse data["iso"]
+      elsif data.is_a? String
+        @value = DateTime.parse data
+      end
+    end
+
+    def to_json(*a)
+      {
+          Protocol::KEY_TYPE => Protocol::TYPE_DATE,
+          "iso"              => value.iso8601
+      }.to_json(*a)
+    end
+  end
+
+  # Bytes
+  # ------------------------------------------------------------
+
+  class Bytes
+    attr_accessor :value
+
+    def initialize(data)
+      bytes = data["base64"]
+      value = Base64.decode(bytes)
+    end
+
+    def to_json(*a)
+      {
+          Protocol::KEY_TYPE => Protocol::TYPE_BYTES,
+          "base64" => Base64.encode(@value)
+      }.to_json(*a)
+    end
+  end
+
+end

data/lib/parse/error.rb

@@ -0,0 +1,27 @@
+module Parse
+
+  # Base exception class for errors thrown by the Parse
+  # client library. ParseError will be raised by any
+  # network operation if Parse.init() has not been called.
+  class ParseError < Exception
+  end
+
+  # An exception class raised when the REST API returns an error.
+  # The error code and message will be parsed out of the HTTP response,
+  # which is also included in the response attribute.
+  class ParseProtocolError < ParseError
+    attr_accessor :code
+    attr_accessor :error
+    attr_accessor :response
+
+    def initialize(response)
+      @response = response
+      if response.body
+        data = JSON.parse response.body
+        @code = data["code"]
+        @message = data["error"]
+      end
+    end
+  end
+  
+end

data/lib/parse/object.rb

@@ -0,0 +1,119 @@
+require 'parse/protocol'
+require 'parse/client'
+require 'parse/error'
+
+module Parse
+
+  # Represents an individual Parse API object.
+  class Object  < Hash
+    attr_reader :parse_object_id
+    attr_reader :class_name
+    attr_reader :created_at
+    attr_reader :updated_at
+
+    def initialize(class_name, data = nil)
+      @class_name = class_name
+      if data
+        parse data
+      end
+    end
+
+    def uri
+      Protocol.class_uri @class_name, @parse_object_id
+    end
+
+    def pointer
+      Parse::Pointer.new self
+    end
+
+    # Merge a hash parsed from the JSON representation into
+    # this instance. This will extract the reserved fields,
+    # merge the hash keys, and then insure that the reserved
+    # fields do not occur in the underlying hash storage.
+    def parse(data)
+      if !data
+        return
+      end
+
+      @parse_object_id ||= data[Protocol::KEY_OBJECT_ID]
+
+      if data.has_key? Protocol::KEY_CREATED_AT
+        @created_at = DateTime.parse data[Protocol::KEY_CREATED_AT]
+      end
+
+      if data.has_key? Protocol::KEY_UPDATED_AT
+        @updated_at = DateTime.parse data[Protocol::KEY_UPDATED_AT]
+      end
+
+			data.each { |k,v|
+				if k.is_a? Symbol
+					k = k.to_s
+				end
+				if !Protocol::RESERVED_KEYS.include? k
+					self[k] = v
+				end
+			}
+    end
+    private :parse
+
+    # Write the current state of the local object to the API.
+    # If the object has never been saved before, this will create
+    # a new object, otherwise it will update the existing stored object.
+    def save
+      method   = @parse_object_id ? :put : :post
+      body     = self.to_json
+
+      data = Parse.client.request(self.uri, method, body)
+      if data
+        parse data
+      end
+      self
+    end
+
+    # Update the fields of the local Parse object with the current
+    # values from the API.
+    def refresh
+      if @parse_object_id
+        data = Parse.client.get self.uri
+        if data
+          parse data
+        end
+      end
+      self
+    end
+
+    # Delete the remote Parse API object.
+    def parse_delete
+      if @parse_object_id
+        response = Parse.client.delete self.uri
+      end
+      nil
+    end
+
+    # Increment the given field by an amount, which defaults to 1.
+    def increment(field, amount = 1)
+      value = (self[field] || 0) + amount
+      self[field] = value
+      if !@parse_object_id
+        # TODO - warn that the object must be stored first
+        return nil
+      end
+
+      if amount != 0
+        op = amount > 0 ? Protocol::OP_INCREMENT : Protocol::OP_DECREMENT
+        body = "{\"#{field}\": {\"#{Protocol::KEY_OP}\": \"#{op}\", \"#{Protocol::KEY_AMOUNT}\" : #{amount.abs}}}"
+        data = Parse.client.request( self.uri, :put, body)
+        parse data
+      end
+      self
+    end
+
+    # Decrement the given field by an amount, which defaults to 1.
+    # A synonym for increment(field, -amount).
+    def decrement(field, amount = 1)
+      increment field, -amount
+    end
+
+  end
+
+end

data/lib/parse/protocol.rb

@@ -0,0 +1,122 @@
+module Parse
+  # A module which encapsulates the specifics of Parse's REST API.
+  module Protocol
+
+    # Basics
+    # ----------------------------------------
+
+    # The default hostname for communication with the Parse API.
+    HOST            = "api.parse.com"
+
+    # The version of the REST API implemented by this module.
+    VERSION         = 1
+
+    # HTTP Headers
+    # ----------------------------------------
+
+    # The HTTP header used for passing your application ID to the
+    # Parse API.
+    HEADER_APP_ID   = "X-Parse-Application-Id"
+
+    # The HTTP header used for passing your API key to the
+    # Parse API.
+    HEADER_API_KEY  = "X-Parse-REST-API-Key"
+
+    # JSON Keys
+    # ----------------------------------------
+
+    # The JSON key used to store the class name of an object
+    # in a Pointer datatype.
+    KEY_CLASS_NAME  = "className"
+
+    # The JSON key used to store the ID of Parse objects
+    # in their JSON representation.
+    KEY_OBJECT_ID   = "objectId"
+
+    # The JSON key used to store the creation timestamp of
+    # Parse objects in their JSON representation.
+    KEY_CREATED_AT  = "createdAt"
+
+    # The JSON key used to store the last modified timestamp
+    # of Parse objects in their JSON representation.
+    KEY_UPDATED_AT  = "updatedAt"
+
+    # The JSON key used in the top-level response object
+    # to indicate that the response contains an array of objects.
+    RESPONSE_KEY_RESULTS = "results"
+
+    # The JSON key used to identify an operator in the increment/decrement
+    # API call.
+    KEY_OP          = "__op"
+
+    # The JSON key used to identify the datatype of a special value.
+    KEY_TYPE        = "__type"
+
+    # The JSON key used to specify the numerical value in the
+    # increment/decrement API call.
+    KEY_AMOUNT      = "amount"
+
+		RESERVED_KEYS = [ KEY_CLASS_NAME, KEY_CREATED_AT, KEY_OBJECT_ID ]
+
+    # Other Constants
+    # ----------------------------------------
+
+    # Operation name for incrementing an objects field value remotely
+    OP_INCREMENT    = "Increment"
+
+    # Operation name for decrementing an objects field value remotely
+    OP_DECREMENT    = "Decrement"
+
+
+    # The data type name for special JSON objects representing a reference
+    # to another Parse object.
+    TYPE_POINTER    = "Pointer"
+
+    # The data type name for special JSON objects containing an array of
+    # encoded bytes.
+    TYPE_BYTES      = "Bytes"
+
+    # The data type name for special JSON objects representing a date/time.
+    TYPE_DATE       = "Date"
+
+    # The data type name for special JSON objects representing a
+    # location specified as a latitude/longitude pair.
+    TYPE_GEOPOINT   = "GeoPoint"
+
+    # The data type name for special JSON objects representing
+    # a file.
+    TYPE_FILE       = "File"
+
+    # The class name for User objects, when referenced by a Pointer.
+    CLASS_USER      = "_User"
+
+    # URI Helpers
+    # ----------------------------------------
+
+    # Construct a uri referencing a given Parse object
+    # class or instance (of object_id is non-nil).
+    def Protocol.class_uri(class_name, object_id = nil)
+      if object_id
+        "/#{VERSION}/classes/#{class_name}/#{object_id}"
+      else
+        "/#{VERSION}/classes/#{class_name}"
+      end
+    end
+
+    # Construct a uri referencing a given Parse user
+    # instance or the users category.
+    def Protocol.user_uri(user_id = nil)
+      if user_id
+        "/#{VERSION}/users/#{user_id}"
+      else
+        "/#{VERSION}/users"
+      end
+    end
+
+    # Construct a uri referencing a file stored by the API.
+    def Protocol.file_uri(file_name)
+      "/#{VERSION}/files/#{file_name}"
+    end
+
+  end
+end

data/lib/parse/query.rb

@@ -0,0 +1,79 @@
+require 'cgi'
+
+module Parse
+
+  class Query
+    attr_accessor :where
+    attr_accessor :class_name
+    attr_accessor :order_by
+    attr_accessor :order
+    attr_accessor :limit
+    attr_accessor :skip
+
+    def initialize(cls_name)
+      @class_name = cls_name
+      @where = {}
+      @order = :ascending
+    end
+
+    def add_constraint(field, constraint)
+      current = where[field]
+      if current && current.is_a?(Hash) && constraint.is_a?(Hash)
+        current.merge! constraint
+      else
+        where[field] = constraint
+      end
+    end
+    private :add_constraint
+
+    def eq(field, value)
+      add_constraint field, value
+      self
+    end
+
+    def regex(field, expression)
+      add_constraint field, { "$regex" => expression }
+      self
+    end
+
+    def less_than(field, value)
+      add_constraint field, { "$lt" => value }
+      self
+    end
+
+    def less_eq(field, value)
+      add_constraint field, { "$lte" => value }
+      self
+    end
+
+    def greater_than(field, value)
+      add_constraint field, { "$gt" => value }
+      self
+    end
+
+    def greater_eq(field, value)
+      add_constraint field, { "$gte" => value }
+      self
+    end
+
+    def value_in(field, values)
+      add_constraint field, { "$in" => values }
+      self
+    end
+
+    def exists(field, value = true)
+      add_constraint field, { "$exists" => value }
+      self
+    end
+
+    def get
+      uri   = Protocol.class_uri @class_name
+      query = { "where" => CGI.escape(@where.to_json) }
+
+      response = Parse.client.request uri, :get, nil, query
+      Parse.client.parse_response class_name, response
+    end
+
+  end
+
+end

data/lib/parse/util.rb

@@ -0,0 +1,49 @@
+module Parse
+
+  # Parse a JSON representation into a fully instantiated
+  # class. obj can be either a string or a Hash as parsed
+  # by JSON.parse
+  # @param class_name [Object]
+  # @param obj [Object]
+  def Parse.parse_json(class_name, obj)
+
+    if obj.nil?
+      nil
+    # String
+    elsif obj.is_a? String
+      parse_json class_name, JSON.parse(obj)
+
+    # Array
+    elsif obj.is_a? Array
+      obj.collect { |o| parse_json(class_name, o) }
+
+    # Hash
+    elsif obj.is_a? Hash
+
+      # If it's a datatype hash
+      if obj.has_key?(Protocol::KEY_TYPE)
+        parse_datatype obj
+      elsif obj.size == 1 && obj.has_key?(Protocol::KEY_RESULTS) && obj[Protocol::KEY_RESULTS].is_a?(Array)
+        obj[Protocol::KEY_RESULTS].collect { |o| parse_json(class_name, o) }
+      else # otherwise it must be a regular object
+        Parse::Object.new class_name, obj
+      end
+
+    else
+      obj
+    end
+  end
+
+  def Parse.parse_datatype(obj)
+    type = obj[Protocol::KEY_TYPE]
+
+    case type
+      when Protocol::TYPE_POINTER
+        Parse::Pointer.new obj
+      when Protocol::TYPE_BYTES
+        Parse::Bytes.new obj
+      when Protocol::TYPE_DATE
+        Parse::Date.new obj
+    end
+  end
+end

data/parse-ruby-client.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "parse-ruby-client"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alan deLevie", "Adam Alpern"]
+  s.date = "2012-02-05"
+  s.description = "A simple Ruby client for the parse.com REST API"
+  s.email = "adelevie@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "example.rb",
+    "lib/parse.rb",
+    "lib/parse/client.rb",
+    "lib/parse/datatypes.rb",
+    "lib/parse/error.rb",
+    "lib/parse/object.rb",
+    "lib/parse/protocol.rb",
+    "lib/parse/query.rb",
+    "lib/parse/util.rb",
+    "parse-ruby-client.gemspec",
+    "pkg/parse-ruby-client-0.0.1.gem",
+    "pkg/parse-ruby-client-1-0.0.1.gem",
+    "pkg/parse-ruby-client.gem",
+    "test/helper.rb",
+    "test/test_parse-ruby-client.rb"
+  ]
+  s.homepage = "http://github.com/adelevie/parse-ruby-client"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "A simple Ruby client for the parse.com REST API"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'parse-ruby-client-1'
+
+class Test::Unit::TestCase
+end

data/test/test_parse-ruby-client.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestParseRubyClient < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: parse-ruby-client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alan deLevie
+- Adam Alpern
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70311876454920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70311876454920
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70311876453900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70311876453900
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70311876434760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70311876434760
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70311876433780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70311876433780
+description: A simple Ruby client for the parse.com REST API
+email: adelevie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- example.rb
+- lib/parse.rb
+- lib/parse/client.rb
+- lib/parse/datatypes.rb
+- lib/parse/error.rb
+- lib/parse/object.rb
+- lib/parse/protocol.rb
+- lib/parse/query.rb
+- lib/parse/util.rb
+- parse-ruby-client.gemspec
+- pkg/parse-ruby-client-0.0.1.gem
+- pkg/parse-ruby-client-1-0.0.1.gem
+- pkg/parse-ruby-client.gem
+- test/helper.rb
+- test/test_parse-ruby-client.rb
+homepage: http://github.com/adelevie/parse-ruby-client
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1143289306669216906
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple Ruby client for the parse.com REST API
+test_files: []