parse-stack 1.4.3 → 1.5.1

data/lib/parse/client/response.rb

@@ -1,3 +1,52 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Member name	Value	Description
+# OtherCause	-1	Error code indicating that an unknown error or an error unrelated to Parse occurred.
+# InternalServerError	1	Error code indicating that something has gone wrong with the server. If you get this error code, it is Parse's fault. Please report the bug to https://parse.com/help.
+# ConnectionFailed	100	Error code indicating the connection to the Parse servers failed.
+# ObjectNotFound	101	Error code indicating the specified object doesn't exist.
+# InvalidQuery	102	Error code indicating you tried to query with a datatype that doesn't support it, like exact matching an array or object.
+# InvalidClassName	103	Error code indicating a missing or invalid classname. Classnames are case-sensitive. They must start with a letter, and a-zA-Z0-9_ are the only valid characters.
+# MissingObjectId	104	Error code indicating an unspecified object id.
+# InvalidKeyName	105	Error code indicating an invalid key name. Keys are case-sensitive. They must start with a letter, and a-zA-Z0-9_ are the only valid characters.
+# InvalidPointer	106	Error code indicating a malformed pointer. You should not see this unless you have been mucking about changing internal Parse code.
+# InvalidJSON	107	Error code indicating that badly formed JSON was received upstream. This either indicates you have done something unusual with modifying how things encode to JSON, or the network is failing badly.
+# CommandUnavailable	108	Error code indicating that the feature you tried to access is only available internally for testing purposes.
+# NotInitialized	109	You must call Parse.initialize before using the Parse library.
+# IncorrectType	111	Error code indicating that a field was set to an inconsistent type.
+# InvalidChannelName	112	Error code indicating an invalid channel name. A channel name is either an empty string (the broadcast channel) or contains only a-zA-Z0-9_ characters and starts with a letter.
+# PushMisconfigured	115	Error code indicating that push is misconfigured.
+# ObjectTooLarge	116	Error code indicating that the object is too large.
+# OperationForbidden	119	Error code indicating that the operation isn't allowed for clients.
+# CacheMiss	120	Error code indicating the result was not found in the cache.
+# InvalidNestedKey	121	Error code indicating that an invalid key was used in a nested JSONObject.
+# InvalidFileName	122	Error code indicating that an invalid filename was used for ParseFile. A valid file name contains only a-zA-Z0-9_. characters and is between 1 and 128 characters.
+# InvalidACL	123	Error code indicating an invalid ACL was provided.
+# Timeout	124	Error code indicating that the request timed out on the server. Typically this indicates that the request is too expensive to run.
+# InvalidEmailAddress	125	Error code indicating that the email address was invalid.
+# DuplicateValue	137	Error code indicating that a unique field was given a value that is already taken.
+# InvalidRoleName	139	Error code indicating that a role's name is invalid.
+# ExceededQuota	140	Error code indicating that an application quota was exceeded. Upgrade to resolve.
+# ScriptFailed	141	Error code indicating that a Cloud Code script failed.
+# ValidationFailed	142	Error code indicating that a Cloud Code validation failed.
+# FileDeleteFailed	153	Error code indicating that deleting a file failed.
+# RequestLimitExceeded	155	Error code indicating that the application has exceeded its request limit.
+# InvalidEventName	160	Error code indicating that the provided event name is invalid.
+# UsernameMissing	200	Error code indicating that the username is missing or empty.
+# PasswordMissing	201	Error code indicating that the password is missing or empty.
+# UsernameTaken	202	Error code indicating that the username has already been taken.
+# EmailTaken	203	Error code indicating that the email has already been taken.
+# EmailMissing	204	Error code indicating that the email is missing, but must be specified.
+# EmailNotFound	205	Error code indicating that a user with the specified email was not found.
+# SessionMissing	206	Error code indicating that a user object without a valid session could not be altered.
+# MustCreateUserThroughSignup	207	Error code indicating that a user can only be created through signup.
+# AccountAlreadyLinked	208	Error code indicating that an an account being linked is already linked to another user.
+# InvalidSessionToken	209	Error code indicating that the current session token is invalid.
+# 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.
+
 require 'active_support'
 require 'active_support/json'
 # This is the model that represents a response from Parse. A Response can also
@@ -13,11 +62,15 @@ module Parse
     ERROR_TIMEOUT = 124
     ERROR_EXCEEDED_BURST_LIMIT = 155
     ERROR_OBJECT_NOT_FOUND = 101
-
-    ERROR = "error".freeze
-    CODE = "code".freeze
-    RESULTS = "results".freeze
-    COUNT = "count".freeze
+    ERROR_USERNAME_MISSING = 200
+    ERROR_PASSWORD_MISSING = 201
+    ERROR_USERNAME_TAKEN = 202
+    ERROR_EMAIL_TAKEN = 203
+
+    ERROR = "error"
+    CODE = "code"
+    RESULTS = "results"
+    COUNT = "count"
     # A response has a result or (a code and an error)
     attr_accessor :parse_class, :code, :error, :result, :http_status
     attr_accessor :request # capture request that created result
@@ -67,7 +120,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".freeze] || r["error".freeze]
+        hash = r["success"] || r[ERROR]
         Parse::Response.new hash
       end
     end

data/lib/parse/client.rb

@@ -19,22 +19,34 @@ require_relative "api/all"
 module Parse
 
   # This is an exception that is thrown if there is a client connectivity issue
-  class ConnectionError < Exception; end;
-  class TimeoutError < Exception; end;
-  class ProtocolError < Exception; end;
-  class ServerError < Exception; end;
-  class ServiceUnavailableError < Exception; end;
-  class AuthenticationError < Exception; end;
-  class RequestLimitExceededError < Exception; end;
-  class InvalidSessionTokenError < Exception; end;
+  class ConnectionError < StandardError; end;
+  class TimeoutError < StandardError; end;
+  class ProtocolError < StandardError; end;
+  class ServerError < StandardError; end;
+  class ServiceUnavailableError < StandardError; end;
+  class AuthenticationError < StandardError; end;
+  class RequestLimitExceededError < StandardError; end;
+  class InvalidSessionTokenError < StandardError; end;
 
   # helper method to get the config variables.
   def self.config(s = :default)
-    Parse::Client.session(s).config
+    Parse::Client.client(s).config
+  end
+
+  def self.set_config(field, value, s = :default)
+    Parse::Client.client(s).update_config({ field => value })
+  end
+
+  def self.update_config(params, s = :default)
+    Parse::Client.client(s).update_config(params)
   end
 
   def self.config!(s = :default)
-    Parse::Client.session(s).config!
+    Parse::Client.client(s).config!
+  end
+
+  def self.client(conn = :default)
+    Parse::Client.client(conn)
   end
 
   # Main class for the client. The client class is based on a Faraday stack.
@@ -61,23 +73,37 @@ module Parse
     # The client can support multiple sessions. The first session created, will be placed
     # under the default session tag. The :default session will be the default client to be used
     # by the other classes including Parse::Query and Parse::Objects
-    @@sessions = { default: nil }
+    @clients = { default: nil }
+    class << self
+      attr_reader :clients
+      def session?(v = :default)
+          puts '[Warning] Parse::Client#session is DEPRECATED. Please use Parse::Client#client instead.'
+          self.client? v
+      end
 
-    def self.session?(v = :default)
-        @@sessions[v].present?
-    end
-    # get a session for a given tag. This will also create a new one for the tag if not specified.
-    def self.session(connection = :default)
-      #warn "Please call Parse::Client.setup() to initialize your parse session" if @@sessions.empty? || @@sessions[:default].nil?
-      @@sessions[connection] ||= self.new
-    end
+      # DEPRECATED
+      # get a session for a given tag. This will also create a new one for the tag if not specified.
+      def session(connection = :default)
+        puts '[Warning] Parse::Client#session is DEPRECATED. Please use Parse::Client#client instead.'
+        self.client(connection)
+      end
+
+      def client?(v = :default)
+        @clients[v].present?
+      end
+
+      def client(connection = :default)
+        @clients[connection] ||= self.new
+      end
+
+      def setup(opts = {})
+        # If Proc.new is called from inside a method without any arguments of
+        # its own, it will return a new Proc containing the block given to
+        # its surrounding method.
+        # http://mudge.name/2011/01/26/passing-blocks-in-ruby-without-block.html
+        @clients[:default] = self.new(opts, &Proc.new)
+      end
 
-    def self.setup(opts = {})
-      # If Proc.new is called from inside a method without any arguments of
-      # its own, it will return a new Proc containing the block given to
-      # its surrounding method.
-      # http://mudge.name/2011/01/26/passing-blocks-in-ruby-without-block.html
-      @@sessions[:default] = self.new(opts, &Proc.new)
     end
 
     # This builds a new Parse::Client stack. The options are:
@@ -108,7 +134,7 @@ module Parse
       #Configure Faraday
       opts[:faraday] ||= {}
       opts[:faraday].merge!(:url => @server_url)
-      @session = Faraday.new(opts[:faraday]) do |conn|
+      @conn = Faraday.new(opts[:faraday]) do |conn|
         #conn.request :json
 
         conn.response :logger if opts[:logging]
@@ -134,7 +160,7 @@ module Parse
 
         if opts[:cache].present? && opts[:expires].to_i > 0
           unless opts[:cache].is_a?(Moneta::Transformer)
-            raise "Parse::Client option :cache needs to be a type of Moneta::Transformer store."
+            raise ArgumentError, "Parse::Client option :cache needs to be a type of Moneta::Transformer store."
           end
           self.cache = opts[:cache]
           conn.use Parse::Middleware::Caching, self.cache, {expires: opts[:expires].to_i }
@@ -145,7 +171,7 @@ module Parse
         conn.adapter opts[:adapter]
 
       end
-      @@sessions[:default] ||= self
+      Parse::Client.clients[:default] ||= self
       self
     end
 
@@ -154,7 +180,7 @@ module Parse
     end
 
     def url_prefix
-      @session.url_prefix
+      @conn.url_prefix
     end
 
     def clear_cache!
@@ -189,10 +215,10 @@ module Parse
       # http method
       method = method.downcase.to_sym
       # set the User-Agent
-      headers["User-Agent".freeze] = "Parse-Server Ruby Client v#{Parse::Stack::VERSION}".freeze
+      headers["User-Agent"] = "Parse-Stack v#{Parse::Stack::VERSION}"
 
       if opts[:cache] == false
-        headers[Parse::Middleware::Caching::CACHE_CONTROL] = "no-cache".freeze
+        headers[Parse::Middleware::Caching::CACHE_CONTROL] = "no-cache"
       elsif opts[:cache].is_a?(Numeric)
         # specify the cache duration of this request
         headers[Parse::Middleware::Caching::CACHE_EXPIRES_DURATION] = opts[:cache].to_i
@@ -202,16 +228,18 @@ module Parse
         headers[Parse::Middleware::Authentication::DISABLE_MASTER_KEY] = "true"
       end
 
-      if opts[:session_token].present?
+      token = opts[:session_token]
+      if token.present?
+        token = token.session_token if token.respond_to?(:session_token)
         headers[Parse::Middleware::Authentication::DISABLE_MASTER_KEY] = "true"
-        headers[Parse::Protocol::SESSION_TOKEN] = opts[:session_token]
+        headers[Parse::Protocol::SESSION_TOKEN] = token
       end
 
       #if it is a :get request, then use query params, otherwise body.
       params = (method == :get ? query : body) || {}
       # if the path does not start with the '/1/' prefix, then add it to be nice.
       # actually send the request and return the body
-      response_env = @session.send(method, uri, params, headers)
+      response_env = @conn.send(method, uri, params, headers)
       response = response_env.body
       response.request = _request
 
@@ -296,7 +324,7 @@ module Parse
     end
 
     def send_request(req) #Parse::Request object
-      raise "Object not of Parse::Request type." unless req.is_a?(Parse::Request)
+      raise ArgumentError, "Object not of Parse::Request type." unless req.is_a?(Parse::Request)
       request req.method, req.path, req.body, req.headers
     end
 
@@ -313,7 +341,7 @@ module Parse
       module ClassMethods
           attr_accessor :client
           def client
-            @client ||= Parse::Client.session #defaults to :default tag
+            @client ||= Parse::Client.client #defaults to :default tag
           end
       end
 
@@ -335,16 +363,18 @@ module Parse
   end
 
   # Helper method to call cloud functions and get results
-  def self.trigger_job(name, body, session: :default, raw: false)
-    response = Parse::Client.session(session).trigger_job(name, body)
-    return response if raw
+  def self.trigger_job(name, body = {}, **opts)
+    conn = opts[:session] || opts[:client] ||  :default
+    response = Parse::Client.client(conn).trigger_job(name, body)
+    return response if opts[:raw].present?
     response.error? ? nil : response.result["result"]
   end
 
   # Helper method to call cloud functions and get results
-  def self.call_function(name, body, session: :default, raw: false)
-    response = Parse::Client.session(session).call_function(name, body)
-    return response if raw
+  def self.call_function(name, body = {}, **opts)
+    conn = opts[:session] || opts[:client] ||  :default
+    response = Parse::Client.client(conn).call_function(name, body)
+    return response if opts[:raw].present?
     response.error? ? nil : response.result["result"]
   end
 

data/lib/parse/model/acl.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 # An ACL represents the Parse Permissions object used for each record. In Parse,
 # it is composed a hash-like object that represent Parse::User objectIds and/or Parse::Role
@@ -12,12 +14,28 @@
 # of dirty tracking.
 module Parse
 
-  class ACL
-    # The internal permissions hash and delegate accessors
-    attr_accessor :permissions, :delegate
+  # Base class for supporting custom data types
+  class DataType
     include ::ActiveModel::Model
     include ::ActiveModel::Serializers::JSON
-    PUBLIC = "*".freeze # Public priviledges are '*' key in Parse
+    def attributes
+      {}
+    end
+
+    def self.typecast(value, **opts)
+      value
+    end
+
+    def as_json(*args)
+      {}.as_json
+    end
+
+  end
+
+  class ACL < DataType
+    # The internal permissions hash and delegate accessors
+    attr_accessor :permissions, :delegate
+    PUBLIC = "*" # Public priviledges are '*' key in Parse
 
     # provide a set of acls and the delegate (for dirty tracking)
     # { '*' => { "read": true, "write": true } }

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative '../pointer'
 require_relative 'collection_proxy'
 require_relative 'pointer_collection_proxy'
@@ -32,6 +35,11 @@ module Parse
           opts = {as: key, field: key.to_s.camelize(:lower), required: false}.merge(opts)
           klassName = opts[:as].to_parse_class
           parse_field = opts[:field].to_sym
+
+          ivar = :"@#{key}"
+          will_change_method = :"#{key}_will_change!"
+          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}"
           end
@@ -56,7 +64,7 @@ module Parse
 
           # We generate the getter method
           define_method(key) do
-            ivar = :"@#{key}"
+
             val = instance_variable_get ivar
             # We provide autofetch functionality. If the value is nil and the
             # current Parse::Object is a pointer, then let's auto fetch it
@@ -68,37 +76,41 @@ module Parse
             # if for some reason we retrieved either from store or fetching a
             # hash, lets try to buid a Pointer of that type.
 
-            if val.is_a?(Hash) && ( val["__type"].freeze == "Pointer".freeze ||  val["__type"].freeze == "Object".freeze )
-              val = Parse::Object.build val, ( val["className"] || klassName )
+            if val.is_a?(Hash) && ( val["__type"] == "Pointer" ||  val["__type"] == "Object" )
+              val = Parse::Object.build val, ( val[Parse::Model::KEY_CLASS_NAME] || klassName )
               instance_variable_set ivar, val
             end
             val
           end
 
+          if self.method_defined?("#{key}?")
+            puts "Creating belongs_to helper :#{key}?. Will overwrite existing method #{self}##{key}?."
+          end
+
           define_method("#{key}?") do
             self.send(key).is_a?(Parse::Pointer)
           end
 
           # A proxy setter method that has dirty tracking enabled.
           define_method("#{key}=") do |val|
-            send "#{key}_set_attribute!", val, true
+            send set_attribute_method, val, true
           end
 
           # We only support pointers, either by object or by transforming a hash.
-          define_method("#{key}_set_attribute!") do |val, track = true|
+          define_method(set_attribute_method) do |val, track = true|
             if val == Parse::Properties::DELETE_OP
               val = nil
-            elsif val.is_a?(Hash) && ( val["__type"].freeze == "Pointer".freeze ||  val["__type"].freeze == "Object".freeze )
-              val = Parse::Object.build val, ( val["className"] || klassName )
+            elsif val.is_a?(Hash) && ( val["__type"] == "Pointer" ||  val["__type"] == "Object" )
+              val = Parse::Object.build val, ( val[Parse::Model::KEY_CLASS_NAME] || klassName )
             end
 
             if track == true
-              send :"#{key}_will_change!" unless val == instance_variable_get( :"@#{key}" )
+              send will_change_method unless val == instance_variable_get( ivar )
             end
 
             # Never set an object that is not a Parse::Pointer
             if val.nil? || val.is_a?(Parse::Pointer)
-              instance_variable_set(:"@#{key}", val)
+              instance_variable_set(ivar, val)
             else
               warn "[#{self.class}] Invalid value #{val} set for belongs_to field #{key}"
             end
@@ -110,7 +122,7 @@ module Parse
           if self.method_defined?(parse_field) == false
             alias_method parse_field, key
             alias_method "#{parse_field}=", "#{key}="
-            alias_method "#{parse_field}_set_attribute!", "#{key}_set_attribute!"
+            alias_method "#{parse_field}_set_attribute!", set_attribute_method
           elsif parse_field.to_sym != :objectId
             warn "Alias belongs_to method #{self}##{parse_field} already defined."
           end

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -18,7 +21,7 @@ module Parse
     class CollectionProxy
       include ::ActiveModel::Model
       include ::ActiveModel::Dirty
-
+      include ::Enumerable
       attr_accessor :collection, :delegate, :loaded
       attr_reader :delegate, :key
       attr_accessor :parse_class
@@ -195,6 +198,16 @@ module Parse
         collection.each &Proc.new
       end
 
+      def map
+        return collection.enum_for(:map) unless block_given?
+        collection.map &Proc.new
+      end
+
+      def select
+        return collection.enum_for(:select) unless block_given?
+        collection.select &Proc.new
+      end
+
       def inspect
         "#<#{self.class} changed?=#{changed?} @collection=#{@collection.inspect} >"
       end

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative '../pointer'
 require_relative 'collection_proxy'
 require_relative 'pointer_collection_proxy'
@@ -55,16 +58,75 @@ module Parse
         # By default, all associations are stored in 'through: :array' form. If you are working with a Parse Relation, you
         # should specify the 'through: :relation' property instead. This will switch the internal storage mechanisms
         # from using a PointerCollectionProxy to a RelationCollectionProxy.
+        def has_many_queried(key, scope = nil, **opts)
+          # key will be the name of the property
+          # the remote class is either key or as.
+          opts[:scope_only] ||= false
+          klassName = (opts[:as] || key).to_parse_class singularize: true
+          foreign_field = (opts[:field] || parse_class.columnize ).to_sym
+
+          define_method(key) do |*args, &block|
+            return [] if @id.nil?
+            query = Parse::Query.new(klassName, limit: :max)
+
+            query.where(foreign_field => self) unless opts[:scope_only] == true
+
+            if scope.is_a?(Proc)
+              # magic, override the singleton method_missing with accessing object level methods
+              # that don't collide with Parse::Query instance. Still accessible under :i
+              instance = self
+              query.define_singleton_method(:method_missing) { |m, *args, &block| instance.send(m, *args, &block) }
+              query.define_singleton_method(:i) { instance }
+              # if the scope takes no arguments, assume arguments are additional conditions
+              if scope.arity.zero?
+                query.instance_exec(&scope)
+                query.conditions(*args) if args.present?
+              else
+                query.instance_exec(*args,&scope)
+              end
+              instance = nil # help clean up ruby gc
+            elsif args.present?
+              query.conditions(*args)
+            end
+
+            query.define_singleton_method(:method_missing) do |m, *args, &block|
+              klass = Parse::Model.find_class klassName
+              if klass.present? && klass.respond_to?(m)
+                klass_scope = klass.send(m, *args, &block)
+                return klass_scope.is_a?(Parse::Query) ?
+                    self.add_constraints( klass_scope.constraints ) :
+                    klass_scope
+              end
+              self.results.send(m, *args, &block)
+            end
+
+            return query if block.nil?
+            query.results(&block)
+          end
 
-        def has_many(key, opts = {})
-          opts = {through: :array,
+        end
+
+        def has_many(key, scope = nil, **opts)
+          opts[:through] ||= :query
+
+          if opts[:through] == :query
+            return has_many_queried(key, scope, opts)
+          end
+
+          # below this is the same
+          opts.reverse_merge!({
                   field: key.to_s.camelize(:lower),
                   required: false,
-                  as: key}.merge(opts)
+                  as: key})
 
           klassName = opts[:as].to_parse_class singularize: true
-          parse_field = opts[:field].to_sym
+          parse_field = opts[:field].to_sym # name of the column (local or remote)
           access_type = opts[:through].to_sym
+
+          ivar = :"@#{key}"
+          will_change_method = :"#{key}_will_change!"
+          set_attribute_method = :"#{key}_set_attribute!"
+
           # 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}"
@@ -96,7 +158,6 @@ module Parse
 
           # The first method to be defined is a getter.
           define_method(key) do
-            ivar = :"@#{key}"
             val = instance_variable_get(ivar)
             # if the value for this is nil and we are a pointer, then autofetch
             if val.nil? && pointer?
@@ -116,11 +177,11 @@ module Parse
 
           # proxy setter that forwards with dirty tracking
           define_method("#{key}=") do |val|
-              send "#{key}_set_attribute!", val, true
+              send set_attribute_method, val, true
           end
 
           # This will set the content of the proxy.
-          define_method("#{key}_set_attribute!") do |val, track = true|
+          define_method(set_attribute_method) do |val, track = true|
             # If it is a hash, with a __type of Relation, createa a new RelationCollectionProxy, regardless
             # of what is defined because we must have gotten this from Parse.
 
@@ -132,14 +193,14 @@ module Parse
 
             if val.is_a?(Hash) && val["__type"] == "Relation"
               relation_objects = val["objects"] || []
-              val = Parse::RelationCollectionProxy.new relation_objects, delegate: self, key: key, parse_class: (val["className"] || klassName)
+              val = Parse::RelationCollectionProxy.new relation_objects, delegate: self, key: key, parse_class: (val[Parse::Model::KEY_CLASS_NAME] || klassName)
             elsif val.is_a?(Hash) && val["__op"] == "AddRelation" && val["objects"].present?
-              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: (val["className"] || klassName)
+              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: (val[Parse::Model::KEY_CLASS_NAME] || klassName)
               _collection.loaded = true
               _collection.add val["objects"].parse_objects
               val = _collection
             elsif val.is_a?(Hash) && val["__op"] == "RemoveRelation" && val["objects"].present?
-              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: (val["className"] || klassName)
+              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: (val[Parse::Model::KEY_CLASS_NAME] || klassName)
               _collection.loaded = true
               _collection.remove val["objects"].parse_objects
               val = _collection
@@ -150,11 +211,11 @@ module Parse
 
             # send dirty tracking if set
             if track == true
-              send :"#{key}_will_change!" unless val == instance_variable_get( :"@#{key}" )
+              send will_change_method unless val == instance_variable_get( ivar )
             end
             # TODO: Only allow empty proxy collection class as a value or nil.
             if val.is_a?(Parse::CollectionProxy)
-              instance_variable_set(:"@#{key}", val)
+              instance_variable_set(ivar, val)
             else
               warn "[#{self.class}] Invalid value #{val} for :has_many field #{key}. Should be an Array or a CollectionProxy"
             end
@@ -185,7 +246,7 @@ module Parse
           if self.method_defined?(parse_field) == false
             alias_method parse_field, key
             alias_method "#{parse_field}=", "#{key}="
-            alias_method "#{parse_field}_set_attribute!", "#{key}_set_attribute!"
+            alias_method "#{parse_field}_set_attribute!", set_attribute_method
           elsif parse_field.to_sym != :objectId
             warn "Alias has_many method #{self}##{parse_field} already defined."
           end
@@ -199,14 +260,14 @@ module Parse
         self.class.relations
       end
 
-      # returns a has of all the relation changes that have been performed on this
+      # returns a hash of all the relation changes that have been performed on this
       # instance.
       def relation_updates
         h = {}
         changed.each do |key|
           next unless relations[key.to_sym].present? && send(key).changed?
           remote_field = self.field_map[key.to_sym] || key
-          h[remote_field] = send key
+          h[remote_field] = send key # we still need to send a proxy collection
         end
         h
       end