parse-stack-next 5.5.6 → 5.7.0

data/lib/parse/model/core/vector_searchable.rb

@@ -65,6 +65,7 @@ module Parse
       class IndexDriftError < StandardError
         # @return [Array<String>] human-readable drift findings.
         attr_reader :findings
+
         def initialize(message, findings: [])
           @findings = findings
           super(message)
@@ -149,6 +150,12 @@ module Parse
       #   (fields must be declared `type: "filter"` in the index).
       # @param index [String, nil] explicit vectorSearch index name.
       #   Skips auto-discovery when given.
+      # @param candidate_limit [Integer, nil] rows Atlas returns before
+      #   ACL / filter / pointer-field enforcement runs; the result is
+      #   trimmed to `k` afterwards. Defaults to a multiple of `k` for
+      #   any caller subject to enforcement, so heavy ACL attrition
+      #   does not silently return fewer than `k` rows. Raise it when
+      #   a principal can read only a small fraction of the class.
       # @param num_candidates [Integer, nil] HNSW search width.
       # @param max_time_ms [Integer, nil] server-side timeout.
       # @param raw [Boolean] when true return the raw Mongo documents
@@ -192,7 +199,8 @@ module Parse
       #   deadline on the embed step.
       def find_similar(vector: nil, text: nil, k: 10, field: nil, filter: nil,
                        vector_filter: nil, index: nil,
-                       num_candidates: nil, max_time_ms: nil, raw: false,
+                       num_candidates: nil, candidate_limit: nil,
+                       max_time_ms: nil, raw: false,
                        **scope_opts)
         if vector.nil? && text.nil?
           raise ArgumentError,
@@ -206,8 +214,7 @@ module Parse
         resolved_field = resolve_vector_field!(field)
         declared_dims = vector_properties.dig(resolved_field, :dimensions)
 
-        query_vector =
-          if text.nil?
+        query_vector = if text.nil?
             coerce_query_vector(vector)
           else
             embed_query_text!(text, resolved_field)
@@ -222,6 +229,7 @@ module Parse
           query_vector: query_vector,
           k: k,
           num_candidates: num_candidates,
+          candidate_limit: candidate_limit,
           filter: filter,
           vector_filter: vector_filter,
           index: index_name,
@@ -284,8 +292,7 @@ module Parse
         declared_dims = vector_properties.dig(field_sym, :dimensions)
 
         qv = query_vector || vec[:query_vector]
-        qv =
-          if qv.nil?
+        qv = if qv.nil?
             unless text.is_a?(String) && !text.strip.empty?
               raise ArgumentError,
                     "#{self}.hybrid_search: pass `text:` (to embed) or a `query_vector:`."
@@ -314,6 +321,7 @@ module Parse
             query_vector: qv, field: field_sym, index: vector_index,
             num_candidates: vec[:num_candidates], filter: vec[:filter],
             vector_filter: vec[:vector_filter],
+            candidate_limit: vec[:candidate_limit],
           },
           k: k,
           fusion: fusion,
@@ -327,9 +335,22 @@ module Parse
       private
 
       def resolve_vector_field!(field)
-        declared = vector_properties.keys
+        # A property declared `searchable: false` is storage-only. That
+        # may be because it exceeds the Atlas index cap, or simply
+        # because the author opted it out. Either way, including it in
+        # resolution would let a caller reach a field no index serves,
+        # so it is excluded from auto-resolution entirely and refused
+        # with an explanation when named outright.
+        all_declared = vector_properties.keys
+        declared = all_declared.reject { |f| vector_properties[f][:searchable] == false }
+
         if field
           sym = field.to_sym
+          if all_declared.include?(sym) && !declared.include?(sym)
+            raise NoVectorProperty,
+                  "#{self}.find_similar: field :#{sym} is declared `searchable: false` " \
+                  "(storage-only, not eligible for search) and cannot be searched."
+          end
           unless declared.include?(sym)
             raise NoVectorProperty,
                   "#{self}.find_similar: field :#{sym} is not a :vector property " \
@@ -342,7 +363,7 @@ module Parse
         end
         if declared.empty?
           raise NoVectorProperty,
-                "#{self}.find_similar: no :vector property declared on this class."
+                "#{self}.find_similar: no searchable :vector property declared on this class."
         end
         raise AmbiguousVectorField,
               "#{self}.find_similar: class declares multiple :vector properties " \
@@ -383,6 +404,11 @@ module Parse
                 "on the property, or pass an explicit `vector:`."
         end
         provider = Parse::Embeddings.provider(provider_name)
+        # A query embedded by a different model than the stored vectors
+        # returns plausible-looking nonsense rather than an error, so
+        # the binding is verified here too — before the spend cap is
+        # charged and before any provider round-trip.
+        Parse::Embeddings::BindingAudit.verify!(self, resolved_field, provider)
         # Spend cap: every query-embed path (find_similar(text:),
         # hybrid_search(text:), Retrieval.retrieve) funnels through this
         # method, so charging here closes the "direct callers bypass the
@@ -405,7 +431,7 @@ module Parse
       def coerce_query_vector(vector)
         case vector
         when Parse::Vector then vector.to_a
-        when Array         then vector
+        when Array then vector
         else
           raise Parse::VectorSearch::InvalidQueryVector,
                 "vector: must be an Array<Float> or Parse::Vector (got #{vector.class})."

data/lib/parse/model/file.rb

@@ -43,7 +43,6 @@ module Parse
     # in logs or a CDN access trail.
     class SignedUrlError < Parse::Error; end
 
-
     # Regular expression that matches the old legacy Parse hosted file name
     LEGACY_FILE_RX = /^tfss-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}-/
     # The default attributes in a Parse File hash. Matches the Parse
@@ -86,7 +85,7 @@ module Parse
       # Alibaba Cloud metadata service (public-IP-space but well-known
       # cloud-metadata endpoint that must not be reachable from SDK fetches).
       "100.100.100.200/32",
-      "::/128", "::1/128", "fc00::/7", "fe80::/10", "ff00::/8", "::ffff:0:0/96"
+      "::/128", "::1/128", "fc00::/7", "fe80::/10", "ff00::/8", "::ffff:0:0/96",
     ].map { |c| IPAddr.new(c) }.freeze
     # Restrictive port allowlist for Parse::File URL fetches. By default
     # only the standard HTTP/HTTPS ports are permitted. Operators may
@@ -166,12 +165,14 @@ module Parse
       # @return [Integer] Maximum byte size for a remote URL fetch via
       #   `Parse::File.create` / `Parse::File.new(url)`.
       attr_writer :max_remote_size
+
       def max_remote_size
         @max_remote_size ||= DEFAULT_MAX_REMOTE_SIZE
       end
 
       # @return [Integer] Read/open timeout (seconds) for remote URL fetches.
       attr_writer :remote_timeout
+
       def remote_timeout
         @remote_timeout ||= DEFAULT_REMOTE_TIMEOUT
       end
@@ -182,6 +183,7 @@ module Parse
       #   ".example.com" matches "files.example.com"). Default: empty (any
       #   public host is allowed; private hosts are always denied).
       attr_writer :allowed_remote_hosts
+
       def allowed_remote_hosts
         @allowed_remote_hosts ||= []
       end
@@ -202,6 +204,7 @@ module Parse
       #   entries via leading "." (e.g. `".cdn.example.com"`) match any
       #   subdomain.
       attr_writer :trusted_url_hosts
+
       def trusted_url_hosts
         @trusted_url_hosts ||= ["files.parsetfss.com"]
       end
@@ -226,6 +229,7 @@ module Parse
       #   hydration `attributes=` — asymmetric writer behavior was an
       #   explicit anti-goal of the design.
       attr_writer :signed_url_policy
+
       def signed_url_policy
         @signed_url_policy ||= :strip
       end
@@ -244,12 +248,14 @@ module Parse
       #   The default is intentionally non-breaking; integrators ready to
       #   enforce flip the policy explicitly.
       attr_writer :untrusted_url_policy
+
       def untrusted_url_policy
         @untrusted_url_policy ||= :warn
       end
 
       # @return [Array<Integer>] Allowed remote ports for URL fetches.
       attr_writer :allowed_remote_ports
+
       def allowed_remote_ports
         @allowed_remote_ports ||= DEFAULT_ALLOWED_REMOTE_PORTS.dup
       end
@@ -543,10 +549,10 @@ module Parse
         # "exceeds". Fail fast with a clear message before any DNS/host work.
         max_bytes = coerce_positive_max_bytes(max_bytes)
         uri = begin
-          URI.parse(url_string)
-        rescue URI::InvalidURIError => e
-          raise ArgumentError, "Invalid URL: #{e.message}"
-        end
+            URI.parse(url_string)
+          rescue URI::InvalidURIError => e
+            raise ArgumentError, "Invalid URL: #{e.message}"
+          end
         unless %w[http https].include?(uri.scheme)
           raise ArgumentError, "Parse::File only supports http(s) URLs (got #{uri.scheme.inspect})"
         end
@@ -603,8 +609,7 @@ module Parse
       # @return [Integer, nil]
       def coerce_positive_max_bytes(max_bytes)
         return nil if max_bytes.nil?
-        requested =
-          begin
+        requested = begin
             Integer(max_bytes)
           rescue ArgumentError, TypeError
             raise ArgumentError, "max_bytes must be a positive integer (got #{max_bytes.inspect})"
@@ -931,6 +936,7 @@ module Parse
         @url = Parse::File.sanitize_hydrated_url(value, fallback: @url, name: @name)
       end
     end
+
     private :normalize_and_store_url
 
     # @!visibility private
@@ -953,10 +959,10 @@ module Parse
       return raw unless raw.start_with?("http://") || raw.start_with?("https://")
 
       uri = begin
-        URI.parse(raw)
-      rescue URI::InvalidURIError
-        return raw  # malformed URL — leave it alone; downstream code already handles
-      end
+          URI.parse(raw)
+        rescue URI::InvalidURIError
+          return raw  # malformed URL — leave it alone; downstream code already handles
+        end
       host = uri.host.to_s.downcase
       return raw if host.empty?
 
@@ -975,7 +981,7 @@ module Parse
       when :strip
         warn_untrusted_url_host_once(host, action: "stripped")
         fallback
-      else  # :warn (default)
+      else # :warn (default)
         warn_untrusted_url_host_once(host, action: "accepted")
         raw
       end
@@ -1034,8 +1040,8 @@ module Parse
     def save(session_token: nil, use_master_key: nil)
       unless saved? || @contents.nil? || @name.nil?
         opts = {}
-        opts[:session_token]   = session_token unless session_token.nil?
-        opts[:use_master_key]  = use_master_key unless use_master_key.nil?
+        opts[:session_token] = session_token unless session_token.nil?
+        opts[:use_master_key] = use_master_key unless use_master_key.nil?
         response = client.create_file(@name, @contents, @mime_type, **opts)
         unless response.error?
           result = response.result

data/lib/parse/model/geojson.rb

@@ -49,8 +49,7 @@ module Parse
       end
 
       def coordinates=(value)
-        coords =
-          case value
+        coords = case value
           when self.class
             deep_copy_array(value.coordinates)
           when Hash
@@ -76,6 +75,7 @@ module Parse
       def to_geojson
         { "type" => geojson_type, "coordinates" => deep_copy_array(@coordinates) }
       end
+
       alias_method :as_json, :to_geojson
 
       # @return [String] the JSON form, suitable for direct shipment to

data/lib/parse/model/geopoint.rb

@@ -109,6 +109,7 @@ module Parse
       km = 0 if km.nil?
       [@latitude, @longitude, km, :km]
     end
+
     alias_method :max_km, :max_kilometers
 
     # Helper method for performing geo-queries with a radial radians

data/lib/parse/model/object.rb

@@ -403,11 +403,11 @@ module Parse
       # @return [Parse::ACL] the current default ACLs for this class.
       def default_acls
         @default_acls ||= case acl_policy_setting
-                          when :public, :owner_else_public then Parse::ACL.everyone
-                          when :public_read, :owner_but_public_read then Parse::ACL.everyone(true, false)
-                          when :private, :owner_else_private then Parse::ACL.private
-                          else Parse::ACL.everyone
-                          end
+          when :public, :owner_else_public then Parse::ACL.everyone
+          when :public_read, :owner_but_public_read then Parse::ACL.everyone(true, false)
+          when :private, :owner_else_private then Parse::ACL.private
+          else Parse::ACL.everyone
+          end
       end
 
       # A method to set default ACLs to be applied for newly created
@@ -541,10 +541,10 @@ module Parse
         end
         if owner.nil? && policy.to_s.start_with?("owner_")
           fallback = case policy
-                     when :owner_else_public then "public R/W"
-                     when :owner_but_public_read then "public read only"
-                     else "master-key-only"
-                     end
+            when :owner_else_public then "public R/W"
+            when :owner_but_public_read then "public read only"
+            else "master-key-only"
+            end
           warn "[#{self}] acl_policy #{policy.inspect} declared without `owner:` field; ACL resolution will always use the fallback (#{fallback}). Pass `as:` at construction to override."
         end
         @acl_policy_setting = policy
@@ -698,7 +698,7 @@ module Parse
         class_permissions.set_default_permission(
           public_access: public,
           roles: Array(roles),
-          requires_authentication: requires_authentication
+          requires_authentication: requires_authentication,
         )
 
         # Also explicitly set all operations to ensure they're included
@@ -789,7 +789,7 @@ module Parse
           roles: Array(roles),
           users: Array(users),
           pointer_fields: converted_pointer_fields,
-          requires_authentication: requires_authentication
+          requires_authentication: requires_authentication,
         )
       end
 
@@ -1043,8 +1043,8 @@ module Parse
 
           per_field[local_sym] = {
             write: guards_map[local_sym] || :open,
-            read:  hidden_from.empty? ? :open : { hidden_from: hidden_from },
-            type:  data_type,
+            read: hidden_from.empty? ? :open : { hidden_from: hidden_from },
+            type: data_type,
           }
         end
 
@@ -1057,10 +1057,10 @@ module Parse
           end
 
         {
-          operations:        operations,
-          read_user_fields:  perms.respond_to?(:read_user_fields)  ? perms.read_user_fields  : [],
+          operations: operations,
+          read_user_fields: perms.respond_to?(:read_user_fields) ? perms.read_user_fields : [],
           write_user_fields: perms.respond_to?(:write_user_fields) ? perms.write_user_fields : [],
-          fields:            per_field,
+          fields: per_field,
         }
       end
 
@@ -1241,8 +1241,7 @@ module Parse
       # for tests or internal mongo-direct bulk writes). A class may flip
       # the per-class default with `vector_visibility :public`; an explicit
       # `include_vectors:` in the call always wins over the class default.
-      include_vectors =
-        if opts.key?(:include_vectors)
+      include_vectors = if opts.key?(:include_vectors)
           opts[:include_vectors] == true
         else
           self.class.respond_to?(:vectors_public_by_default?) && self.class.vectors_public_by_default?
@@ -1351,6 +1350,12 @@ module Parse
       # the trust signal here.
       trusted = @_trusted_init == true
       @_trusted_init = nil
+      input_hash = opts.is_a?(Hash) ? opts : nil
+      input_had_acl = input_hash && %w[ACL acl].any? do |key|
+        input_hash.key?(key) || input_hash.key?(key.to_sym)
+      end
+      input_had_id = input_hash && (input_hash.key?(Parse::Model::OBJECT_ID) || input_hash.key?(:objectId) ||
+                                    input_hash.key?(:id) || input_hash.key?(Parse::Model::ID))
       acl_owner_override = nil
       if opts.is_a?(String) #then it's the objectId
         @id = opts.to_s
@@ -1398,6 +1403,31 @@ module Parse
       @_acl_pristine = !acl_was_user_supplied
       @_acl_owner_override = acl_owner_override
 
+      # Record where our ACL knowledge came from. `acl.nil?` alone is not
+      # enough: it can mean a genuinely ACL-less (therefore public) server
+      # row, but it also describes an id-only pointer or a selective response
+      # that never fetched ACL. Conversely, a custom class may stamp its local
+      # default ACL while hydrating a full server row whose ACL was absent.
+      # Access inspection uses this evidence to distinguish those cases.
+      @_authorization_acl_state = if trusted
+          if has_selective_keys? && !input_had_acl
+            :unknown
+          elsif input_had_acl
+            self.acl.nil? ? :absent : :present
+          else
+            :absent
+          end
+        elsif opts.is_a?(String) || input_had_id
+          :unknown
+        elsif input_had_acl
+          self.acl.nil? ? :unknown : :local
+        elsif self.class.builtin_acl_default_active?
+          :unknown
+        else
+          :local
+        end
+      @_authorization_acl_tracking_ready = true
+
       # One-time per-class permissive-default warning. Fires only when the
       # effective policy is :public or :owner_else_public.
       self.class._warn_permissive_acl_default_once
@@ -1617,6 +1647,39 @@ module Parse
       @_fetched_keys.include?(key) || (remote_key && @_fetched_keys.include?(remote_key))
     end
 
+    # Describes whether the in-memory ACL is authoritative enough for local
+    # access inspection. `:absent` means a full trusted server response omitted
+    # ACL (Parse Server's public default); `:present` and `:local` have a usable
+    # ACL value; `:unknown` covers pointers and incomplete hydration.
+    #
+    # @return [Symbol] `:present`, `:absent`, `:local`, or `:unknown`.
+    # @api private
+    def authorization_acl_state
+      @_authorization_acl_state || :unknown
+    end
+
+    # Update ACL evidence after `fetch!` applies a server response to an
+    # existing instance. Save/update responses are deliberately excluded: they
+    # are deltas and omission there says nothing about the stored ACL.
+    # @param attributes [Hash] trusted server response.
+    # @param partial [Boolean] whether a selective key fetch produced it.
+    # @api private
+    def record_authorization_hydration!(attributes, partial: false)
+      return unless attributes.is_a?(Hash)
+      has_acl = %w[ACL acl].any? do |key|
+        attributes.key?(key) || attributes.key?(key.to_sym)
+      end
+      @_authorization_acl_state = if has_acl
+          self.acl.nil? ? :absent : :present
+        elsif partial
+          :unknown
+        else
+          :absent
+        end
+      @_authorization_acl_tracking_ready = true
+      @_authorization_acl_state
+    end
+
     # Returns the nested fetched keys map for building nested objects.
     # @return [Hash] map of field names to their fetched keys
     def nested_fetched_keys
@@ -1884,48 +1947,48 @@ module Parse
       owner = @_acl_owner_override if defined?(@_acl_owner_override)
       if owner.nil? && (field = self.class.acl_owner_field)
         owner = if field == :self
-          # Self-referential ownership (Parse::User only — enforced at
-          # declaration time). Pre-generate a Parse-compatible objectId
-          # client-side so the ACL grant can reference the record's own
-          # id in the same POST body that creates it. Skipped when the id
-          # is already set (e.g. when re-saving an existing user, or when
-          # parse_reference precompute already ran).
-          @id = Parse::Core::ParseReference.generate_object_id if @id.blank?
-          @id
-        elsif respond_to?(field)
-          send(field)
-        end
+            # Self-referential ownership (Parse::User only — enforced at
+            # declaration time). Pre-generate a Parse-compatible objectId
+            # client-side so the ACL grant can reference the record's own
+            # id in the same POST body that creates it. Skipped when the id
+            # is already set (e.g. when re-saving an existing user, or when
+            # parse_reference precompute already ran).
+            @id = Parse::Core::ParseReference.generate_object_id if @id.blank?
+            @id
+          elsif respond_to?(field)
+            send(field)
+          end
       end
       owner_id = _resolve_acl_owner_id(owner)
 
       target_acl = case policy
-                   when :public
-                     Parse::ACL.everyone(true, true)
-                   when :public_read
-                     Parse::ACL.everyone(true, false)
-                   when :private
-                     Parse::ACL.private
-                   when :owner_else_public
-                     if owner_id
-                       acl = Parse::ACL.new
-                       acl.apply(owner_id, true, true)
-                       acl
-                     else
-                       Parse::ACL.everyone(true, true)
-                     end
-                   when :owner_else_private
-                     if owner_id
-                       acl = Parse::ACL.new
-                       acl.apply(owner_id, true, true)
-                       acl
-                     else
-                       Parse::ACL.private
-                     end
-                   when :owner_but_public_read
-                     acl = Parse::ACL.everyone(true, false)
-                     acl.apply(owner_id, true, true) if owner_id
-                     acl
-                   end
+        when :public
+          Parse::ACL.everyone(true, true)
+        when :public_read
+          Parse::ACL.everyone(true, false)
+        when :private
+          Parse::ACL.private
+        when :owner_else_public
+          if owner_id
+            acl = Parse::ACL.new
+            acl.apply(owner_id, true, true)
+            acl
+          else
+            Parse::ACL.everyone(true, true)
+          end
+        when :owner_else_private
+          if owner_id
+            acl = Parse::ACL.new
+            acl.apply(owner_id, true, true)
+            acl
+          else
+            Parse::ACL.private
+          end
+        when :owner_but_public_read
+          acl = Parse::ACL.everyone(true, false)
+          acl.apply(owner_id, true, true) if owner_id
+          acl
+        end
 
       # Only re-stamp if the resolved ACL differs from the init-time stamp;
       # this avoids an unnecessary dirty mark on the acl field for `:public`
@@ -1985,6 +2048,9 @@ module Parse
         @_acl_snapshot_before_change = @acl ? Parse::ACL.new(@acl.as_json) : Parse::ACL.new
       end
       @_acl_pristine = false if defined?(@_acl_pristine)
+      if defined?(@_authorization_acl_tracking_ready) && @_authorization_acl_tracking_ready
+        @_authorization_acl_state = :local
+      end
       super
     end
 
@@ -2156,16 +2222,16 @@ class Array
       next m if m.is_a?(Parse::Pointer)
       if m.is_a?(Hash)
         resolved = if className
-                     # Caller knows the type; warn on mismatch but always
-                     # use the declared className.
-                     incoming = m[f] || m[:className]
-                     if incoming && !Parse::Model.same_parse_class?(incoming, className)
-                       warn "[Parse::Array#parse_objects] expected className=#{className.inspect}, ignoring incoming className=#{incoming.inspect}"
-                     end
-                     className
-                   else
-                     m[f] || m[:className]
-                   end
+            # Caller knows the type; warn on mismatch but always
+            # use the declared className.
+            incoming = m[f] || m[:className]
+            if incoming && !Parse::Model.same_parse_class?(incoming, className)
+              warn "[Parse::Array#parse_objects] expected className=#{className.inspect}, ignoring incoming className=#{incoming.inspect}"
+            end
+            className
+          else
+            m[f] || m[:className]
+          end
         next Parse::Object.build(m, resolved) if resolved
       end
       nil

data/lib/parse/model/pointer.rb

@@ -118,8 +118,10 @@ module Parse
     # nil unless the instance came from the corresponding search path.
     # @return [Float, nil]
     def vector_score; @_vector_score; end
+
     # @return [Float, nil]
     def search_score; @_search_score; end
+
     # @return [Hash, nil]
     def search_highlights; @_search_highlights; end
 

data/lib/parse/model/polygon.rb

@@ -99,8 +99,7 @@ module Parse
       end
       outer = rings.first
       pairs = outer.map do |(lng, lat)|
-        raise ArgumentError, "[Parse::Polygon] GeoJSON ring entries must be [lng, lat] numeric pairs." \
-          unless lng.is_a?(Numeric) && lat.is_a?(Numeric)
+        raise ArgumentError, "[Parse::Polygon] GeoJSON ring entries must be [lng, lat] numeric pairs." unless lng.is_a?(Numeric) && lat.is_a?(Numeric)
         [lat.to_f, lng.to_f]
       end
       new(pairs)
@@ -120,8 +119,7 @@ module Parse
     # - a Hash with a `coordinates` key (the Parse REST wire shape)
     # - another {Parse::Polygon}
     def coordinates=(value)
-      coords =
-        case value
+      coords = case value
         when Parse::Polygon
           # Duplicate so external mutation of the source doesn't leak in.
           value.coordinates.map { |pair| pair.dup }
@@ -270,8 +268,7 @@ module Parse
     # @param point [Parse::GeoPoint, Array<Numeric>] the point to test.
     # @return [Boolean]
     def contains_point?(point)
-      lat, lng =
-        case point
+      lat, lng = case point
         when Parse::GeoPoint then [point.latitude, point.longitude]
         when Array then [point[0].to_f, point[1].to_f]
         else

data/lib/parse/model/push.rb

@@ -963,11 +963,11 @@ module Parse
       if device_type.present? && !SUPPORTED_PUSH_DEVICE_TYPES.include?(device_type)
         if UNSUPPORTED_PUSH_DEVICE_TYPES.include?(device_type)
           warn "[Parse::Push] Warning: device_type '#{device_type}' may not be supported for push notifications. " \
-               "Supported types: #{SUPPORTED_PUSH_DEVICE_TYPES.join(', ')}"
+               "Supported types: #{SUPPORTED_PUSH_DEVICE_TYPES.join(", ")}"
         else
           warn "[Parse::Push] Warning: unknown device_type '#{device_type}' for installation #{installation_id}. " \
                "This device type may not receive push notifications. " \
-               "Supported types: #{SUPPORTED_PUSH_DEVICE_TYPES.join(', ')}"
+               "Supported types: #{SUPPORTED_PUSH_DEVICE_TYPES.join(", ")}"
         end
       end
     end

data/lib/parse/model/vector.rb

@@ -57,6 +57,7 @@ module Parse
     def dimensions
       @values.length
     end
+
     alias_method :length, :dimensions
     alias_method :size, :dimensions
 
@@ -84,10 +85,11 @@ module Parse
     def ==(other)
       case other
       when Parse::Vector then @values == other.values
-      when Array         then @values == other
+      when Array then @values == other
       else false
       end
     end
+
     alias_method :eql?, :==
 
     def hash