parse-ruby-client 0.1.15 → 0.2.0

data/lib/parse/http_client.rb

@@ -0,0 +1,84 @@
+module Parse
+  class HttpClient
+    class TimeoutError < StandardError; end
+
+    attr_accessor :base_url, :headers
+
+    def initialize(base_url=nil, headers = {})
+      @base_url = base_url
+      @headers = headers
+    end
+
+    def build_query(hash)
+      hash.to_a.map{|k, v| "#{k}=#{v}"}.join('&')
+    end
+
+    def request(method, uri, headers, options)
+      NotImplementedError.new("Subclass responsibility")
+    end
+  end
+
+  class NetHttpClient < HttpClient
+    class NetHttpResponseWrapper
+      def initialize(response) @response = response end
+      def status() @response.code.to_i end
+      def body() @response.read_body end
+    end
+
+    def request(method, uri, headers, options)
+      request_class = eval("Net::HTTP::#{method.to_s.capitalize}")
+      uri = "#{uri}?#{options[:query]}" if options[:query]
+      request = request_class.new(uri, @headers.dup.update(headers))
+      request.body = options[:data] if options.has_key?(:data)
+      NetHttpResponseWrapper.new(
+        @client.start do
+          @client.request(request)
+        end
+      )
+    end
+
+    def base_url=(url)
+      @base_url = url
+      @client = Net::HTTP.new(@base_url.sub('https://', ''), 443)
+      @client.use_ssl = true
+    end
+  end
+
+  class PatronHttpClient < HttpClient
+    def initialize(base_url=nil, headers = {})
+      super
+      @session = Patron::Session.new
+      @session.timeout = 30
+      @session.connect_timeout = 30
+      @session.headers.update(@headers)
+    end
+
+    def build_query(hash)
+      Patron::Util.build_query_pairs_from_hash(hash).join('&')
+    end
+
+    def request(method, uri, headers, options)
+      @session.request(method, uri, headers, options)
+    rescue Patron::TimeoutError => e
+      raise HttpClient::TimeoutError.new(e)
+    end
+
+    def base_url
+      @session.base_url
+    end
+
+    def base_url=(url)
+      @session.base_url = url
+    end
+
+    def headers
+      @session.headers
+    end
+
+    def headers=(hash)
+      @session.headers = hash
+    end
+  end
+
+  DEFAULT_HTTP_CLIENT = defined?(JRUBY_VERSION) ? NetHttpClient : PatronHttpClient
+end

data/lib/parse/object.rb

@@ -35,7 +35,7 @@ module Parse
     end
 
     def pointer
-      Parse::Pointer.new(self.merge(Parse::Protocol::KEY_CLASS_NAME => class_name)) unless new?
+      Parse::Pointer.new(rest_api_hash) unless new?
     end
 
     # make it easier to deal with the ambiguity of whether you're passed a pointer or object
@@ -43,68 +43,10 @@ module Parse
       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 ensure 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 do |k,v|
-        if k.is_a? Symbol
-          k = k.to_s
-        end
-
-        if k != Parse::Protocol::KEY_TYPE
-          self[k] = v
-        end
-      end
-
-      self
-    end
-
     def new?
       self["objectId"].nil?
     end
 
-    def safe_hash
-      without_reserved = self.dup
-      Protocol::RESERVED_KEYS.each { |k| without_reserved.delete(k) }
-
-      without_relations = without_reserved
-      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
-
-    def safe_json
-      safe_hash.to_json
-    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.
@@ -116,7 +58,7 @@ module Parse
         method = :post
       end
 
-      body = safe_json
+      body = safe_hash.to_json
       data = Parse.client.request(self.uri, method, body)
 
       if data
@@ -133,20 +75,36 @@ module Parse
       self
     end
 
-    def as_json(*a)
+    # representation of object to send on saves
+    def safe_hash
       Hash[self.map do |key, value|
-        value = if !value.nil?
-          value.respond_to?(:as_json) ? value.as_json : value
+        if Protocol::RESERVED_KEYS.include?(key)
+          nil
+        elsif value.is_a?(Hash) && value[Protocol::KEY_TYPE] == Protocol::TYPE_RELATION
+          nil
+        elsif value.nil?
+          [key, Protocol::DELETE_OP]
         else
-          Protocol::DELETE_OP
+          [key, Parse.pointerize_value(value)]
         end
+      end.compact]
+    end
 
-        [key, value]
+    # full REST api representation of object
+    def rest_api_hash
+      self.merge(Parse::Protocol::KEY_CLASS_NAME => class_name)
+    end
+
+    def to_h(*a)
+      Hash[rest_api_hash.map do |key, value|
+        [key, value.respond_to?(:to_h) ? value.to_h : value]
       end]
     end
+    alias :as_json :to_h
+    alias :to_hash :to_h
 
     def to_json(*a)
-      as_json.to_json(*a)
+      to_h.to_json(*a)
     end
 
     def to_s
@@ -220,6 +178,38 @@ module Parse
 
     private
 
+    # Merge a hash parsed from the JSON representation into
+    # this instance. This will extract the reserved fields,
+    # merge the hash keys, and then ensure 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 do |k,v|
+        if k.is_a? Symbol
+          k = k.to_s
+        end
+
+        if k != Parse::Protocol::KEY_TYPE
+          self[k] = v
+        end
+      end
+
+      self
+    end
+
     def array_op(field, operation, value)
       raise "field #{field} not an array" if self[field] && !self[field].is_a?(Array)
 

data/lib/parse/query.rb

@@ -125,7 +125,17 @@ module Parse
       [: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
+
+      if response.is_a?(Hash) && response.has_key?(Protocol::KEY_RESULTS) && response[Protocol::KEY_RESULTS].is_a?(Array)
+        parsed_results = response[Protocol::KEY_RESULTS].map{|o| Parse.parse_json(class_name, o)}
+        if response.keys.size == 1
+          parsed_results
+        else
+          response.dup.merge(Protocol::KEY_RESULTS => parsed_results)
+        end
+      else
+        raise ParseError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
+      end
     end
 
     private

data/lib/parse/util.rb

@@ -1,7 +1,7 @@
 module Parse
 
   # Parse a JSON representation into a fully instantiated
-  # class. obj can be either a string or a Hash as parsed
+  # class. obj can be either a primitive or a Hash of primitives as parsed
   # by JSON.parse
   # @param class_name [Object]
   # @param obj [Object]
@@ -19,8 +19,6 @@ module Parse
       # 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) }
       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
@@ -54,7 +52,9 @@ module Parse
 
   def Parse.pointerize_value(obj)
     if obj.kind_of?(Parse::Object)
-      obj.pointer
+      p = obj.pointer
+      raise ArgumentError.new("new object used in context requiring pointer #{obj}") unless p
+      p
     elsif obj.is_a?(Array)
       obj.map do |v|
         Parse.pointerize_value(v)

data/parse-ruby-client.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parse-ruby-client"
-  s.version = "0.1.15"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan deLevie", "Adam Alpern"]
-  s.date = "2013-05-22"
+  s.date = "2013-10-08"
   s.description = "A simple Ruby client for the parse.com REST API"
   s.email = "adelevie@gmail.com"
   s.extra_rdoc_files = [
@@ -34,8 +34,8 @@ Gem::Specification.new do |s|
     "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_nils_delete_keys.yml",
     "fixtures/vcr_cassettes/test_batch_update_object.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",
@@ -52,18 +52,21 @@ Gem::Specification.new do |s|
     "fixtures/vcr_cassettes/test_pointer.yml",
     "fixtures/vcr_cassettes/test_save_with_sub_objects.yml",
     "fixtures/vcr_cassettes/test_saving_boolean_values.yml",
+    "fixtures/vcr_cassettes/test_saving_nested_objects.yml",
     "fixtures/vcr_cassettes/test_server_update.yml",
     "fixtures/vcr_cassettes/test_simple_save.yml",
     "fixtures/vcr_cassettes/test_text_file_save.yml",
     "fixtures/vcr_cassettes/test_update.yml",
     "fixtures/vcr_cassettes/test_updated_at.yml",
     "fixtures/vcr_cassettes/test_user_save.yml",
+    "fixtures/vcr_cassettes/test_xget.yml",
     "lib/parse-ruby-client.rb",
     "lib/parse/batch.rb",
     "lib/parse/client.rb",
     "lib/parse/cloud.rb",
     "lib/parse/datatypes.rb",
     "lib/parse/error.rb",
+    "lib/parse/http_client.rb",
     "lib/parse/model.rb",
     "lib/parse/object.rb",
     "lib/parse/protocol.rb",
@@ -106,7 +109,7 @@ Gem::Specification.new do |s|
       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>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.5"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<webmock>, [">= 0"])
       s.add_development_dependency(%q<vcr>, [">= 0"])
@@ -117,7 +120,7 @@ Gem::Specification.new do |s|
       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>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.5"])
       s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<webmock>, [">= 0"])
       s.add_dependency(%q<vcr>, [">= 0"])
@@ -129,7 +132,7 @@ Gem::Specification.new do |s|
     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>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.5"])
     s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<webmock>, [">= 0"])
     s.add_dependency(%q<vcr>, [">= 0"])

data/test/test_batch.rb

@@ -5,6 +5,11 @@ class TestBatch < ParseTestCase
   def test_initialize
     batch = Parse::Batch.new
     assert_equal batch.class, Parse::Batch
+    assert_equal Parse.client, batch.client
+
+    batch = Parse::Batch.new(Parse::Client.new)
+    assert_equal batch.class, Parse::Batch
+    assert_not_equal Parse.client, batch.client
   end
 
   def test_add_request
@@ -91,6 +96,21 @@ class TestBatch < ParseTestCase
     end
   end
 
+  def test_update_nils_delete_keys
+    VCR.use_cassette('test_batch_update_nils_delete_keys', :record => :new_episodes) do
+      post = Parse::Object.new("BatchTestObject")
+      post["foo"] = "1"
+      post.save
+
+      post["foo"] = nil
+      batch = Parse::Batch.new
+      batch.update_object(post)
+      batch.run!
+
+      assert_false post.refresh.keys.include?("foo")
+    end
+  end
+
   def test_delete_object
     VCR.use_cassette('test_batch_delete_object', :record => :new_episodes) do
       objects = [1, 2, 3, 4, 5].map do |i|

data/test/test_datatypes.rb

@@ -18,14 +18,13 @@ class TestDatatypes < Test::Unit::TestCase
   end
 
   def test_date
-    date_time = DateTime.now
-    data = date_time
-    parse_date = Parse::Date.new data
+    date_time = Time.at(0).to_datetime
+    parse_date = Parse::Date.new(date_time)
 
-    assert_equal parse_date.value, date_time
-    assert_equal JSON.parse(parse_date.to_json)["iso"], date_time.iso8601(3)
+    assert_equal date_time, parse_date.value
+    assert_equal "1970-01-01T00:00:00.000Z", JSON.parse(parse_date.to_json)["iso"]
     assert_equal 0, parse_date <=> parse_date
-    assert_equal 0, Parse::Date.new(data) <=> Parse::Date.new(data)
+    assert_equal 0, Parse::Date.new(date_time) <=> Parse::Date.new(date_time)
 
     post = Parse::Object.new("Post")
     post["time"] = parse_date

data/test/test_object.rb

@@ -143,11 +143,19 @@ class TestObject < ParseTestCase
     end
   end
 
+  def test_saving_nested_objects
+    VCR.use_cassette('test_saving_nested_objects', :record => :new_episodes) do
+      post = Parse::Object.new "Post"
+      post["comment"] = Parse::Object.new("Comment", "text" => "testing")
+      assert_raise{post.save}
+    end
+  end
+
   def test_boolean_values_as_json
     post = Parse::Object.new "Post"
     post["read"] = false
     post["published"] = true
-    safe_json_hash = JSON.parse post.safe_json
+    safe_json_hash = JSON.parse post.safe_hash.to_json
     assert_equal false, safe_json_hash["read"]
     assert_equal true, safe_json_hash["published"]
   end
@@ -269,17 +277,4 @@ class TestObject < ParseTestCase
       assert_equal 'baz', bar['baz']
     end
   end
-
-  def test_circular_save
-    VCR.use_cassette('test_circular_save', :record => :new_episodes) do
-      bar = Parse::Object.new("CircularBar", "text" => "bar")
-      bar_2 = Parse::Object.new("CircularBar", "bar" => bar, "text" => "bar_2")
-      bar_2.save
-      bar['bar'] = bar_2
-      assert bar.save
-
-      assert_equal "bar_2", bar["bar"]["text"]
-      assert_equal "bar", bar["bar"]["bar"]["text"]
-    end
-  end
 end