parse-stack 1.8.0 → 1.8.1

data/lib/parse/model/acl.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-
 module Parse
 
   # This class allows you to define custom data types for your model fields. You
@@ -33,7 +32,6 @@ module Parse
     def as_json(*args)
       {}.as_json
     end
-
   end
 
   # An ACL represents the dirty-trackable Parse Permissions object used for
@@ -131,6 +129,7 @@ module Parse
     def permissions
       @permissions ||= {}
     end
+
     # The key field value for public permissions.
     PUBLIC = "*".freeze
 
@@ -162,7 +161,7 @@ module Parse
     # @return [ACL::Permission]
     # @see ACL::Permission
     def self.permission(read, write = nil)
-        ACL::Permission.new(read, write)
+      ACL::Permission.new(read, write)
     end
     # Determines whether two ACLs or a Parse-ACL hash is equivalent to this object.
     # @example
@@ -195,6 +194,7 @@ module Parse
       apply(PUBLIC, read, write)
       permissions[PUBLIC]
     end
+
     alias_method :world, :everyone
 
     # Calls `acl_will_change!` on the delegate when the permissions have changed.
@@ -236,7 +236,7 @@ module Parse
     # @return [Hash] the current set of permissions.
     # @see #apply_role
     def apply(id, read = nil, write = nil)
-      return apply_role(id,read,write) if id.is_a?(Parse::Role)
+      return apply_role(id, read, write) if id.is_a?(Parse::Role)
       id = id.id if id.is_a?(Parse::Pointer)
       unless id.present?
         raise ArgumentError, "Invalid argument applying ACLs: must be either objectId, role or :public"
@@ -254,7 +254,8 @@ module Parse
       end
 
       permissions
-    end; alias_method :add, :apply
+    end; 
+    alias_method :add, :apply
 
     # Apply a {Parse::Role} to this ACL.
     # @overload apply_role(role, read = nil, write = nil)
@@ -268,7 +269,8 @@ module Parse
     def apply_role(name, read = nil, write = nil)
       name = name.name if name.is_a?(Parse::Role)
       apply("role:#{name}", read, write)
-    end; alias_method :add_role, :apply_role
+    end; 
+    alias_method :add_role, :apply_role
 
     # Used for object conversion when formatting the input/output value in
     # Parse::Object properties
@@ -286,7 +288,7 @@ module Parse
     # all privileges
     # @return [Hash]
     def attributes
-      permissions.select {|k,v| v.present? }.as_json
+      permissions.select { |k, v| v.present? }.as_json
     end
 
     # @!visibility private
@@ -294,8 +296,8 @@ module Parse
       return unless h.is_a?(Hash)
       will_change!
       @permissions ||= {}
-      h.each do |k,v|
-        apply(k,v)
+      h.each do |k, v|
+        apply(k, v)
       end
     end
 
@@ -306,7 +308,7 @@ module Parse
 
     # @return [Hash]
     def as_json(*args)
-      permissions.select {|k,v| v.present? }.as_json
+      permissions.select { |k, v| v.present? }.as_json
     end
 
     # @return [Boolean] true if there are any permissions.
@@ -330,7 +332,8 @@ module Parse
     def master_key_only!
       will_change!
       @permissions = {}
-    end; alias_method :clear!, :master_key_only!
+    end; 
+    alias_method :clear!, :master_key_only!
 
     # Grants read permission on all existing users and roles attached to this object.
     # @example
@@ -530,7 +533,6 @@ module Parse
       def no_write!
         @write = false
       end
-
     end
   end
 end

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

@@ -1,11 +1,10 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative '../pointer'
-require_relative 'collection_proxy'
-require_relative 'pointer_collection_proxy'
-require_relative 'relation_collection_proxy'
-
+require_relative "../pointer"
+require_relative "collection_proxy"
+require_relative "pointer_collection_proxy"
+require_relative "relation_collection_proxy"
 
 module Parse
   # Defines all the types of Parse object associations.
@@ -120,7 +119,7 @@ module Parse
 
         # These items are added as attributes with the special data type of :pointer
         def belongs_to(key, opts = {})
-          opts = {as: key, field: key.to_s.camelize(:lower), required: false}.merge(opts)
+          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
 
@@ -138,13 +137,13 @@ module Parse
           end
           # store this attribute in the attributes hash with the proper remote column name.
           # we know the type is pointer.
-          self.attributes.merge!( parse_field => :pointer )
+          self.attributes.merge!(parse_field => :pointer)
           # Add them to our list of pointer references
-          self.references.merge!( parse_field => klassName )
+          self.references.merge!(parse_field => klassName)
           # Add them to the list of fields in our class model
-          self.fields.merge!( key => :pointer, parse_field => :pointer )
+          self.fields.merge!(key => :pointer, parse_field => :pointer)
           # Mapping between local attribute name and the remote column name
-          self.field_map.merge!( key => parse_field )
+          self.field_map.merge!(key => parse_field)
 
           # used for dirty tracking
           define_attribute_methods key
@@ -154,7 +153,6 @@ module Parse
 
           # We generate the getter method
           define_method(key) do
-
             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
@@ -166,8 +164,8 @@ 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"] == "Pointer" ||  val["__type"] == "Object" )
-              val = Parse::Object.build val, ( val[Parse::Model::KEY_CLASS_NAME] || 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
@@ -190,12 +188,12 @@ module Parse
           define_method(set_attribute_method) do |val, track = true|
             if val == Parse::Properties::DELETE_OP
               val = nil
-            elsif val.is_a?(Hash) && ( val["__type"] == "Pointer" ||  val["__type"] == "Object" )
-              val = Parse::Object.build val, ( val[Parse::Model::KEY_CLASS_NAME] || 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 will_change_method unless val == instance_variable_get( ivar )
+              send will_change_method unless val == instance_variable_get(ivar)
             end
 
             # Never set an object that is not a Parse::Pointer
@@ -204,7 +202,6 @@ module Parse
             else
               warn "[#{self.class}] Invalid value #{val} set for belongs_to field #{key}"
             end
-
           end
           # don't create method aliases if the fields are the same
           return if parse_field.to_sym == key.to_sym
@@ -216,12 +213,8 @@ module Parse
           elsif parse_field.to_sym != :objectId
             warn "Alias belongs_to method #{self}##{parse_field} already defined."
           end
-
         end
-
       end # ClassMethod
-
     end #BelongsTo
   end #Associations
-
 end

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

@@ -1,379 +1,378 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext/object'
-require_relative '../pointer'
-
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/object"
+require_relative "../pointer"
 
 module Parse
-    # We use a delegate pattern to send notifications to the parent whenever the content of the internal array changes.
-    # The main requirement to using the proxy is to provide the list of initial items if any,
-    # the owner to be notified and the name of the attribute 'key'. With that, anytime the array
-    # will change, we will notify the delegate by sending :'key'_will_change! . The proxy can also
-    # be lazy when fetching the contents of the collection. Whenever the collection is accessed and
-    # the list is in a "not loaded" state (empty and loaded == false), we will send :'key_fetch!' to the delegate in order to
-    # populate the collection.
-
-    # A CollectionProxy is a special type of array wrapper that notifies a delegate
-    # object about changes to the array in order to perform dirty tracking. This is
-    # used for all Array properties in Parse::Objects. Subclasses of {CollectionProxy} are
-    # also available for supporting different association types such as an array of Parse pointers
-    # and Parse relations.
+  # We use a delegate pattern to send notifications to the parent whenever the content of the internal array changes.
+  # The main requirement to using the proxy is to provide the list of initial items if any,
+  # the owner to be notified and the name of the attribute 'key'. With that, anytime the array
+  # will change, we will notify the delegate by sending :'key'_will_change! . The proxy can also
+  # be lazy when fetching the contents of the collection. Whenever the collection is accessed and
+  # the list is in a "not loaded" state (empty and loaded == false), we will send :'key_fetch!' to the delegate in order to
+  # populate the collection.
+
+  # A CollectionProxy is a special type of array wrapper that notifies a delegate
+  # object about changes to the array in order to perform dirty tracking. This is
+  # used for all Array properties in Parse::Objects. Subclasses of {CollectionProxy} are
+  # also available for supporting different association types such as an array of Parse pointers
+  # and Parse relations.
+  # @see PointerCollectionProxy
+  # @see RelationCollectionProxy
+  class CollectionProxy
+    include ::ActiveModel::Model
+    include ::ActiveModel::Dirty
+    include ::Enumerable
+
+    # @!attribute [r] delegate
+    #  The object to be notified of changes to the collection.
+    #  @return [Object]
+
+    # @!attribute [rw] loaded
+    #  @return [Boolean] true/false whether the collection has been loaded.
+
+    # @!attribute [r] parse_class
+    #  For some subclasses, this helps typecast the items in the collection.
+    #  @return [String]
+
+    # @!attribute [r] key
+    #  the name of the property key to use when sending notifications for _will_change! and _fetch!
+    #  @return [String]
+
+    attr_accessor :collection, :delegate, :loaded, :parse_class
+    attr_reader :delegate, :key
+
+    # This is to use dirty tracking within the proxy
+    define_attribute_methods :collection
+
+    # Create a new CollectionProxy instance.
+    # @param collection [Array] the initial items to add to the collection.
+    # @param delegate [Object] the owner of the object that will receive the notifications.
+    # @param key [Symbol] the name of the key to use when sending notifications for _will_change! and _fetch!
+    # @param parse_class [String] (Optional) the Parse class type are the items of the collection.
+    #   This is used to typecast the objects in the array to a particular Parse Object type.
     # @see PointerCollectionProxy
     # @see RelationCollectionProxy
-    class CollectionProxy
-      include ::ActiveModel::Model
-      include ::ActiveModel::Dirty
-      include ::Enumerable
-
-      # @!attribute [r] delegate
-      #  The object to be notified of changes to the collection.
-      #  @return [Object]
-
-      # @!attribute [rw] loaded
-      #  @return [Boolean] true/false whether the collection has been loaded.
-
-      # @!attribute [r] parse_class
-      #  For some subclasses, this helps typecast the items in the collection.
-      #  @return [String]
-
-      # @!attribute [r] key
-      #  the name of the property key to use when sending notifications for _will_change! and _fetch!
-      #  @return [String]
-
-      attr_accessor :collection, :delegate, :loaded, :parse_class
-      attr_reader :delegate, :key
-
-      # This is to use dirty tracking within the proxy
-      define_attribute_methods :collection
-
-      # Create a new CollectionProxy instance.
-      # @param collection [Array] the initial items to add to the collection.
-      # @param delegate [Object] the owner of the object that will receive the notifications.
-      # @param key [Symbol] the name of the key to use when sending notifications for _will_change! and _fetch!
-      # @param parse_class [String] (Optional) the Parse class type are the items of the collection.
-      #   This is used to typecast the objects in the array to a particular Parse Object type.
-      # @see PointerCollectionProxy
-      # @see RelationCollectionProxy
-      def initialize(collection = nil, delegate: nil, key: nil, parse_class: nil)
-        @delegate = delegate
-        @key = key.to_sym if key.present?
-        @collection = collection.is_a?(Array) ? collection : []
-        @loaded = @collection.count > 0
-        @parse_class = parse_class
-      end
-
-      # true if the collection has been loaded
-      def loaded?
-        @loaded
-      end
-
-      # Forward a method call to the delegate.
-      # @param method [Symbol] the name of the method to forward
-      # @param params [Object] method parameters
-      # @return [Object] the return value from the forwarded method.
-      def forward(method, params = nil)
-        return unless @delegate && @delegate.respond_to?(method)
-        params.nil? ? @delegate.send(method) : @delegate.send(method, params)
-      end
-
-      # Reset the state of the collection.
-      def reset!
-        @loaded = false
-        clear
-      end
-
-      # @return [Boolean] true if two collection proxies have similar items.
-      def ==(other_list)
-        if other_list.is_a?(Array)
-          return @collection == other_list
-        elsif other_list.is_a?(Parse::CollectionProxy)
-          return @collection == other_list.instance_variable_get(:@collection)
-        end
-      end
+    def initialize(collection = nil, delegate: nil, key: nil, parse_class: nil)
+      @delegate = delegate
+      @key = key.to_sym if key.present?
+      @collection = collection.is_a?(Array) ? collection : []
+      @loaded = @collection.count > 0
+      @parse_class = parse_class
+    end
 
-      # Reload and restore the collection to its original set of items.
-      def reload!
-        reset!
-        collection #force reload
-      end
+    # true if the collection has been loaded
+    def loaded?
+      @loaded
+    end
 
-      # clear all items in the collection
-      def clear
-        @collection.clear
-      end
+    # Forward a method call to the delegate.
+    # @param method [Symbol] the name of the method to forward
+    # @param params [Object] method parameters
+    # @return [Object] the return value from the forwarded method.
+    def forward(method, params = nil)
+      return unless @delegate && @delegate.respond_to?(method)
+      params.nil? ? @delegate.send(method) : @delegate.send(method, params)
+    end
 
-      # @return [Array]
-      def to_a
-        collection.to_a
-      end; alias_method :to_ary, :to_a
+    # Reset the state of the collection.
+    def reset!
+      @loaded = false
+      clear
+    end
 
-      # Set the internal collection of items *without* dirty tracking or
-      # change notifications.
-      # @return [Array] the collection
-      def set_collection!(list)
-        @collection = list
+    # @return [Boolean] true if two collection proxies have similar items.
+    def ==(other_list)
+      if other_list.is_a?(Array)
+        return @collection == other_list
+      elsif other_list.is_a?(Parse::CollectionProxy)
+        return @collection == other_list.instance_variable_get(:@collection)
       end
+    end
 
-      # @!attribute [rw] collection
-      #  The internal backing store of the collection containing the content. This value is lazily
-      #  loaded for some subclasses.
-      # @note If you modify this directly, it is highly recommended that you
-      #  call {CollectionProxy#notify_will_change!} to notify the dirty tracking system.
-      # @return [Array] contents of the collection.
-      def collection
-        if @collection.empty? && @loaded == false
-          @collection = forward( :"#{@key}_fetch!" ) || @collection || []
-          @loaded = true
-        end
-
-        @collection
-      end
+    # Reload and restore the collection to its original set of items.
+    def reload!
+      reset!
+      collection #force reload
+    end
 
-      def collection=(c)
-        notify_will_change!
-        @collection = c
-      end
+    # clear all items in the collection
+    def clear
+      @collection.clear
+    end
 
-      # Add items to the collection
-      # @param items [Array] items to add
-      def add(*items)
-        notify_will_change! if items.count > 0
-        items.each do |item|
-          collection.push item
-        end
-        @collection
-      end; alias_method :push, :add
-
-      # Add items to the collection if they don't already exist
-      # @param items [Array] items to uniquely add
-      # @return [Array] the collection.
-      def add_unique(*items)
-        return unless items.count > 0
-        notify_will_change!
-        @collection = collection | items.flatten
-        @collection
-      end; alias_method :push_unique, :add_unique
-
-      # Set Union - Returns a new array by joining two arrays, excluding
-      # any duplicates and preserving the order from the original array.
-      # It compares elements using their hash and eql? methods for efficiency.
-      # See {https://docs.ruby-lang.org/en/2.0.0/Array.html#method-i-hash Array#|}
-      # @example
-      #    [ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ]
-      # @param items [Array] items to uniquely add
-      # @see #add_unique
-      # @return [Array] array with unique items
-      def |(items)
-        collection | [items].flatten
-      end
+    # @return [Array]
+    def to_a
+      collection.to_a
+    end; 
+    alias_method :to_ary, :to_a
+
+    # Set the internal collection of items *without* dirty tracking or
+    # change notifications.
+    # @return [Array] the collection
+    def set_collection!(list)
+      @collection = list
+    end
 
-      # Set Intersection - Returns a new array containing unique elements common
-      # to the two arrays. The order is preserved from the original array.
-      #
-      # It compares elements using their hash and eql? methods for efficiency.
-      # See {https://ruby-doc.org/core-2.4.1/Array.html#method-i-26 Array#&}
-      # @example
-      #   [ 1, 1, 3, 5 ] & [ 3, 2, 1 ]                 #=> [ 1, 3 ]
-      #   [ 'a', 'b', 'b', 'z' ] & [ 'a', 'b', 'c' ]   #=> [ 'a', 'b' ]
-      # @param other_ary [Array]
-      # @return [Array] intersection array
-      def &(other_ary)
-        collection & [other_ary].flatten
+    # @!attribute [rw] collection
+    #  The internal backing store of the collection containing the content. This value is lazily
+    #  loaded for some subclasses.
+    # @note If you modify this directly, it is highly recommended that you
+    #  call {CollectionProxy#notify_will_change!} to notify the dirty tracking system.
+    # @return [Array] contents of the collection.
+    def collection
+      if @collection.empty? && @loaded == false
+        @collection = forward(:"#{@key}_fetch!") || @collection || []
+        @loaded = true
       end
 
-      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2D Array Difference}.
-      # Returns a new array that is a copy of the original array, removing any
-      # items that also appear in other_ary. The order is preserved from the
-      # original array.
-      # @example
-      #   [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]
-      # @param other_ary [Array]
-      # @return [Array] delta array
-      def -(other_ary)
-        collection - [other_ary].flatten
-      end
+      @collection
+    end
 
-      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2B Array Concatenation}.
-      # Returns a new array built by concatenating the two arrays together to
-      # produce a third array.
-      # @example
-      #   [ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]
-      # @param other_ary [Array]
-      # @return [Array] concatenated array
-      def +(other_ary)
-        collection + [other_ary].flatten.to_a
-      end
+    def collection=(c)
+      notify_will_change!
+      @collection = c
+    end
 
-      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-flatten Array flattening}.
-      # @return [Array] a flattened one-dimensional array
-      def flatten
-        collection.flatten
-      end
+    # Add items to the collection
+    # @param items [Array] items to add
+    def add(*items)
+      notify_will_change! if items.count > 0
+      items.each do |item|
+        collection.push item
+      end
+      @collection
+    end; 
+    alias_method :push, :add
+
+    # Add items to the collection if they don't already exist
+    # @param items [Array] items to uniquely add
+    # @return [Array] the collection.
+    def add_unique(*items)
+      return unless items.count > 0
+      notify_will_change!
+      @collection = collection | items.flatten
+      @collection
+    end; 
+    alias_method :push_unique, :add_unique
+
+    # Set Union - Returns a new array by joining two arrays, excluding
+    # any duplicates and preserving the order from the original array.
+    # It compares elements using their hash and eql? methods for efficiency.
+    # See {https://docs.ruby-lang.org/en/2.0.0/Array.html#method-i-hash Array#|}
+    # @example
+    #    [ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ]
+    # @param items [Array] items to uniquely add
+    # @see #add_unique
+    # @return [Array] array with unique items
+    def |(items)
+      collection | [items].flatten
+    end
 
-      # Remove items from the collection
-      # @param items [Array] items to remove
-      def remove(*items)
-        notify_will_change! if items.count > 0
-        items.each do |item|
-          collection.delete item
-        end
-        @collection
-      end; alias_method :delete, :remove
-
-      # Atomically adds all items from the array.
-      # This request is sent directly to the Parse backend.
-      # @param items [Array] items to uniquely add
-      # @see #add_unique!
-      def add!(*items)
-        return false unless @delegate.respond_to?(:op_add!)
-        @delegate.send :op_add!, @key, items.flatten
-        reset!
-      end
+    # Set Intersection - Returns a new array containing unique elements common
+    # to the two arrays. The order is preserved from the original array.
+    #
+    # It compares elements using their hash and eql? methods for efficiency.
+    # See {https://ruby-doc.org/core-2.4.1/Array.html#method-i-26 Array#&}
+    # @example
+    #   [ 1, 1, 3, 5 ] & [ 3, 2, 1 ]                 #=> [ 1, 3 ]
+    #   [ 'a', 'b', 'b', 'z' ] & [ 'a', 'b', 'c' ]   #=> [ 'a', 'b' ]
+    # @param other_ary [Array]
+    # @return [Array] intersection array
+    def &(other_ary)
+      collection & [other_ary].flatten
+    end
 
-      # Atomically adds all items from the array that are not already part of the collection.
-      # This request is sent directly to the Parse backend.
-      # @param items [Array] items to uniquely add
-      # @see #add!
-      def add_unique!(*items)
-        return false unless @delegate.respond_to?(:op_add_unique!)
-        @delegate.send :op_add_unique!, @key, items.flatten
-        reset!
-      end
+    # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2D Array Difference}.
+    # Returns a new array that is a copy of the original array, removing any
+    # items that also appear in other_ary. The order is preserved from the
+    # original array.
+    # @example
+    #   [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]
+    # @param other_ary [Array]
+    # @return [Array] delta array
+    def -(other_ary)
+      collection - [other_ary].flatten
+    end
 
-      # Atomically deletes all items from the array. This request is sent
-      # directly to the Parse backend.
-      # @param items [Array] items to remove
-      def remove!(*items)
-        return false unless @delegate.respond_to?(:op_remove!)
-        @delegate.send :op_remove!, @key, items.flatten
-        reset!
-      end
+    # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2B Array Concatenation}.
+    # Returns a new array built by concatenating the two arrays together to
+    # produce a third array.
+    # @example
+    #   [ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]
+    # @param other_ary [Array]
+    # @return [Array] concatenated array
+    def +(other_ary)
+      collection + [other_ary].flatten.to_a
+    end
 
-      # Atomically deletes all items in the array, and marks the field as `undefined` directly
-      # with the Parse server. This request is sent directly to the Parse backend.
-      def destroy!
-        return false unless @delegate.respond_to?(:op_destroy!)
-        @delegate.send :op_destroy!, @key
-        collection_will_change!
-        @collection.clear
-        reset!
-      end
+    # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-flatten Array flattening}.
+    # @return [Array] a flattened one-dimensional array
+    def flatten
+      collection.flatten
+    end
 
-      # Locally restores previous attributes (not from the persistent store)
-      def rollback!
-        restore_attributes
-      end
+    # Remove items from the collection
+    # @param items [Array] items to remove
+    def remove(*items)
+      notify_will_change! if items.count > 0
+      items.each do |item|
+        collection.delete item
+      end
+      @collection
+    end; 
+    alias_method :delete, :remove
+
+    # Atomically adds all items from the array.
+    # This request is sent directly to the Parse backend.
+    # @param items [Array] items to uniquely add
+    # @see #add_unique!
+    def add!(*items)
+      return false unless @delegate.respond_to?(:op_add!)
+      @delegate.send :op_add!, @key, items.flatten
+      reset!
+    end
 
-      # clears all dirty tracked information.
-      def clear_changes!
-        clear_changes_information
-      end
+    # Atomically adds all items from the array that are not already part of the collection.
+    # This request is sent directly to the Parse backend.
+    # @param items [Array] items to uniquely add
+    # @see #add!
+    def add_unique!(*items)
+      return false unless @delegate.respond_to?(:op_add_unique!)
+      @delegate.send :op_add_unique!, @key, items.flatten
+      reset!
+    end
 
-      # mark that collection changes where applied, which clears dirty tracking.
-      def changes_applied!
-        changes_applied
-      end
+    # Atomically deletes all items from the array. This request is sent
+    # directly to the Parse backend.
+    # @param items [Array] items to remove
+    def remove!(*items)
+      return false unless @delegate.respond_to?(:op_remove!)
+      @delegate.send :op_remove!, @key, items.flatten
+      reset!
+    end
 
-      # @param args [Hash] arguments to pass to Array#first.
-      # @return [Object] the first item in the collection
-      def first(*args)
-        collection.first(*args)
-      end
+    # Atomically deletes all items in the array, and marks the field as `undefined` directly
+    # with the Parse server. This request is sent directly to the Parse backend.
+    def destroy!
+      return false unless @delegate.respond_to?(:op_destroy!)
+      @delegate.send :op_destroy!, @key
+      collection_will_change!
+      @collection.clear
+      reset!
+    end
 
-      # @return [Object] the second item in the collection
-      def second
-        collection.second
-      end
+    # Locally restores previous attributes (not from the persistent store)
+    def rollback!
+      restore_attributes
+    end
 
-      # @param args [Hash] arguments to pass to Array#last.
-      # @return [Object] the last item in the collection
-      def last(*args)
-        collection.last(*args)
-      end
+    # clears all dirty tracked information.
+    def clear_changes!
+      clear_changes_information
+    end
 
-      # @return [Integer] number of items in the collection.
-      def count
-        collection.count
-      end
+    # mark that collection changes where applied, which clears dirty tracking.
+    def changes_applied!
+      changes_applied
+    end
 
-      # @return [Hash] a JSON representation
-      def as_json(opts = nil)
-        collection.as_json(opts)
-      end
+    # @param args [Hash] arguments to pass to Array#first.
+    # @return [Object] the first item in the collection
+    def first(*args)
+      collection.first(*args)
+    end
 
-      # true if the collection is empty.
-      def empty?
-        collection.empty?
-      end
+    # @return [Object] the second item in the collection
+    def second
+      collection.second
+    end
 
-      # Append items to the collection
-      def <<(*list)
-        if list.count > 0
-          notify_will_change!
-          list.flatten.each { |e| collection.push(e) }
-        end
-      end
+    # @param args [Hash] arguments to pass to Array#last.
+    # @return [Object] the last item in the collection
+    def last(*args)
+      collection.last(*args)
+    end
 
-      # Notifies the delegate that the collection changed.
-      def notify_will_change!
-        collection_will_change!
-        forward "#{@key}_will_change!"
-      end
+    # @return [Integer] number of items in the collection.
+    def count
+      collection.count
+    end
 
-      # Alias for Array#each
-      def each
-        return collection.enum_for(:each) unless block_given?
-        collection.each &Proc.new
-      end
+    # @return [Hash] a JSON representation
+    def as_json(opts = nil)
+      collection.as_json(opts)
+    end
 
-      # Alias for Array#map
-      def map
-        return collection.enum_for(:map) unless block_given?
-        collection.map &Proc.new
-      end
+    # true if the collection is empty.
+    def empty?
+      collection.empty?
+    end
 
-      # Alias for Array#select
-      def select
-        return collection.enum_for(:select) unless block_given?
-        collection.select &Proc.new
+    # Append items to the collection
+    def <<(*list)
+      if list.count > 0
+        notify_will_change!
+        list.flatten.each { |e| collection.push(e) }
       end
+    end
 
-      # Alias for Array#uniq
-      def uniq
-        return collection.uniq(&Proc.new) if block_given?
-        return collection.uniq
-      end
+    # Notifies the delegate that the collection changed.
+    def notify_will_change!
+      collection_will_change!
+      forward "#{@key}_will_change!"
+    end
 
-      # Alias for Array#uniq!
-      def uniq!
-        notify_will_change!
-        return collection.uniq!(&Proc.new) if block_given?
-        return collection.uniq!
-      end
+    # Alias for Array#each
+    def each
+      return collection.enum_for(:each) unless block_given?
+      collection.each &Proc.new
+    end
 
-      # @!visibility private
-      def inspect
-        "#<#{self.class} changed?=#{changed?} @collection=#{@collection.inspect} >"
-      end
+    # Alias for Array#map
+    def map
+      return collection.enum_for(:map) unless block_given?
+      collection.map &Proc.new
+    end
 
-      # Alias to `to_a.parse_objects` from Array#parse_objects
-      # @return [Array<Parse::Object>] an array of Parse Object subclasses representing this collection.
-      def parse_objects
-        collection.to_a.parse_objects
-      end
+    # Alias for Array#select
+    def select
+      return collection.enum_for(:select) unless block_given?
+      collection.select &Proc.new
+    end
 
-      # Alias to `to_a.parse_pointers` from Array#parse_pointers
-      # @return [Array<Parse::Pointer>] an array of pointers representing this collection.
-      def parse_pointers
-        collection.to_a.parse_pointers
-      end
+    # Alias for Array#uniq
+    def uniq
+      return collection.uniq(&Proc.new) if block_given?
+      return collection.uniq
+    end
 
+    # Alias for Array#uniq!
+    def uniq!
+      notify_will_change!
+      return collection.uniq!(&Proc.new) if block_given?
+      return collection.uniq!
     end
 
+    # @!visibility private
+    def inspect
+      "#<#{self.class} changed?=#{changed?} @collection=#{@collection.inspect} >"
+    end
 
+    # Alias to `to_a.parse_objects` from Array#parse_objects
+    # @return [Array<Parse::Object>] an array of Parse Object subclasses representing this collection.
+    def parse_objects
+      collection.to_a.parse_objects
+    end
 
+    # Alias to `to_a.parse_pointers` from Array#parse_pointers
+    # @return [Array<Parse::Pointer>] an array of pointers representing this collection.
+    def parse_pointers
+      collection.to_a.parse_pointers
+    end
   end
+end