parse-stack 1.5.3 → 1.6.0

data/lib/parse/client/protocol.rb

@@ -5,18 +5,30 @@
 module Parse
   # Set of Parse protocol constants.
   module Protocol
-      HOST              = 'api.parse.com'
-      SERVER_URL        = 'https://api.parse.com/1/'
-      APP_ID            = 'X-Parse-Application-Id'
-      API_KEY           = 'X-Parse-REST-API-Key'
-      MASTER_KEY        = 'X-Parse-Master-Key'
-      SESSION_TOKEN     = 'X-Parse-Session-Token'
-      REVOCABLE_SESSION = 'X-Parse-Revocable-Session'
-      EMAIL             = 'X-Parse-Email'
-      PASSWORD          = 'X-Parse-Password'
-      INSTALLATION_ID   = 'Parse-Installation-Id'
-      CONTENT_TYPE      = 'Content-Type'
-      CONTENT_TYPE_FORMAT = 'application/json; charset=utf-8'
+    # The default server url, based on the hosted Parse platform.
+    SERVER_URL        = 'https://api.parse.com/1/'.freeze
+    # The default legacy server url, based on the hosted Parse platform.
+    LEGACY_SERVER_URL = 'https://api.parse.com/1/'.freeze
+    # The request header field to send the application Id.
+    APP_ID            = 'X-Parse-Application-Id'
+    # The request header field to send the REST API key.
+    API_KEY           = 'X-Parse-REST-API-Key'
+    # The request header field to send the Master key.
+    MASTER_KEY        = 'X-Parse-Master-Key'
+    # The request header field to send the revocable Session key.
+    SESSION_TOKEN     = 'X-Parse-Session-Token'
+    # The request header field to request a revocable session token.
+    REVOCABLE_SESSION = 'X-Parse-Revocable-Session'
+    # The request header field to send the installation id.
+    INSTALLATION_ID   = 'Parse-Installation-Id'
+    # The request header field to send an email when authenticating with Parse hosted platform.
+    EMAIL             = 'X-Parse-Email'
+    # The request header field to send the password when authenticating with the Parse hosted platform.
+    PASSWORD          = 'X-Parse-Password'
+    # The request header field for the Content type.
+    CONTENT_TYPE      = 'Content-Type'
+    # The default content type format for sending API requests.
+    CONTENT_TYPE_FORMAT = 'application/json; charset=utf-8'
   end
 
   # All Parse error codes.
@@ -67,8 +79,8 @@ module Parse
   #  LinkedIdMissing	250	Error code indicating that a user cannot be linked to an account because that account's id could not be found.
   #  InvalidLinkedSession	251	Error code indicating that a user with a linked (e.g. Facebook) account has an invalid session.
   #  UnsupportedService	252	Error code indicating that a service being linked (e.g. Facebook or Twitter) is unsupported.
-  module ErrorCodes
-
-  end
+  # module ErrorCodes
+  #
+  # end
 
 end

data/lib/parse/client/response.rb

@@ -3,30 +3,47 @@
 
 require 'active_support'
 require 'active_support/json'
-# This is the model that represents a response from Parse. A Response can also
-# be a set of responses (from a Batch response).
+
 module Parse
 
-  class ResponseError < StandardError; end;
+  # Represents a response from Parse server. A response can also
+  # be a set of responses (from a Batch response).
   class Response
     include Enumerable
 
+    # Code for an unknown error.
     ERROR_INTERNAL = 1
+    # Code when the server returns a 500 or is non-responsive.
     ERROR_SERVICE_UNAVAILABLE = 2
+    # Code when the request times out.
     ERROR_TIMEOUT = 124
+    # Code when the requests per second limit as been exceeded.
     ERROR_EXCEEDED_BURST_LIMIT = 155
+    # Code when a requested record is not found.
     ERROR_OBJECT_NOT_FOUND = 101
+    # Code when the username is missing in request.
     ERROR_USERNAME_MISSING = 200
+    # Code when the password is missing in request.
     ERROR_PASSWORD_MISSING = 201
+    # Code when the username is already in the system.
     ERROR_USERNAME_TAKEN = 202
+    # Code when the email is already in the system.
     ERROR_EMAIL_TAKEN = 203
+    # Code when the email is not found
     ERROR_EMAIL_NOT_FOUND = 205
+    # Code when the email is invalid
     ERROR_EMAIL_INVALID = 125
 
-    ERROR = "error"
-    CODE = "code"
-    RESULTS = "results"
-    COUNT = "count"
+    # The field name for the error.
+    ERROR = "error".freeze
+    # The field name for the success.
+    SUCCESS = "success".freeze
+    # The field name for the error code.
+    CODE = "code".freeze
+    # The field name for the results of the request.
+    RESULTS = "results".freeze
+    # The field name for the count result in a count response.
+    COUNT = "count".freeze
 
     # @!attribute [rw] parse_class
     #  @return [String] the Parse class for this request
@@ -85,7 +102,7 @@ module Parse
       # if batch response, generate array based on the response hash.
       @result.map do |r|
         next r unless r.is_a?(Hash)
-        hash = r["success"] || r[ERROR]
+        hash = r[SUCCESS] || r[ERROR]
         Parse::Response.new hash
       end
     end
@@ -145,6 +162,7 @@ module Parse
       self
     end
 
+    # @!visibility private
     def inspect
       if error?
         "#<#{self.class} @code=#{code} @error='#{error}'>"

data/lib/parse/model/acl.rb

@@ -100,7 +100,7 @@ module Parse
     def permissions
       @permissions ||= {}
     end
-
+    # The key field value for public permissions.
     PUBLIC = "*"
 
     # Create a new ACL with default Public read/write permissions and any

data/lib/parse/model/associations/belongs_to.rb

@@ -57,23 +57,6 @@ module Parse
       #  A hash mapping of all belongs_to associations for this model.
       #  @return [Hash]
 
-      # @!method key?
-      # A dynamically generated method based on the value of `key` passed to the
-      # belongs_to method, which returns true if this instance has a pointer for
-      # this field.
-      # @example
-      #
-      #  class Post < Parse::Object
-      #  	belongs_to :author # generates 'author?'
-      #  end
-      #
-      #  post = Post.new
-      #  post.author? # => false
-      #  post.author = Author.new
-      #  post.author? # => true
-      # @return [Boolean] true if field contains a Parse::Pointer or subclass.
-
-
       # @!method self.belongs_to(key, opts = {})
       # Creates a one-to-one association with another Parse model.
       # @param [Symbol] key The singularized version of the foreign class and the name of the
@@ -106,6 +89,22 @@ module Parse
       # @return [Parse::Object] a Parse::Object subclass when using the accessor
       #  when fetching the association.
 
+      # @!method key?
+      # A dynamically generated method based on the value of `key` passed to the
+      # belongs_to method, which returns true if this instance has a pointer for
+      # this field.
+      # @example
+      #
+      #  class Post < Parse::Object
+      #  	belongs_to :author # generates 'author?'
+      #  end
+      #
+      #  post = Post.new
+      #  post.author? # => false
+      #  post.author = Author.new
+      #  post.author? # => true
+      # @return [Boolean] true if field contains a Parse::Pointer or subclass.
+
       # @!visibility private
       def self.included(base)
         base.extend(ClassMethods)
@@ -130,10 +129,10 @@ module Parse
           set_attribute_method = :"#{key}_set_attribute!"
 
           if self.fields[key].present? && Parse::Properties::BASE_FIELD_MAP[key].nil?
-            raise Parse::Properties::DefinitionError, "Belongs relation #{self}##{key} already defined with type #{klassName}"
+            raise ArgumentError, "Belongs relation #{self}##{key} already defined with type #{klassName}"
           end
           if self.fields[parse_field].present?
-            raise Parse::Properties::DefinitionError, "Alias belongs_to #{self}##{parse_field} conflicts with previously defined property."
+            raise ArgumentError, "Alias belongs_to #{self}##{parse_field} conflicts with previously defined property."
           end
           # store this attribute in the attributes hash with the proper remote column name.
           # we know the type is pointer.

data/lib/parse/model/associations/collection_proxy.rb

@@ -113,6 +113,7 @@ module Parse
       # @!attribute [rw] collection
       #  Set the internal collection of items without dirty tracking or
       #  change notifications.
+      # @return [Array] the collection
       def set_collection!(list)
         @collection = list
       end
@@ -230,6 +231,7 @@ module Parse
         collection.count
       end
 
+      # @return [Hash] a JSON representation
       def as_json(*args)
         collection.as_json(args)
       end
@@ -253,21 +255,25 @@ module Parse
         forward "#{@key}_will_change!"
       end
 
+      # Alias for Array#each
       def each
         return collection.enum_for(:each) unless block_given?
         collection.each &Proc.new
       end
 
+      # Alias for Array#map
       def map
         return collection.enum_for(:map) unless block_given?
         collection.map &Proc.new
       end
 
+      # Alias for Array#select
       def select
         return collection.enum_for(:select) unless block_given?
         collection.select &Proc.new
       end
 
+      # @!visibility private
       def inspect
         "#<#{self.class} changed?=#{changed?} @collection=#{@collection.inspect} >"
       end

data/lib/parse/model/associations/has_many.rb

@@ -366,15 +366,15 @@ module Parse
               results.send(m, *args, &chained_block)
             end
 
-            query.define_singleton_method(:to_s) { self.results.to_s }
-            query.define_singleton_method(:inspect) { self.results.to_a.inspect }
-
+            Parse::Query.apply_auto_introspection!(query)
+            
             return query if block.nil?
             query.results(&block)
           end
 
         end
 
+        # Define a one-to-many or many-to-many association between the local model and a foreign class.
         def has_many(key, scope = nil, **opts)
           opts[:through] ||= :query
 
@@ -398,10 +398,10 @@ module Parse
 
           # verify that the user did not duplicate properties or defined different properties with the same name
           if self.fields[key].present? && Parse::Properties::BASE_FIELD_MAP[key].nil?
-            raise Parse::Properties::DefinitionError, "Has_many property #{self}##{key} already defined with type #{klassName}"
+            raise ArgumentError, "Has_many property #{self}##{key} already defined with type #{klassName}"
           end
           if self.fields[parse_field].present?
-            raise Parse::Properties::DefinitionError, "Alias has_many #{self}##{parse_field} conflicts with previously defined property."
+            raise ArgumentError, "Alias has_many #{self}##{parse_field} conflicts with previously defined property."
           end
           # validations
           validates_presence_of(key) if opts[:required]
@@ -545,7 +545,6 @@ module Parse
       end
 
       # @return [Boolean] true if there are pending relational changes for
-      #  associations defined using Parse Relations.
       def relation_changes?
         changed.any? { |key| relations[key.to_sym] }
       end

data/lib/parse/model/bytes.rb

@@ -11,6 +11,7 @@ module Parse
 
   # Support for the Bytes type in Parse
   class Bytes < Model
+    # The default attributes in a Parse Bytes hash.
     ATTRIBUTES = {__type: :string, base64: :string }.freeze
     # @return [String] the base64 string representing the content
     attr_accessor :base64
@@ -26,7 +27,9 @@ module Parse
       @base64 = (bytes.is_a?(Bytes) ? bytes.base64 : bytes).dup
     end
 
-    # @return [Hash]
+    # @!attribute attributes
+    # Supports for mass assignment of values and encoding to JSON.
+    # @return [ATTRIBUTES]
     def attributes
       ATTRIBUTES
     end

data/lib/parse/model/classes/user.rb

@@ -3,20 +3,22 @@
 
 require_relative '../object'
 module Parse
-  # 200	Error code indicating that the username is missing or empty.
-  class UsernameMissingError < StandardError; end;
-  # 201	Error code indicating that the password is missing or empty.
-  class PasswordMissingError < StandardError; end;
-  # Error code 202: indicating that the username has already been taken.
-  class UsernameTakenError < StandardError; end;
-  # 203	Error code indicating that the email has already been taken.
-  class EmailTakenError < StandardError; end;
-  # 204	Error code indicating that the email is missing, but must be specified.
-  class EmailMissing < StandardError; end;
-  # 205	Error code indicating that a user with the specified email was not found.
-  class EmailNotFound < StandardError; end;
-  # 125	Error code indicating that the email address was invalid.
-  class InvalidEmailAddress < StandardError; end;
+  class Error
+    # 200	Error code indicating that the username is missing or empty.
+    class UsernameMissingError < Error; end;
+    # 201	Error code indicating that the password is missing or empty.
+    class PasswordMissingError < Error; end;
+    # Error code 202: indicating that the username has already been taken.
+    class UsernameTakenError < Error; end;
+    # 203	Error code indicating that the email has already been taken.
+    class EmailTakenError < Error; end;
+    # 204	Error code indicating that the email is missing, but must be specified.
+    class EmailMissing < Error; end;
+    # 205	Error code indicating that a user with the specified email was not found.
+    class EmailNotFound < Error; end;
+    # 125	Error code indicating that the email address was invalid.
+    class InvalidEmailAddress < Error; end;
+  end
 
   # The main class representing the _User table in Parse. A user can either be signed up or anonymous.
   # All users need to have a username and a password, with email being optional but globally unique if set.
@@ -168,20 +170,20 @@ module Parse
     # Adds the third-party authentication data to for a given service.
     # @param service_name [Symbol] The name of the service (ex. :facebook)
     # @param data [Hash] The body of the OAuth data. Dependent on each service.
-    # @raise [ResponseError] If user was not successfully linked
+    # @raise [Parse::Client::ResponseError] If user was not successfully linked
     def link_auth_data!(service_name, **data)
       response = client.set_service_auth_data(id, service_name, data)
-      raise Parse::ResponseError, response if response.error?
+      raise Parse::Client::ResponseError, response if response.error?
       apply_attributes!(response.result)
     end
 
     # Removes third-party authentication data for this user
     # @param service_name [Symbol] The name of the third-party service (ex. :facebook)
-    # @raise [ResponseError] If user was not successfully unlinked
+    # @raise [Parse::Client::ResponseError] If user was not successfully unlinked
     # @return [Boolean] True/false if successful.
     def unlink_auth_data!(service_name)
       response = client.set_service_auth_data(id, service_name, nil)
-      raise Parse::ResponseError, response if response.error?
+      raise Parse::Client::ResponseError, response if response.error?
       apply_attributes!(response.result)
     end
 
@@ -208,21 +210,21 @@ module Parse
 
     # You may set a password for this user when you are creating them. Parse never returns a
     # @param passwd The user's password to be used for signing up.
-    # @raise [Parse::UsernameMissingError] If username is missing.
-    # @raise [Parse::PasswordMissingError] If password is missing.
-    # @raise [Parse::UsernameTakenError] If the username has already been taken.
-    # @raise [Parse::EmailTakenError] If the email has already been taken (or exists in the system).
-    # @raise [Parse::InvalidEmailAddress] If the email is invalid.
-    # @raise [Parse::ResponseError] An unknown error occurred.
+    # @raise [Parse::Error::UsernameMissingError] If username is missing.
+    # @raise [Parse::Error::PasswordMissingError] If password is missing.
+    # @raise [Parse::Error::UsernameTakenError] If the username has already been taken.
+    # @raise [Parse::Error::EmailTakenError] If the email has already been taken (or exists in the system).
+    # @raise [Parse::Error::InvalidEmailAddress] If the email is invalid.
+    # @raise [Parse::Client::ResponseError] An unknown error occurred.
     # @return [Boolean] True if signup it was successful. If it fails an exception is thrown.
     def signup!(passwd = nil)
       self.password = passwd || password
       if username.blank?
-        raise Parse::UsernameMissingError, "Signup requires a username."
+        raise Parse::Error::UsernameMissingError, "Signup requires a username."
       end
 
       if password.blank?
-        raise Parse::PasswordMissingError, "Signup requires a password."
+        raise Parse::Error::PasswordMissingError, "Signup requires a password."
       end
 
       signup_attrs = attribute_updates
@@ -238,17 +240,17 @@ module Parse
 
       case response.code
       when Parse::Response::ERROR_USERNAME_MISSING
-        raise Parse::UsernameMissingError, response
+        raise Parse::Error::UsernameMissingError, response
       when Parse::Response::ERROR_PASSWORD_MISSING
-        raise Parse::PasswordMissingError, response
+        raise Parse::Error::PasswordMissingError, response
       when Parse::Response::ERROR_USERNAME_TAKEN
-        raise Parse::UsernameTakenError, response
+        raise Parse::Error::UsernameTakenError, response
       when Parse::Response::ERROR_EMAIL_TAKEN
-        raise Parse::EmailTakenError, response
+        raise Parse::Error::EmailTakenError, response
       when Parse::Response::ERROR_EMAIL_INVALID
-        raise Parse::InvalidEmailAddress, response
+        raise Parse::Error::InvalidEmailAddress, response
       end
-      raise Parse::ResponseError, response
+      raise Parse::Client::ResponseError, response
     end
 
     # Login and get a session token for this user.
@@ -290,12 +292,12 @@ module Parse
     # Creates a new Parse::User given a hash that maps to the fields defined in your Parse::User collection.
     # @param body [Hash] The hash containing the Parse::User fields. The field `username` and `password` are required.
     # @option opts [Boolean] :master_key Whether the master key should be used for this request.
-    # @raise [UsernameMissingError] If username is missing.
-    # @raise [PasswordMissingError] If password is missing.
-    # @raise [UsernameTakenError] If the username has already been taken.
-    # @raise [EmailTakenError] If the email has already been taken (or exists in the system).
-    # @raise [InvalidEmailAddress] If the email is invalid.
-    # @raise [ResponseError] An unknown error occurred.
+    # @raise [Parse::Error::UsernameMissingError] If username is missing.
+    # @raise [Parse::Error::PasswordMissingError] If password is missing.
+    # @raise [Parse::Error::UsernameTakenError] If the username has already been taken.
+    # @raise [Parse::Error::EmailTakenError] If the email has already been taken (or exists in the system).
+    # @raise [Parse::Error::InvalidEmailAddress] If the email is invalid.
+    # @raise [Parse::Client::ResponseError] An unknown error occurred.
     # @return [User] Returns a successfully created Parse::User.
     def self.create(body, **opts)
       response = client.create_user(body, opts: opts)
@@ -305,15 +307,15 @@ module Parse
 
       case response.code
       when Parse::Response::ERROR_USERNAME_MISSING
-        raise Parse::UsernameMissingError, response
+        raise Parse::Error::UsernameMissingError, response
       when Parse::Response::ERROR_PASSWORD_MISSING
-        raise Parse::PasswordMissingError, response
+        raise Parse::Error::PasswordMissingError, response
       when Parse::Response::ERROR_USERNAME_TAKEN
-        raise Parse::UsernameTakenError, response
+        raise Parse::Error::UsernameTakenError, response
       when Parse::Response::ERROR_EMAIL_TAKEN
-        raise Parse::EmailTakenError, response
+        raise Parse::Error::EmailTakenError, response
       end
-      raise  Parse::ResponseError, response
+      raise  Parse::Client::ResponseError, response
     end
 
     # Automatically and implicitly signup a user if it did not already exists and
@@ -372,7 +374,7 @@ module Parse
     # @see #session!
     def self.session(token, opts = {})
       self.session! token, opts
-    rescue InvalidSessionTokenError => e
+    rescue Parse::Error::InvalidSessionTokenError => e
       nil
     end