parse_resource 1.7.3 → 1.8.0

data/lib/parse_resource/client.rb

@@ -0,0 +1,8 @@
+require "rest-client"
+require "json"
+
+module ParseResource
+	class Client
+		
+	end
+end

data/lib/parse_resource/parse_error.rb

@@ -1,34 +1,48 @@
 class ParseError
+  # ParseError actually represents both HTTP & parse.com error codes. If the
+  # HTTP response is 400, one can inspect the first element of the error
+  # converted to_array for the HTTP error code and the 2nd element for the
+  # parse error response.
+  attr_accessor :msg, :code, :error
   
+  # @param [String] an error code, e.g. "400"
+  # @param [Object] an optional error mesg/object.
   def initialize(code, msg="")
     @msg = msg
-    case code
-    when 202
-      @error = [:username, "must be unique"]
-    when 111
-      @error = [:base, "field set to incorrect type. Error code #{code}. #{msg}"]
-    when 125
-      @error = [:email, "must be valid"]
-    when 122
-      @error = [:file_name, "contains only a-zA-Z0-9_. characters and is between 1 and 36 characters."]
-    when 204
-      @error = [:email, "must not be missing"]
-    when 203
-      @error = [:email, "has already been taken"]
-    when 200
-      @error = [:username, "is missing or empty"]
-    when 201
-      @error = [:password, "is missing or empty"]
-    when 205
-      @error = [:user, "with specified email not found"]
+    @code = code
+    case code.to_s
+    when "111"
+      @error = "Invalid type."
+    when "135"
+      @error = "Unknown device type."
+    when "202"
+      @error = "Username already taken."
+    when "400"
+      @error = "Bad Request: The request cannot be fulfilled due to bad syntax."
+    when "401"
+      @error = "Unauthorized: Check your App ID & Master Key."
+    when "403"
+      @error = "Forbidden: You do not have permission to access or modify this."
+    when "408"
+      @error = "Request Timeout: The request was not completed within the time the server was prepared to wait."
+    when "415"
+      @error = "Unsupported Media Type"
+    when "500"
+      @error = "Internal Server Error"
+    when "502"
+      @error = "Bad Gateway"
+    when "503"
+      @error = "Service Unavailable"
+    when "508"
+      @error = "Loop Detected"
     else
-      raise "Parse error #{code}: #{@error}"
+      @error = "Unknown Error"
+      raise "Parse error #{code}: #{@error} #{@msg}"
     end
   end
   
   def to_array
-    @error[1] = @error[1] + " " + @msg
-    @error
+    [ @code, @msg ]
   end
   
 end

data/lib/parse_resource/query.rb

@@ -14,6 +14,9 @@ class Query
   end
 
   def limit(limit)
+    # If > 1000, set chunking, because large queries over 1000 need it with Parse
+    chunk(1000) if limit > 1000
+
     criteria[:limit] = limit
     self
   end
@@ -23,12 +26,15 @@ class Query
     self
   end
   
-  # deprecating until it works
-  #def order(attribute)
-  #  attribute = attribute.to_sym if attribute.is_a?(String)
-  #  criteria[:order] = attribute
-  #  self
-  #end
+  def order(attr)
+    orders = attr.split(" ")
+    if orders.count > 1
+      criteria[:order] = orders.last.downcase == "desc" ? "-#{orders.first}" : "#{orders.first}"
+    else
+      criteria[:order] = orders.first
+    end
+    self
+  end
 
   def skip(skip)
    criteria[:skip] = skip
@@ -37,10 +43,47 @@ class Query
 
   def count(count=1)
     criteria[:count] = count
-    #self
     all
   end
 
+  # Divides the query into multiple chunks if you're running into RestClient::BadRequest errors.
+  def chunk(count=100)
+    criteria[:chunk] = count
+    self
+  end
+
+  def near(klass, geo_point, options)
+    if geo_point.is_a? Array
+      geo_point = ParseGeoPoint.new :latitude => geo_point[0], :longitude => geo_point[1]
+    end
+
+    query = { "$nearSphere" => geo_point.to_pointer }
+    if options[:maxDistanceInMiles]
+      query["$maxDistanceInMiles"] = options[:maxDistanceInMiles]
+    elsif options[:maxDistanceInRadians]
+      query["$maxDistanceInRadians"] = options[:maxDistanceInRadians]
+    elsif options[:maxDistanceInKilometers]
+      query["$maxDistanceInKilometers"] = options[:maxDistanceInKilometers]
+    end
+
+    criteria[:conditions].merge!({ klass => query })
+    self
+  end
+
+  def within_box(klass, geo_point_south, geo_point_north)
+    if geo_point_south.is_a? Array
+      geo_point_south = ParseGeoPoint.new :latitude => geo_point_south[0], :longitude => geo_point_south[1]
+    end
+
+    if geo_point_north.is_a? Array
+      geo_point_north = ParseGeoPoint.new :latitude => geo_point_north[0], :longitude => geo_point_north[1]
+    end
+
+    query = { "$within" => { "$box" => [geo_point_south.to_pointer, geo_point_north.to_pointer]}}
+    criteria[:conditions].merge!({ klass => query })
+    self
+  end
+
   def execute
     params = {}
     params.merge!({:where => criteria[:conditions].to_json}) if criteria[:conditions]
@@ -50,6 +93,8 @@ class Query
     params.merge!({:include => criteria[:include]}) if criteria[:include]
     params.merge!({:order => criteria[:order]}) if criteria[:order]
 
+    return chunk_results(params) if criteria[:chunk]
+
     resp = @klass.resource.get(:params => params)
     
     if criteria[:count] == 1
@@ -61,11 +106,58 @@ class Query
     end
   end
 
+  def chunk_results(params={})
+    criteria[:limit] ||= 100
+    
+    start_row = criteria[:skip].to_i
+    end_row = [criteria[:limit].to_i - start_row - 1, 1].max
+    result = []
+    
+    # Start at start_row, go to end_row, get results in chunks
+    (start_row..end_row).each_slice(criteria[:chunk].to_i) do |slice|
+      params[:skip] = slice.first
+      params[:limit] = slice.length # Either the chunk size or the end of the limited results
+
+      resp = @klass.resource.get(:params => params)
+      results = JSON.parse(resp)['results']
+      result = result + results.map {|r| @klass.model_name.constantize.new(r, false)}
+      break if results.length < params[:limit] # Got back fewer than we asked for, so exit.
+    end
+    result
+  end
+
+  def first
+    limit(1)
+    execute.first
+  end
+
   def all
     execute
   end
 
   def method_missing(meth, *args, &block)
+    method_name = method_name.to_s
+    if method_name.start_with?("find_by_")
+      attrib   = method_name.gsub(/^find_by_/,"")
+      finder_name = "find_all_by_#{attrib}"
+
+      define_singleton_method(finder_name) do |target_value|
+        where({attrib.to_sym => target_value}).first
+      end
+
+      send(finder_name, args[0])
+
+    elsif method_name.start_with?("find_all_by_")
+      attrib   = method_name.gsub(/^find_all_by_/,"")
+      finder_name = "find_all_by_#{attrib}"
+
+      define_singleton_method(finder_name) do |target_value|
+        where({attrib.to_sym => target_value}).all
+      end
+
+      send(finder_name, args[0])
+    end
+
     if Array.method_defined?(meth)
       all.send(meth, *args, &block)
     else

data/lib/parse_resource/query_methods.rb

@@ -0,0 +1,64 @@
+#require 'parse_resource'
+require 'parse_resource/query'
+
+module ParseResource
+
+	module QueryMethods
+
+		module ClassMethods
+	    # Include the attributes of a parent ojbect in the results
+	    # Similar to ActiveRecord eager loading
+	    #
+	    def include_object(parent)
+	      Query.new(self).include_object(parent)
+	    end
+
+	    # Add this at the end of a method chain to get the count of objects, instead of an Array of objects
+	    def count
+	      #https://www.parse.com/docs/rest#queries-counting
+	      Query.new(self).count(1)
+	    end
+
+	    # Find all ParseResource::Base objects for that model.
+	    #
+	    # @return [Array] an `Array` of objects that subclass `ParseResource`.
+	    def all
+	      Query.new(self).all
+	    end
+
+	    # Find the first object. Fairly random, not based on any specific condition.
+	    #
+	    def first
+	      Query.new(self).limit(1).first
+	    end
+
+	    # Limits the number of objects returned
+	    #
+	    def limit(n)
+	      Query.new(self).limit(n)
+	    end
+
+	    # Skip the number of objects
+	    #
+	    def skip(n)
+	      Query.new(self).skip(n)
+	    end
+	    
+	    def order(attr)
+	      Query.new(self).order(attr)
+      end
+
+      def near(near, geo_point, options={})
+        Query.new(self).near(near, geo_point, options)
+      end
+
+      def within_box(near, geo_point_south, geo_point_north)
+        Query.new(self).within_box(near, geo_point_south, geo_point_north)
+      end
+		end
+
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+	end
+end

data/lib/parse_resource/types/parse_geopoint.rb

@@ -0,0 +1,19 @@
+class ParseGeoPoint
+  attr_accessor :latitude, :longitude
+
+  def initialize(hash=nil)
+    if hash.nil?
+      self.latitude=0.0
+      self.longitude=0.0
+    else
+      self.latitude = hash["latitude"] || hash[:latitude]
+      self.longitude = hash["longitude"] || hash[:longitude]
+    end
+
+  end
+
+  def to_pointer
+    {"__type"=>"GeoPoint", :latitude=> self.latitude, :longitude => self.longitude}
+  end
+
+end

data/parse_resource.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parse_resource"
-  s.version = "1.7.3"
+  s.version = "1.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan deLevie"]
-  s.date = "2012-09-20"
+  s.date = "2013-04-17"
   s.description = ""
   s.email = "adelevie@gmail.com"
   s.extra_rdoc_files = [
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
     "README.md"
   ]
   s.files = [
+    ".DS_Store",
     ".document",
     ".travis.yml",
     "Gemfile",
@@ -25,38 +26,58 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
+    "fixtures/.DS_Store",
+    "fixtures/vcr_cassettes/.DS_Store",
     "fixtures/vcr_cassettes/test_all.yml",
     "fixtures/vcr_cassettes/test_attribute_getters.yml",
     "fixtures/vcr_cassettes/test_attribute_setters.yml",
     "fixtures/vcr_cassettes/test_authenticate.yml",
     "fixtures/vcr_cassettes/test_chained_wheres.yml",
+    "fixtures/vcr_cassettes/test_chunk.yml",
     "fixtures/vcr_cassettes/test_count.yml",
     "fixtures/vcr_cassettes/test_create.yml",
     "fixtures/vcr_cassettes/test_created_at.yml",
     "fixtures/vcr_cassettes/test_destroy.yml",
     "fixtures/vcr_cassettes/test_destroy_all.yml",
     "fixtures/vcr_cassettes/test_each.yml",
+    "fixtures/vcr_cassettes/test_fetching_closest_10.yml",
+    "fixtures/vcr_cassettes/test_fetching_closest_by_kilometers.yml",
+    "fixtures/vcr_cassettes/test_fetching_closest_by_miles.yml",
+    "fixtures/vcr_cassettes/test_fetching_closest_by_radians.yml",
+    "fixtures/vcr_cassettes/test_fetching_closest_within_box.yml",
+    "fixtures/vcr_cassettes/test_fetching_geopoint_field.yml",
     "fixtures/vcr_cassettes/test_find.yml",
     "fixtures/vcr_cassettes/test_find_all_by.yml",
     "fixtures/vcr_cassettes/test_find_by.yml",
     "fixtures/vcr_cassettes/test_first.yml",
     "fixtures/vcr_cassettes/test_id.yml",
+    "fixtures/vcr_cassettes/test_installation_creation.yml",
+    "fixtures/vcr_cassettes/test_installation_creation_validation_check.yml",
     "fixtures/vcr_cassettes/test_limit.yml",
     "fixtures/vcr_cassettes/test_map.yml",
+    "fixtures/vcr_cassettes/test_order_ascending.yml",
+    "fixtures/vcr_cassettes/test_order_descending.yml",
     "fixtures/vcr_cassettes/test_save.yml",
+    "fixtures/vcr_cassettes/test_save_all_and_destroy_all.yml",
+    "fixtures/vcr_cassettes/test_saving_geo_point_with_quick_init.yml",
+    "fixtures/vcr_cassettes/test_saving_geopoint_with_coords.yml",
     "fixtures/vcr_cassettes/test_skip.yml",
     "fixtures/vcr_cassettes/test_update.yml",
     "fixtures/vcr_cassettes/test_updated_at.yml",
     "fixtures/vcr_cassettes/test_username_should_be_unique.yml",
     "fixtures/vcr_cassettes/test_where.yml",
     "lib/.DS_Store",
+    "lib/kaminari_extension.rb",
     "lib/parse_resource.rb",
     "lib/parse_resource/base.rb",
+    "lib/parse_resource/client.rb",
     "lib/parse_resource/parse_error.rb",
     "lib/parse_resource/parse_exceptions.rb",
     "lib/parse_resource/parse_user.rb",
     "lib/parse_resource/parse_user_validator.rb",
     "lib/parse_resource/query.rb",
+    "lib/parse_resource/query_methods.rb",
+    "lib/parse_resource/types/parse_geopoint.rb",
     "parse_resource.gemspec",
     "parse_resource.yml",
     "rdoc/ParseResource.html",
@@ -66,10 +87,12 @@ Gem::Specification.new do |s|
     "rdoc/rdoc.css",
     "test/active_model_lint_test.rb",
     "test/helper.rb",
+    "test/test_parse_installation.rb",
     "test/test_parse_resource.rb",
     "test/test_parse_user.rb",
     "test/test_query.rb",
-    "test/test_query_options.rb"
+    "test/test_query_options.rb",
+    "test/test_types.rb"
   ]
   s.homepage = "http://github.com/adelevie/parse_resource"
   s.licenses = ["MIT"]
@@ -85,44 +108,41 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<activesupport>, [">= 0"])
       s.add_runtime_dependency(%q<activemodel>, [">= 0"])
       s.add_runtime_dependency(%q<json>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1.5"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<reek>, ["~> 1.2.8"])
       s.add_development_dependency(%q<rest-client>, [">= 0"])
       s.add_development_dependency(%q<activesupport>, [">= 0"])
       s.add_development_dependency(%q<activemodel>, [">= 0"])
       s.add_development_dependency(%q<vcr>, [">= 0"])
       s.add_development_dependency(%q<webmock>, [">= 0"])
+      s.add_development_dependency(%q<turn>, [">= 0"])
     else
       s.add_dependency(%q<rest-client>, [">= 0"])
       s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<activemodel>, [">= 0"])
       s.add_dependency(%q<json>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.1.5"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
       s.add_dependency(%q<reek>, ["~> 1.2.8"])
       s.add_dependency(%q<rest-client>, [">= 0"])
       s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<activemodel>, [">= 0"])
       s.add_dependency(%q<vcr>, [">= 0"])
       s.add_dependency(%q<webmock>, [">= 0"])
+      s.add_dependency(%q<turn>, [">= 0"])
     end
   else
     s.add_dependency(%q<rest-client>, [">= 0"])
     s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<activemodel>, [">= 0"])
     s.add_dependency(%q<json>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.1.5"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
     s.add_dependency(%q<reek>, ["~> 1.2.8"])
     s.add_dependency(%q<rest-client>, [">= 0"])
     s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<activemodel>, [">= 0"])
     s.add_dependency(%q<vcr>, [">= 0"])
     s.add_dependency(%q<webmock>, [">= 0"])
+    s.add_dependency(%q<turn>, [">= 0"])
   end
 end