parse-stack-next 5.7.5 → 5.8.0

data/lib/parse/model/acl.rb

@@ -147,6 +147,25 @@ module Parse
       @delegate = owner
     end
 
+    # Deep-copies the permissions table so a `dup`/`clone` of an ACL never
+    # shares mutable state with the original. ActiveModel dirty tracking
+    # stores a clone of the ACL as the "before" value on the first change;
+    # with a shallow copy, later in-place edits (`apply`, `delete`,
+    # `Permission#no_read!`) also rewrote that saved value. `rollback!`
+    # then restored the edited ACL and the change history reported the old
+    # and new values as identical.
+    # @!visibility private
+    def initialize_copy(other)
+      super
+      src = other.instance_variable_get(:@permissions)
+      @permissions = nil
+      return if src.nil?
+      @permissions = {}
+      src.each do |key, perm|
+        @permissions[key] = perm.is_a?(Permission) ? adopt_permission(perm.dup) : perm
+      end
+    end
+
     # Create a new ACL with default Public read/write permissions and any
     # overrides from the input hash format.
     # @param read [Boolean] the read permissions for PUBLIC (default: true)
@@ -268,6 +287,21 @@ module Parse
       as_json == other_acl.as_json
     end
 
+    # Strict equality used by Hash keys and `Array#uniq`. Unlike {#==}, a
+    # plain Hash is never `eql?` to an ACL, since the two cannot share a
+    # {#hash} value. Two ACLs granting the same privileges are `eql?` and
+    # hash alike. The hash follows the current permissions, so an ACL
+    # mutated after use as a Hash key must be rehashed like any Hash key.
+    # @return [Boolean]
+    def eql?(other_acl)
+      other_acl.is_a?(Parse::ACL) && as_json == other_acl.as_json
+    end
+
+    # @return [Integer] a hash value consistent with {#eql?}.
+    def hash
+      [Parse::ACL, as_json].hash
+    end
+
     # Set the public read and write permissions.
     # @param read [Boolean] the read permission state.
     # @param write [Boolean] the write permission state.
@@ -285,17 +319,23 @@ module Parse
       @delegate.acl_will_change! if @delegate.respond_to?(:acl_will_change!)
     end
 
-    # Removes a permission for an objectId or user.
+    # Removes every permission for a user, role or the public entry.
     # @overload delete(object)
-    #  @param object [Parse::User] the user to revoke permissions.
+    #  @param object [Parse::User, Parse::Pointer] the user to revoke permissions.
+    # @overload delete(role)
+    #  @param role [Parse::Role] the role to revoke permissions.
     # @overload delete(id)
-    #  @param id [String] the objectId to revoke permissions.
+    #  @param id [String, Symbol] a user objectId, a role key (`"role:Admin"`),
+    #   a role name whose `role:` entry exists, or `:public` / `"*"`.
+    # @return [Parse::ACL::Permission, nil] the removed permission, or nil
+    #  when there was no matching entry.
     def delete(id)
-      id = id.id if id.is_a?(Parse::Pointer)
-      if id.present? && permissions.has_key?(id)
-        will_change!
-        permissions.delete(id)
-      end
+      key = normalize_permission_key(id)
+      return nil unless key.present? && permissions.has_key?(key)
+      will_change!
+      perm = permissions.delete(key)
+      perm.acl = nil if perm.is_a?(Permission) && perm.acl.equal?(self)
+      perm
     end
 
     # Apply a new permission with a given objectId, tag or :public.
@@ -331,7 +371,7 @@ module Parse
       if permission.is_a?(ACL::Permission)
         if permissions[id.to_s] != permission
           will_change! # dirty track
-          permissions[id.to_s] = permission
+          permissions[id.to_s] = adopt_permission(permission)
         end
       end
 
@@ -351,6 +391,10 @@ module Parse
     #  @param write [Boolean] the write permission.
     def apply_role(name, read = nil, write = nil)
       name = name.name if name.is_a?(Parse::Role)
+      name = name.to_s
+      # Accept an already-prefixed key so "role:Admin" does not become
+      # "role:role:Admin".
+      name = name.delete_prefix("role:") if name.start_with?("role:")
       apply("role:#{name}", read, write)
     end
 
@@ -822,6 +866,17 @@ module Parse
 
     private
 
+    # Points a Permission at this ACL so its own mutators can mark the ACL
+    # (and the owning object) dirty. A Permission already owned by a
+    # different ACL is copied first, so one ACL's edit never reaches another.
+    # @return [Permission]
+    def adopt_permission(perm)
+      owner = perm.acl
+      perm = perm.dup if owner && !owner.equal?(self)
+      perm.acl = self
+      perm
+    end
+
     # Normalizes a user or role input to the appropriate permission key format.
     # @param user_or_role [String, Parse::User, Parse::Role] the input to normalize
     # @return [String, nil] the normalized key or nil if invalid
@@ -885,6 +940,27 @@ module Parse
       # @return [Boolean] whether this permission is allowed.
       attr_reader :write
 
+      # @!visibility private
+      # The ACL this permission belongs to. Its mutators notify this ACL so
+      # the change is dirty tracked on the owning object.
+      attr_accessor :acl
+
+      # Converts a permission flag to a strict boolean. Only `true`, the
+      # strings "true" and "1" (any case, surrounding whitespace ignored) and
+      # non-zero numbers grant. Everything else, including the string
+      # "false", denies.
+      # @!visibility private
+      # @return [Boolean]
+      def self.grant?(value)
+        case value
+        when true then true
+        when false, nil then false
+        when String then %w[true 1].include?(value.strip.downcase)
+        when Numeric then !value.zero?
+        else value.present?
+        end
+      end
+
       # Create a new permission with the given read and write privileges.
       # @overload new(read = nil, write = nil)
       #  @param read [Boolean] whether reading is allowed.
@@ -899,20 +975,34 @@ module Parse
       def initialize(r_perm = nil, w_perm = nil)
         if r_perm.is_a?(Hash)
           r_perm = r_perm.symbolize_keys
-          @read = r_perm[:read].present?
-          @write = r_perm[:write].present?
+          @read = self.class.grant?(r_perm[:read])
+          @write = self.class.grant?(r_perm[:write])
         else
-          @read = r_perm.present?
-          @write = w_perm.present?
+          @read = self.class.grant?(r_perm)
+          @write = self.class.grant?(w_perm)
         end
       end
 
+      # A copy is detached from the original's ACL; the copying ACL adopts it.
+      # @!visibility private
+      def initialize_copy(other)
+        super
+        @acl = nil
+      end
+
       # @return [Boolean] whether two permission instances have the same permissions.
       def ==(per)
         return false unless per.is_a?(self.class)
         @read == per.read && @write == per.write
       end
 
+      alias_method :eql?, :==
+
+      # @return [Integer] a hash value consistent with {#eql?}.
+      def hash
+        [self.class, @read, @write].hash
+      end
+
       # @return [Hash] A Parse-compatible ACL-hash. Omission or false on a
       #  priviledge means don't include it
       def as_json(*args)
@@ -940,19 +1030,27 @@ module Parse
         @read.present? || @write.present?
       end
 
-      # Sets the *read* value of the permission. Defaults to true.
-      # @note Setting the value in this manner is not dirty tracked.
+      # Sets the *read* value of the permission. Defaults to true. When the
+      # permission belongs to an ACL, a real change marks that ACL (and its
+      # owning object) dirty so the change is sent on the next save.
       # @version 1.7.2
-      # @return [void]
+      # @return [Boolean] the new read value.
       def read!(value = true)
+        value = self.class.grant?(value)
+        return value if value == @read
+        @acl&.will_change!
         @read = value
       end
 
-      # Sets the *write* value of the permission. Defaults to true.
-      # @note Setting the value in this manner is not dirty tracked.
+      # Sets the *write* value of the permission. Defaults to true. When the
+      # permission belongs to an ACL, a real change marks that ACL (and its
+      # owning object) dirty so the change is sent on the next save.
       # @version 1.7.2
-      # @return [void]
+      # @return [Boolean] the new write value.
       def write!(value = true)
+        value = self.class.grant?(value)
+        return value if value == @write
+        @acl&.will_change!
         @write = value
       end
 
@@ -960,14 +1058,14 @@ module Parse
       # @version 1.7.2
       # @return [void]
       def no_read!
-        @read = false
+        read!(false)
       end
 
       # Sets the *write* value of the permission to false.
       # @version 1.7.2
       # @return [void]
       def no_write!
-        @write = false
+        write!(false)
       end
     end
   end

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

@@ -183,6 +183,7 @@ module Parse
           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)
+          Parse::Model.model_registry_changed!
 
           # Agent metadata: a belongs_to pointer can carry a semantic description
           # (and per-value enum descriptions) just like a `property` can. This
@@ -229,8 +230,10 @@ module Parse
             # hash, lets try to build a Pointer of that type.
 
             if val.is_a?(Hash) && (val["__type"] == "Pointer" || val["__type"] == "Object")
-              # Get nested fetched keys for this field if available
-              nested_keys = nested_keys_for(association_key)
+              # Get nested fetched keys for this field if available. Query
+              # keys are recorded under the remote column name, which differs
+              # from the local name for multi-word fields.
+              nested_keys = nested_keys_for(association_key) || nested_keys_for(parse_field)
               # Always trust the declared klassName — never the className the
               # server (or attacker-controlled mass assignment) supplied. This
               # prevents type confusion where a pointer to a different class
@@ -272,21 +275,40 @@ module Parse
           end
 
           # We only support pointers, either by object or by transforming a hash.
+          # Assignment from application code (track == true) also accepts an
+          # objectId String, which becomes a pointer of the declared class,
+          # and refuses an object or pointer of another class. A pointer
+          # hash is wire data: its className is ignored in favor of the
+          # declared class, as before.
           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")
               # Get nested fetched keys for this field if available
-              nested_keys = nested_keys_for(key)
+              nested_keys = nested_keys_for(key) || nested_keys_for(parse_field)
               # Always trust declared klassName over incoming hash className.
               incoming_class = val[Parse::Model::KEY_CLASS_NAME]
               if incoming_class && !Parse::Model.same_parse_class?(incoming_class, klassName)
                 warn "[#{self.class}] belongs_to :#{key} expected className=#{klassName.inspect}, ignoring incoming className=#{incoming_class.inspect}"
               end
               val = Parse::Object.build val, klassName, fetched_keys: nested_keys
+            elsif track == true && val.is_a?(String)
+              # A blank String (an empty form select) clears the pointer.
+              val = val.blank? ? nil : Parse::Object.build({ Parse::Model::TYPE_FIELD => Parse::Model::TYPE_POINTER,
+                                                             Parse::Model::KEY_CLASS_NAME => klassName,
+                                                             Parse::Model::OBJECT_ID => val }, klassName)
             end
 
             if track == true
+              unless val.nil? || val.is_a?(Parse::Pointer)
+                raise ArgumentError, "#{self.class}##{key} expects a #{klassName} object, pointer or objectId, got #{val.class}."
+              end
+              # The class is checked when the declared class is a registered
+              # model, matching has_many arrays.
+              if val.is_a?(Parse::Pointer) && Parse::Model.find_class(klassName) &&
+                 !Parse::Model.same_parse_class?(val.parse_class, klassName)
+                raise ArgumentError, "#{self.class}##{key} expects a #{klassName} object, got #{val.parse_class}."
+              end
               prepare_for_dirty_tracking!(key)
               send will_change_method unless val == instance_variable_get(ivar)
             else

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

@@ -67,6 +67,25 @@ module Parse
       @parse_class = parse_class
     end
 
+    # Copies (`dup` and `clone`) get their own backing array and their own
+    # dirty-tracking state. ActiveModel records a property's previous value
+    # by cloning it; with a shared array the "previous" proxy changed along
+    # with the live one, so change history showed the new value twice and
+    # `rollback!` restored nothing.
+    # @!visibility private
+    def initialize_copy(other)
+      super
+      @collection = other.instance_variable_get(:@collection).dup
+      # Pending relation operations (RelationCollectionProxy) are copied too.
+      %i[@additions @removals].each do |ivar|
+        next unless instance_variable_defined?(ivar)
+        value = instance_variable_get(ivar)
+        instance_variable_set(ivar, value.dup) if value.is_a?(Array)
+      end
+      @mutations_from_database = nil
+      @mutations_before_last_save = nil
+    end
+
     # true if the collection has been loaded
     def loaded?
       @loaded
@@ -81,10 +100,12 @@ module Parse
       params.nil? ? @delegate.send(method) : @delegate.send(method, params)
     end
 
-    # Reset the state of the collection.
+    # Reset the state of the collection. The items are dropped and the
+    # collection is marked as not loaded. This is not a change to the
+    # field, so it is not dirty tracked; use {#clear} to empty the field.
     def reset!
       @loaded = false
-      clear
+      @collection.clear
     end
 
     # @return [Boolean] true if two collection proxies have similar items.
@@ -102,9 +123,25 @@ module Parse
       collection #force reload
     end
 
-    # clear all items in the collection
+    # Remove all items from the collection. The field is marked as changed,
+    # so the next save stores the empty array.
+    # @return [Array] the (now empty) collection.
     def clear
+      notify_will_change!
       @collection.clear
+      @loaded = true
+      @collection
+    end
+
+    # Replace the contents of the collection with a new set of items, as
+    # Array#replace does. The field is marked as changed.
+    # @param items [Array] the new contents.
+    # @return [self]
+    def replace(items)
+      notify_will_change!
+      @collection = Array(items.is_a?(Parse::CollectionProxy) ? items.to_a : items).dup
+      @loaded = true
+      self
     end
 
     # @return [Array]
@@ -233,36 +270,59 @@ module Parse
 
     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
+    # Atomically adds all items to the array field. The request is sent
+    # directly to the Parse backend. On success the local collection is
+    # updated to match (the items are appended) without marking the field
+    # as changed, so a later save does not overwrite the server array. On
+    # an owner that has not been saved yet there is nothing to update on
+    # the server, so the items are added locally as a normal change and
+    # sent with the next save.
+    # @param items [Array] items to add
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     # @see #add_unique!
     def add!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_add!)
-      @delegate.send :op_add!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return add(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_add!, items) do |list, objs|
+        list + objs
+      end
     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.
+    # Atomically adds the items that are not already part of the array
+    # field. The request is sent directly to the Parse backend. The local
+    # collection is updated as in {#add!}.
     # @param items [Array] items to uniquely add
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     # @see #add!
     def add_unique!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_add_unique!)
-      @delegate.send :op_add_unique!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return add_unique(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_add_unique!, items) do |list, objs|
+        objs.each { |o| list << o unless list.include?(o) }
+        list
+      end
     end
 
-    # Atomically deletes all items from the array. This request is sent
-    # directly to the Parse backend.
+    # Atomically removes the items from the array field. The request is
+    # sent directly to the Parse backend. The local collection is updated
+    # as in {#add!}.
     # @param items [Array] items to remove
     # @note Parse objects are automatically converted to pointer format
+    # @return [Boolean] whether the operation succeeded.
     def remove!(*items)
+      items = items.flatten
       return false unless @delegate.respond_to?(:op_remove!)
-      @delegate.send :op_remove!, @key, items_to_pointers(items.flatten)
-      reset!
+      return true if items.empty?
+      return remove(*items) && true if unsaved_delegate?
+      apply_atomic_op(:op_remove!, items) do |list, objs|
+        list.reject { |x| objs.include?(x) }
+      end
     end
 
     # Atomically deletes all items in the array, and marks the field as `undefined` directly
@@ -276,8 +336,15 @@ module Parse
     end
 
     # Locally restores previous attributes (not from the persistent store)
+    # and clears the dirty tracking of the collection. The values are
+    # restored directly: going through the public writers would report a
+    # new change to the owner while undoing one.
     def rollback!
-      restore_attributes
+      changed.each do |attr|
+        instance_variable_set(:"@#{attr}", attribute_was(attr))
+      end
+      clear_changes_information
+      @collection
     end
 
     # clears all dirty tracked information.
@@ -416,6 +483,60 @@ module Parse
 
     private
 
+    # @return [Boolean] true when the owner has no objectId yet, so an
+    #   atomic server operation has nothing to apply to.
+    def unsaved_delegate?
+      @delegate.respond_to?(:id) && @delegate.id.blank?
+    end
+
+    # @return [Boolean] whether the owner reports this field as changed.
+    def delegate_field_dirty?
+      return false unless @delegate.respond_to?(:changed)
+      @delegate.changed.include?(@key.to_s)
+    rescue StandardError
+      false
+    end
+
+    # Run an atomic operation on the owner and, when it succeeds, apply the
+    # same change to the local collection without marking the field dirty.
+    # The block receives a copy of the current items and the operation's
+    # items and returns the new contents.
+    # @return [Boolean] whether the operation succeeded.
+    def apply_atomic_op(op, items)
+      return true if items.empty?
+      success = @delegate.send(op, @key, items_to_pointers(items))
+      return false unless success
+      # Read the owner's dirty state before touching the items, so a change
+      # that was already pending is still sent by the next save.
+      was_dirty = delegate_field_dirty?
+      # A clean plain array adopts the array the server returned, so a local
+      # copy that was already out of date is corrected. With unsaved local
+      # edits pending, adopting it would discard them, so the operation is
+      # applied locally instead (as it is for pointer collections, or a reply
+      # without the field) and the pending edits are still sent on save.
+      server = was_dirty ? nil : server_array_after_op
+      @collection = server || yield(collection.to_a.dup, items)
+      @loaded = true
+      unless was_dirty
+        # Plain array properties detect in-place edits by comparing against
+        # a snapshot; take a new one so this update is not seen as an edit.
+        if @delegate.respond_to?(:_rebaseline_mutable_value!, true)
+          @delegate.send(:_rebaseline_mutable_value!, @key)
+        end
+      end
+      true
+    end
+
+    # The field's new array from the delegate's last atomic operation, when
+    # this is a plain array proxy and the server returned it.
+    # @return [Array, nil]
+    def server_array_after_op
+      return nil unless instance_of?(Parse::CollectionProxy)
+      return nil unless @delegate.respond_to?(:_last_operation_value, true)
+      value = @delegate.send(:_last_operation_value, @key)
+      value.is_a?(Array) ? Parse::Properties.deep_copy_value(value) : nil
+    end
+
     # Convert items to pointer format for atomic operations.
     # Parse objects/pointers are converted to pointer hashes, other items pass through.
     # @param items [Array] items to convert

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

@@ -378,10 +378,22 @@ module Parse
           }
 
           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
+            unless opts[:scope_only] == true
+              if @id.blank?
+                # An unsaved owner has no related records. Return a query
+                # that matches nothing, so chaining still works, without
+                # sending a constraint on a pointer with a null objectId.
+                query.where(:objectId.in => [])
+                query.define_singleton_method(:results) do |*_a, **_o, &blk|
+                  blk ? [].each(&blk) : []
+                end
+                query.define_singleton_method(:count) { |*_a, **_o| 0 }
+              else
+                query.where(foreign_field => self)
+              end
+            end
 
             if scope.is_a?(Proc)
               # magic, override the singleton method_missing with accessing object level methods
@@ -483,6 +495,7 @@ module Parse
           }
 
           self.field_map.merge!(key => parse_field)
+          Parse::Model.model_registry_changed!
           # dirty tracking
           define_attribute_methods key
 
@@ -510,7 +523,7 @@ module Parse
             unless val.is_a?(Parse::PointerCollectionProxy)
               results = []
               #results = val.parse_objects if val.respond_to?(:parse_objects)
-              val = proxyKlass.new results, delegate: self, key: key
+              val = proxyKlass.new results, delegate: self, key: key, parse_class: klassName
               instance_variable_set(ivar, val)
             end
             val
@@ -554,10 +567,21 @@ module Parse
               _collection.loaded = true
               _collection.remove val["objects"].parse_objects(klassName)
               val = _collection
-            elsif val.is_a?(Array)
-              # Otherwise create a new collection based on what the user
-              # defined; always coerce array elements to the declared class.
-              val = proxyKlass.new val.parse_objects(klassName), delegate: self, key: key, parse_class: klassName
+            elsif val.is_a?(Array) || (track == true && val.is_a?(Parse::CollectionProxy) && !val.is_a?(proxyKlass))
+              _collection = proxyKlass.new [], delegate: self, key: key, parse_class: klassName
+              items = if track == true
+                  # Assignment from application code: validate every item.
+                  # An item of another class, nil, or a value that is not an
+                  # object, pointer or objectId raises ArgumentError rather
+                  # than being stored under the declared class.
+                  _collection.send(:typecast_items, val.to_a)
+                else
+                  # Server data: coerce elements to the declared class.
+                  val.parse_objects(klassName)
+                end
+              _collection.set_collection!(items)
+              _collection.loaded = true
+              val = _collection
             end
 
             # send dirty tracking if set
@@ -579,11 +603,16 @@ module Parse
           #   for more information.
           if data_type == :relation
             # return a query given the foreign table class name.
+            # The $relatedTo key is the remote column, which differs from the
+            # local name when `field:` is given.
             define_method("#{key}_relation_query") do
-              Parse::Query.new(klassName, key.to_sym.related_to => self.pointer, limit: :max)
+              Parse::Query.new(klassName, parse_field.related_to => self.pointer, limit: :max)
             end
-            # fetch the contents of the relation
+            # fetch the contents of the relation. An owner without an
+            # objectId has nothing on the server; a query for it would send
+            # a null objectId, which Parse Server rejects.
             define_method("#{key}_fetch!") do
+              next [] if @id.blank?
               q = self.send :"#{key}_relation_query"
               q.results || []
             end

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

@@ -142,7 +142,9 @@ module Parse
           end
 
           define_method(key) do |*args, &block|
-            return nil if @id.nil?
+            # An unsaved owner has no related record, unless the scope alone
+            # selects it (`scope_only: true` does not use the owner id).
+            return nil if @id.blank? && opts[:scope_only] != true
             query = Parse::Query.new(klassName, limit: 1)
             query.where(foreign_field => self) unless opts[:scope_only] == true