parse-ruby-client 0.1.14 → 0.1.15

data/lib/parse/error.rb

@@ -23,6 +23,14 @@ module Parse
 
       super("#{@code}: #{@error}")
     end
+
+    def to_s
+      @message || super
+    end
+
+    def message=(msg)
+      @message = msg
+    end
   end
 
 end

data/lib/parse/object.rb

@@ -20,6 +20,16 @@ module Parse
       end
     end
 
+    def eql?(other)
+      Parse.object_pointer_equality?(self, other)
+    end
+
+    alias == eql?
+
+    def hash
+      Parse.object_pointer_hash(self)
+    end
+
     def uri
       Protocol.class_uri @class_name, @parse_object_id
     end
@@ -56,9 +66,10 @@ module Parse
         if k.is_a? Symbol
           k = k.to_s
         end
-				#if Protocol::RESERVED_KEYS.include? k
-        self[k] = v
-				#end
+
+        if k != Parse::Protocol::KEY_TYPE
+          self[k] = v
+        end
       end
 
       self
@@ -73,13 +84,17 @@ module Parse
       Protocol::RESERVED_KEYS.each { |k| without_reserved.delete(k) }
 
       without_relations = without_reserved
-      without_relations.each { |k,v|
+      without_relations.each do |k,v|
           if v.is_a? Hash
             if v[Protocol::KEY_TYPE] == Protocol::TYPE_RELATION
               without_relations.delete(k)
             end
           end
-      }
+      end
+
+      without_relations.each do |k, v|
+        without_relations[k] = Parse.pointerize_value(v)
+      end
 
       without_relations
     end
@@ -105,7 +120,8 @@ module Parse
       data = Parse.client.request(self.uri, method, body)
 
       if data
-        parse data
+        # array operations can return mutated view of array which needs to be parsed
+        parse Parse.parse_json(class_name, data)
       end
 
       if @class_name == Parse::Protocol::CLASS_USER
@@ -119,7 +135,7 @@ module Parse
 
     def as_json(*a)
       Hash[self.map do |key, value|
-        value = if value
+        value = if !value.nil?
           value.respond_to?(:as_json) ? value.as_json : value
         else
           Protocol::DELETE_OP
@@ -190,13 +206,6 @@ module Parse
       #  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
       body = {field => Parse::Increment.new(amount)}.to_json
       data = Parse.client.request(self.uri, :put, body)
       parse data
@@ -206,11 +215,7 @@ module Parse
     # Decrement the given field by an amount, which defaults to 1. Saves immediately to reflect decremented
     # A synonym for increment(field, -amount).
     def decrement(field, amount = 1)
-      #increment field, -amount
-      body = {field => Parse::Decrement.new(amount)}.to_json
-      data = Parse.client.request(self.uri, :put, body)
-      parse data
-      self
+      increment(field, -amount)
     end
 
     private
@@ -221,7 +226,7 @@ module Parse
       if @parse_object_id
         @op_fields[field] ||= ArrayOp.new(operation, [])
         raise "only one operation type allowed per array #{field}" if @op_fields[field].operation != operation
-        @op_fields[field].objects << value
+        @op_fields[field].objects << Parse.pointerize_value(value)
       end
 
       # parse doesn't return column values on initial POST creation so we must maintain them ourselves

data/lib/parse/protocol.rb

@@ -59,7 +59,6 @@ module Parse
     KEY_OP          = "__op"
 
     KEY_INCREMENT   = "Increment"
-    KEY_DECREMENT   = "Decrement"
     KEY_DELETE      = "Delete"
 
     # array ops
@@ -86,9 +85,6 @@ module Parse
     # 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 full object
     TYPE_OBJECT     = "Object"
 
@@ -127,7 +123,10 @@ module Parse
 
     BATCH_REQUEST_URI = "batch"
 
+    ERROR_INTERNAL = 1
     ERROR_TIMEOUT = 124
+    ERROR_EXCEEDED_BURST_LIMIT = 155
+    ERROR_OBJECT_NOT_FOUND_FOR_GET = 101
 
     # URI Helpers
     # ----------------------------------------

data/lib/parse/query.rb

@@ -42,12 +42,12 @@ module Parse
     end
 
     def eq(field, value)
-      add_constraint field, value
+      add_constraint field, Parse.pointerize_value(value)
       self
     end
 
     def not_eq(field, value)
-      add_constraint field, { "$ne" => value }
+      add_constraint field, { "$ne" => Parse.pointerize_value(value) }
       self
     end
 
@@ -57,37 +57,37 @@ module Parse
     end
 
     def less_than(field, value)
-      add_constraint field, { "$lt" => value }
+      add_constraint field, { "$lt" => Parse.pointerize_value(value) }
       self
     end
 
     def less_eq(field, value)
-      add_constraint field, { "$lte" => value }
+      add_constraint field, { "$lte" => Parse.pointerize_value(value) }
       self
     end
 
     def greater_than(field, value)
-      add_constraint field, { "$gt" => value }
+      add_constraint field, { "$gt" => Parse.pointerize_value(value) }
       self
     end
 
     def greater_eq(field, value)
-      add_constraint field, { "$gte" => value }
+      add_constraint field, { "$gte" => Parse.pointerize_value(value) }
       self
     end
 
     def value_in(field, values)
-      add_constraint field, { "$in" => values }
+      add_constraint field, { "$in" => values.map { |v| Parse.pointerize_value(v) } }
       self
     end
 
     def value_not_in(field, values)
-      add_constraint field, { "$nin" => values }
+      add_constraint field, { "$nin" => values.map { |v| Parse.pointerize_value(v) } }
       self
     end
 
     def related_to(field,value)
-      h = {"object" => value, "key" => field} 
+      h = {"object" => Parse.pointerize_value(value), "key" => field}
       add_constraint("$relatedTo", h )
     end
 
@@ -123,6 +123,7 @@ module Parse
       query = { "where" => CGI.escape(where_as_json.to_json) }
       set_order(query)
       [:count, :limit, :skip, :include].each {|a| merge_attribute(a, query)}
+      Parse.client.logger.info{"Parse query for #{uri} #{CGI.unescape(query.inspect)}"}
       response = Parse.client.request uri, :get, nil, query
       Parse.parse_json class_name, response
     end

data/lib/parse/util.rb

@@ -1,4 +1,3 @@
-require 'pp'
 module Parse
 
   # Parse a JSON representation into a fully instantiated
@@ -22,8 +21,10 @@ module Parse
         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, so deep parse it avoiding re-JSON.parsing raw Strings
+      elsif class_name # otherwise it must be a regular object, so deep parse it avoiding re-JSON.parsing raw Strings
         Parse::Object.new class_name, Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
+      else # plain old hash
+        obj
       end
 
     # primitive
@@ -50,4 +51,37 @@ module Parse
         Parse::Object.new obj[Protocol::KEY_CLASS_NAME], Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
     end
   end
+
+  def Parse.pointerize_value(obj)
+    if obj.kind_of?(Parse::Object)
+      obj.pointer
+    elsif obj.is_a?(Array)
+      obj.map do |v|
+        Parse.pointerize_value(v)
+      end
+    elsif obj.is_a?(Hash)
+      Hash[obj.map do |k, v|
+        [k, Parse.pointerize_value(v)]
+      end]
+    else
+      obj
+    end
+  end
+
+  def Parse.object_pointer_equality?(a, b)
+    classes = [Parse::Object, Parse::Pointer]
+    return false unless classes.any? { |c| a.kind_of?(c) } && classes.any? { |c| b.kind_of?(c) }
+    return true if a.equal?(b)
+    return false if a.new? || b.new?
+
+    a.class_name == b.class_name && a.id == b.id
+  end
+
+  def Parse.object_pointer_hash(v)
+    if v.new?
+      v.object_id
+    else
+      v.class_name.hash ^ v.id.hash
+    end
+  end
 end

data/parse-ruby-client.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parse-ruby-client"
-  s.version = "0.1.14"
+  s.version = "0.1.15"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan deLevie", "Adam Alpern"]
-  s.date = "2013-02-27"
+  s.date = "2013-05-22"
   s.description = "A simple Ruby client for the parse.com REST API"
   s.email = "adelevie@gmail.com"
   s.extra_rdoc_files = [
@@ -21,33 +21,37 @@ Gem::Specification.new do |s|
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
+    "OLD_README.md",
     "README.md",
     "Rakefile",
     "VERSION",
     "example.rb",
     "features.md",
+    "fixtures/vcr_cassettes/test_acls_arent_objects.yml",
     "fixtures/vcr_cassettes/test_array_add.yml",
-    "fixtures/vcr_cassettes/test_array_add_relation.yml",
+    "fixtures/vcr_cassettes/test_array_add_pointerizing.yml",
+    "fixtures/vcr_cassettes/test_array_add_unique.yml",
     "fixtures/vcr_cassettes/test_batch_create_object.yml",
     "fixtures/vcr_cassettes/test_batch_delete_object.yml",
     "fixtures/vcr_cassettes/test_batch_run.yml",
     "fixtures/vcr_cassettes/test_batch_update_object.yml",
-    "fixtures/vcr_cassettes/test_cloud_function.yml",
+    "fixtures/vcr_cassettes/test_circular_save.yml",
     "fixtures/vcr_cassettes/test_created_at.yml",
+    "fixtures/vcr_cassettes/test_decrement.yml",
     "fixtures/vcr_cassettes/test_deep_parse.yml",
     "fixtures/vcr_cassettes/test_destroy.yml",
-    "fixtures/vcr_cassettes/test_file_save.yml",
+    "fixtures/vcr_cassettes/test_eq_pointerize.yml",
+    "fixtures/vcr_cassettes/test_equality.yml",
     "fixtures/vcr_cassettes/test_get.yml",
-    "fixtures/vcr_cassettes/test_image_file_associate_with_object.yml",
-    "fixtures/vcr_cassettes/test_image_file_save.yml",
+    "fixtures/vcr_cassettes/test_get_missing.yml",
     "fixtures/vcr_cassettes/test_include.yml",
     "fixtures/vcr_cassettes/test_new_model.yml",
     "fixtures/vcr_cassettes/test_new_object.yml",
     "fixtures/vcr_cassettes/test_nils_delete_keys.yml",
-    "fixtures/vcr_cassettes/test_object_id.yml",
     "fixtures/vcr_cassettes/test_parse_delete.yml",
     "fixtures/vcr_cassettes/test_pointer.yml",
-    "fixtures/vcr_cassettes/test_request_batch.yml",
+    "fixtures/vcr_cassettes/test_save_with_sub_objects.yml",
+    "fixtures/vcr_cassettes/test_saving_boolean_values.yml",
     "fixtures/vcr_cassettes/test_server_update.yml",
     "fixtures/vcr_cassettes/test_simple_save.yml",
     "fixtures/vcr_cassettes/test_text_file_save.yml",
@@ -98,35 +102,35 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<patron>, [">= 0"])
       s.add_runtime_dependency(%q<iron_mq>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1.5"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<test-unit>, ["= 2.5.0"])
       s.add_development_dependency(%q<mocha>, ["= 0.12.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<webmock>, [">= 0"])
       s.add_development_dependency(%q<vcr>, [">= 0"])
     else
       s.add_dependency(%q<patron>, [">= 0"])
       s.add_dependency(%q<iron_mq>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.1.5"])
+      s.add_dependency(%q<bundler>, [">= 0"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<test-unit>, ["= 2.5.0"])
       s.add_dependency(%q<mocha>, ["= 0.12.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<webmock>, [">= 0"])
       s.add_dependency(%q<vcr>, [">= 0"])
     end
   else
     s.add_dependency(%q<patron>, [">= 0"])
     s.add_dependency(%q<iron_mq>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.1.5"])
+    s.add_dependency(%q<bundler>, [">= 0"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<test-unit>, ["= 2.5.0"])
     s.add_dependency(%q<mocha>, ["= 0.12.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<webmock>, [">= 0"])
     s.add_dependency(%q<vcr>, [">= 0"])
   end

data/test/helper.rb

@@ -7,21 +7,49 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+end if ENV["COVERAGE"]
+
 require 'test/unit'
 require 'shoulda'
 require 'mocha'
 require 'vcr'
 require 'webmock/test_unit'
 
+require 'simplecov'
+SimpleCov.start if ENV['COVERAGE']
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'parse-ruby-client'
+
+YAML::ENGINE.yamler='syck' # get ascii strings as strings in fixtures
+
 VCR.configure do |c|
   c.cassette_library_dir = 'fixtures/vcr_cassettes'
   c.hook_into :webmock # or :fakeweb
   c.allow_http_connections_when_no_cassette = true
-end
+  c.filter_sensitive_data("<COOKIE-KEY>") { |i| [i.response.headers['Set-Cookie']].flatten.compact.first }
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'parse-ruby-client'
+  def filter_sensitive_header(c, header)
+    c.filter_sensitive_data("<#{header}>") do |interaction|
+      if v = interaction.request.headers.detect{|k,_| k.casecmp(header) == 0}
+        v.last.first
+      end
+    end
+  end
+
+  filter_sensitive_header(c, Parse::Protocol::HEADER_APP_ID)
+  filter_sensitive_header(c, Parse::Protocol::HEADER_API_KEY)
+  filter_sensitive_header(c, Parse::Protocol::HEADER_MASTER_KEY)
+  filter_sensitive_header(c, Parse::Protocol::HEADER_SESSION_TOKEN)
+end
 
-class Test::Unit::TestCase
+class ParseTestCase < Test::Unit::TestCase
+  def setup
+    @client = Parse.init(:logger => Logger.new(STDERR).tap{|l| l.level = Logger::ERROR})
+  end
 end

data/test/test_batch.rb

@@ -1,9 +1,6 @@
 require 'helper'
 
-class TestBatch < Test::Unit::TestCase
-  def setup
-    Parse.init
-  end
+class TestBatch < ParseTestCase
 
   def test_initialize
     batch = Parse::Batch.new

data/test/test_client.rb

@@ -1,15 +1,12 @@
 require 'helper'
 
-class TestClient < Test::Unit::TestCase
-  def setup
-    @client = Parse.init
-  end
+class TestClient < ParseTestCase
 
-  def test_request
-    VCR.use_cassette('test_request', :record => :new_episodes) do
+  def test_retries
+    VCR.use_cassette('test_retries', :record => :new_episodes) do
       response = mock()
       response.stubs(:body).returns({'code' => Parse::Protocol::ERROR_TIMEOUT}.to_json)
-      response.stubs(:status).returns(400)
+      response.stubs(:status).returns(500)
       @client.session.expects(:request).times(@client.max_retries + 1).returns(response)
       assert_raise do
        @client.request(nil)
@@ -17,6 +14,54 @@ class TestClient < Test::Unit::TestCase
     end
   end
 
+  def test_retries_json_error
+    VCR.use_cassette('test_retries_json_error', :record => :new_episodes) do
+      bad_response = mock()
+      bad_response.stubs(:body).returns("<HTML>this is not json</HTML>")
+      bad_response.stubs(:status).returns(500)
+
+      good_response = mock()
+      good_response.stubs(:body).returns('{"foo":100}')
+      good_response.stubs(:status).returns(200)
+      @client.session.expects(:request).twice.returns(bad_response, good_response)
+
+      assert_equal({ "foo" => 100 }, @client.request(nil))
+    end
+  end
+
+  def test_retries_server_error
+    VCR.use_cassette('test_retries_server_error', :record => :new_episodes) do
+      bad_response = mock()
+      bad_response.stubs(:body).returns("{}")
+      bad_response.stubs(:status).returns(500)
+
+      good_response = mock()
+      good_response.stubs(:body).returns('{"foo":100}')
+      good_response.stubs(:status).returns(200)
+      @client.session.expects(:request).twice.returns(bad_response, good_response)
+
+      assert_equal({ "foo" => 100 }, @client.request(nil))
+    end
+  end
+
+  def test_empty_response
+    VCR.use_cassette('test_empty_response', :record => :new_episodes) do
+      bad_response = mock()
+      bad_response.stubs(:body).returns('')
+      JSON.stubs(:parse).returns(nil) # some json parsers return nil instead of raising
+      bad_response.stubs(:status).returns(403)
+
+      @client.session.stubs(:request).returns(bad_response)
+
+      begin
+        @client.request(nil)
+        raise "client error response should have raised"
+      rescue Parse::ParseProtocolError => e
+        assert_equal "HTTP Status 403 Body ", e.error
+      end
+    end
+  end
+
   def test_simple_save
     VCR.use_cassette('test_simple_save', :record => :new_episodes) do
       test_save = Parse::Object.new "TestSave"
@@ -78,4 +123,11 @@ class TestClient < Test::Unit::TestCase
       assert_equal d.keys.length, 0
     end
   end
+
+  def test_get_missing
+    VCR.use_cassette('test_get_missing', :record => :new_episodes) do
+      e = assert_raise(Parse::ParseProtocolError) { Parse.get("SomeClass", "someIdThatDoesNotExist") }
+      assert_equal "101: object not found for get: SomeClass:someIdThatDoesNotExist", e.message
+    end
+  end
 end