parse-stack-next 5.5.6 → 5.7.0

data/lib/parse/clp_scope.rb

@@ -11,7 +11,7 @@ module Parse
 
       def initialize(class_name, operation, reason = nil)
         @class_name = class_name
-        @operation  = operation
+        @operation = operation
         super(reason || "CLP denied: #{operation} on #{class_name}")
       end
     end
@@ -44,6 +44,31 @@ module Parse
     # branch on `kind` before dereferencing.
     CacheEntry = Struct.new(:kind, :clp, :fetched_at, keyword_init: true)
 
+    # Result of evaluating a single CLP branch for object-access inspection.
+    # This is intentionally richer than {permits?}: Parse Server only applies
+    # pointer permissions when no public/user/role branch already grants the
+    # operation, and callers must then inspect the target row before answering.
+    AccessEvaluation = Struct.new(
+      :status, :via, :pointer_fields, :role_claims, :reason,
+      keyword_init: true,
+    ) do
+      def allowed?
+        status == :allowed
+      end
+
+      def denied?
+        status == :denied
+      end
+
+      def unknown?
+        status == :unknown
+      end
+
+      def row_check_required?
+        status == :allowed && pointer_fields&.any?
+      end
+    end
+
     # Positive-cache TTL (seconds): how long a successful schema fetch
     # is reused. Mirrors the previous module-level `@cache_ttl` knob;
     # kept identical to preserve backwards-compatible cache behavior.
@@ -64,11 +89,11 @@ module Parse
     class << self
       attr_accessor :cache_ttl, :schema_client
 
-      def permits?(class_name, op, permission_strings)
+      def permits?(class_name, op, permission_strings, client: nil)
         return true if permission_strings.nil?  # master-key bypass
         return true unless OPERATIONS.include?(op)
 
-        entry = fetch(class_name)
+        entry = fetch(class_name, client: client)
         # `fetch` never returns nil now — it returns an `:unresolvable`
         # CacheEntry on failure so callers must branch on `kind`.
         case entry.kind
@@ -120,14 +145,14 @@ module Parse
         false
       end
 
-      def assert_permitted!(class_name, op, permission_strings)
-        return if permits?(class_name, op, permission_strings)
+      def assert_permitted!(class_name, op, permission_strings, client: nil)
+        return if permits?(class_name, op, permission_strings, client: client)
         raise Denied.new(class_name, op,
-          "CLP refuses #{op} on '#{class_name}' for the current scope.")
+                         "CLP refuses #{op} on '#{class_name}' for the current scope.")
       end
 
-      def pointer_fields_for(class_name, op)
-        entry = fetch(class_name)
+      def pointer_fields_for(class_name, op, client: nil)
+        entry = fetch(class_name, client: client)
         # No CLP at all, or schema unresolvable: there's no
         # pointerFields constraint to apply. (For :unresolvable the
         # caller's `permits?` already failed closed; this helper just
@@ -141,10 +166,124 @@ module Parse
         arr.empty? ? nil : arr
       end
 
-      def protected_fields_for(class_name, permission_strings)
+      # Return Parse Server's top-level `readUserFields` or
+      # `writeUserFields` row constraint for an operation. Unlike an
+      # operation's `pointerFields` grant, these keys live alongside the
+      # operation maps in `classLevelPermissions` and therefore need their
+      # own lookup.
+      #
+      # @param class_name [String] Parse class name.
+      # @param op [Symbol] CLP operation.
+      # @return [Array<String>, nil] pointer field names, or nil when the
+      #   operation has no corresponding user-field constraint.
+      def user_fields_for(class_name, op, client: nil)
+        key = case op.to_sym
+          when :find, :get, :count then "readUserFields"
+          when :create, :update, :delete then "writeUserFields"
+          end
+        return nil if key.nil?
+
+        entry = fetch(class_name, client: client)
+        return nil if entry.kind == :no_clp || entry.kind == :unresolvable
+
+        fields = entry.clp[key] || entry.clp[key.to_sym]
+        arr = Array(fields).map(&:to_s)
+        arr.empty? ? nil : arr
+      end
+
+      # Evaluate the same mutually-exclusive CLP branches Parse Server uses
+      # before applying a query to a particular row. Public, direct-user, and
+      # role grants bypass pointer constraints. `requiresAuthentication` does
+      # not: when pointer/user fields exist, a concrete authenticated `_User`
+      # id must still match the row.
+      #
+      # Unlike {permits?}, schema lookup failures are reported as `:unknown`
+      # rather than collapsed into a denial. Authorization-enforcing callers
+      # can still fail closed by accepting only {AccessEvaluation#allowed?}.
+      #
+      # @param class_name [String] Parse class name.
+      # @param op [Symbol] one of {OPERATIONS}.
+      # @param claims [Enumerable<String>] public, user, and role claims.
+      # @param authenticated [Boolean] whether authentication is established.
+      # @param user_id [String, nil] concrete authenticated `_User.objectId`.
+      # @param client [Parse::Client] application whose schema owns the CLP.
+      # @return [AccessEvaluation]
+      def evaluate_access(class_name, op, claims:, authenticated:, user_id: nil, client: nil)
+        op = op.to_sym
+        unless OPERATIONS.include?(op)
+          return access_evaluation(:unknown, reason: :unsupported_operation)
+        end
+
+        entry = fetch(class_name, client: client)
+        case entry.kind
+        when :unresolvable
+          return access_evaluation(:unknown, reason: :clp_unresolvable)
+        when :no_clp
+          return access_evaluation(:allowed, via: :public_default)
+        end
+
+        op_map = entry.clp[op.to_s] || entry.clp[op]
+        # Parse Server treats an omitted operation map as public. Because that
+        # is already a base grant, grouped pointer fields do not narrow it.
+        return access_evaluation(:allowed, via: :public_default) if op_map.nil?
+        unless op_map.is_a?(Hash)
+          return access_evaluation(:unknown, reason: :malformed_clp)
+        end
+
+        claim_set = claims.is_a?(Set) ? claims : Set.new(Array(claims).map(&:to_s))
+        role_claims = op_map.each_with_object([]) do |(principal, allowed), memo|
+          key = principal.to_s
+          memo << key if allowed == true && key.start_with?("role:")
+        end.freeze
+
+        if op_map["*"] == true || op_map[:"*"] == true
+          return access_evaluation(:allowed, via: :public, role_claims: role_claims)
+        end
+
+        direct_claim = op_map.find do |principal, allowed|
+          key = principal.to_s
+          allowed == true && key != "*" && key != "requiresAuthentication" &&
+            key != "pointerFields" && claim_set.include?(key)
+        end
+        if direct_claim
+          return access_evaluation(
+                   :allowed,
+                   via: direct_claim.first.to_s.start_with?("role:") ? :role : :user,
+                   role_claims: role_claims,
+                 )
+        end
+
+        pointer_fields = pointer_fields_from(entry.clp, op)
+        requires_authentication =
+          op_map["requiresAuthentication"] == true || op_map[:requiresAuthentication] == true
+
+        if pointer_fields.any?
+          if authenticated == true && !user_id.to_s.empty?
+            return access_evaluation(
+                     :allowed,
+                     via: :pointer,
+                     pointer_fields: pointer_fields,
+                     role_claims: role_claims,
+                   )
+          end
+
+          status = authenticated == true ? :unknown : :denied
+          reason = authenticated == true ? :concrete_user_required : :authentication_required
+          return access_evaluation(status, role_claims: role_claims, reason: reason)
+        end
+
+        if requires_authentication && authenticated == true
+          return access_evaluation(:allowed, via: :authenticated, role_claims: role_claims)
+        end
+
+        reason = requires_authentication ? :authentication_required : :clp_denied
+        access_evaluation(:denied, role_claims: role_claims, reason: reason)
+      end
+
+      def protected_fields_for(class_name, permission_strings, client: nil)
         return EMPTY_SET if permission_strings.nil?
 
-        entry = fetch(class_name)
+        entry = fetch(class_name, client: client)
         # No CLP / unresolvable: nothing to strip. For :unresolvable,
         # `permits?` already refused the query, so this branch is only
         # reached when callers ask for the protected-fields set directly
@@ -180,8 +319,15 @@ module Parse
         documents.select { |doc| any_pointer_matches?(doc, pointer_fields, user_id.to_s) }
       end
 
-      def invalidate!(class_name)
-        @cache_mutex.synchronize { @cache.delete(class_name.to_s) }
+      def invalidate!(class_name, client: nil)
+        class_key = class_name.to_s
+        @cache_mutex.synchronize do
+          if client
+            @cache.delete(cache_key(class_key, client))
+          else
+            @cache.delete_if { |(_scope, cached_class), _entry| cached_class == class_key }
+          end
+        end
         nil
       end
 
@@ -196,7 +342,11 @@ module Parse
 
       def cache_stats
         @cache_mutex.synchronize do
-          { size: @cache.size, class_names: @cache.keys.sort }
+          {
+            size: @cache.size,
+            class_names: @cache.keys.map(&:last).uniq.sort,
+            scopes: @cache.keys.map(&:first).uniq.sort,
+          }
         end
       end
 
@@ -205,11 +355,11 @@ module Parse
       # `:no_clp` (matches the public-default semantics Parse Server
       # exposes when no CLP is configured); a non-empty `clp` is
       # recorded as `:cached_clp` (the standard happy path).
-      def __cache_put(class_name, clp:)
+      def __cache_put(class_name, clp:, client: nil)
         normalized = clp || {}
         kind = normalized.empty? ? :no_clp : :cached_clp
         entry = CacheEntry.new(kind: kind, clp: normalized, fetched_at: monotonic_now)
-        @cache_mutex.synchronize { @cache[class_name.to_s] = entry }
+        @cache_mutex.synchronize { @cache[cache_key(class_name, client)] = entry }
         entry
       end
 
@@ -233,23 +383,24 @@ module Parse
       # An empty `class_name` short-circuits to an `:unresolvable`
       # entry — `permits?` will refuse the call rather than dispatching
       # `schema("")` to the upstream client.
-      def fetch(class_name)
-        key = class_name.to_s
-        return unresolvable_entry if key.empty?
+      def fetch(class_name, client: nil)
+        class_key = class_name.to_s
+        return unresolvable_entry if class_key.empty?
+
+        resolved_client = client || schema_client || default_client_safe
+        key = cache_key(class_key, resolved_client)
 
         cached = @cache_mutex.synchronize { @cache[key] }
         return cached if cached && !stale?(cached)
 
-        client = schema_client || default_client_safe
-        entry =
-          if client.nil?
+        entry = if resolved_client.nil?
             # No client configured (Parse.setup never called, etc.) —
             # treat as unresolvable so we fail closed instead of
             # crashing inside the begin block with NoMethodError.
             unresolvable_entry
           else
             begin
-              response = client.schema(key)
+              response = resolved_client.schema(class_key)
               if response&.success?
                 schema = response.result || {}
                 clp = schema["classLevelPermissions"] || {}
@@ -318,6 +469,46 @@ module Parse
         Parse::Client.client(:default)
       end
 
+      # Cache CLP by Parse application, not merely by class name. Two clients
+      # can legitimately point at different applications that both contain a
+      # `Document` class with unrelated permissions.
+      def cache_key(class_name, client = nil)
+        resolved_client = client || schema_client || default_client_safe
+        scope = if resolved_client.nil?
+            "client:none"
+          elsif resolved_client.respond_to?(:server_url) &&
+                resolved_client.respond_to?(:application_id)
+            "app:#{resolved_client.server_url}\u0000#{resolved_client.application_id}"
+          else
+            "client:#{resolved_client.object_id}"
+          end
+        [scope.freeze, class_name.to_s.freeze].freeze
+      end
+
+      def access_evaluation(status, via: nil, pointer_fields: EMPTY_SET,
+                                    role_claims: EMPTY_SET, reason: nil)
+        AccessEvaluation.new(
+          status: status,
+          via: via,
+          pointer_fields: Array(pointer_fields).map(&:to_s).uniq.freeze,
+          role_claims: Array(role_claims).map(&:to_s).uniq.freeze,
+          reason: reason,
+        ).freeze
+      end
+
+      def pointer_fields_from(clp, op)
+        op_map = clp[op.to_s] || clp[op]
+        per_operation = if op_map.is_a?(Hash)
+            op_map["pointerFields"] || op_map[:pointerFields]
+          end
+        grouped_key = case op.to_sym
+          when :find, :get, :count then "readUserFields"
+          when :create, :update, :delete then "writeUserFields"
+          end
+        grouped = grouped_key && (clp[grouped_key] || clp[grouped_key.to_sym])
+        (Array(per_operation) + Array(grouped)).map(&:to_s).reject(&:empty?).uniq.freeze
+      end
+
       def user_identity?(entry)
         s = entry.to_s
         s != "*" && !s.start_with?("role:")
@@ -339,20 +530,26 @@ module Parse
         pointer_fields.any? do |field|
           val = doc[field] || doc[field.to_sym]
           if val.is_a?(Hash)
-            return true if val["objectId"] == user_id || val[:objectId] == user_id
+            return true if user_pointer_matches?(val, user_id)
           elsif val.is_a?(Array)
-            return true if val.any? do |v|
-              v.is_a?(Hash) && (v["objectId"] == user_id || v[:objectId] == user_id)
-            end
+            return true if val.any? { |v| user_pointer_matches?(v, user_id) }
           end
           mongo_val = doc["_p_#{field}"] || doc[:"_p_#{field}"]
           if mongo_val.is_a?(String) && mongo_val.include?("$")
-            _cls, oid = mongo_val.split("$", 2)
-            return true if oid == user_id
+            klass, oid = mongo_val.split("$", 2)
+            return true if klass == Parse::Model::CLASS_USER && oid == user_id
           end
           false
         end
       end
+
+      def user_pointer_matches?(value, user_id)
+        return false unless value.is_a?(Hash)
+        type = value["__type"] || value[:__type]
+        klass = value["className"] || value[:className]
+        oid = value["objectId"] || value[:objectId]
+        type == Parse::Model::TYPE_POINTER && klass == Parse::Model::CLASS_USER && oid == user_id
+      end
     end
 
     @cache_ttl = POSITIVE_TTL

data/lib/parse/console.rb

@@ -26,7 +26,7 @@ require "timeout"
 
 module Parse
   module Console
-    DEFAULT_WATCH_EVENTS  = [:create, :update, :delete, :enter, :leave].freeze
+    DEFAULT_WATCH_EVENTS = [:create, :update, :delete, :enter, :leave].freeze
     DEFAULT_WAIT_FOR_EVENTS = [:create, :enter].freeze
 
     module_function
@@ -120,9 +120,9 @@ module Parse
     # @return [Parse::Object] the matched row.
     # @raise [Timeout::Error] when `timeout:` elapses with no match.
     def wait_for(klass, where: {}, on: nil, timeout: nil, fields: nil,
-                 session_token: nil, &predicate)
+                        session_token: nil, &predicate)
       events = Array(on || DEFAULT_WAIT_FOR_EVENTS).map(&:to_sym)
-      queue  = Queue.new
+      queue = Queue.new
       sub = _open_subscription(klass, where: where, fields: fields, session_token: session_token)
 
       events.each do |ev|

data/lib/parse/embeddings/batch_embedder.rb

@@ -83,8 +83,8 @@ module Parse
       # @param on_progress [#call, nil] callable invoked after each
       #   successful batch with `done:, total:, batch_index:, batch_count:`.
       def initialize(provider, batch_size: nil, requests_per_minute: nil,
-                     max_attempts: 5, base_delay: 2.0, max_delay: 60.0,
-                     jitter: 0.25, retry_on: nil, on_progress: nil)
+                               max_attempts: 5, base_delay: 2.0, max_delay: 60.0,
+                               jitter: 0.25, retry_on: nil, on_progress: nil)
         unless provider.is_a?(Provider)
           raise ArgumentError,
                 "Parse::Embeddings::BatchEmbedder expects a Parse::Embeddings::Provider " \
@@ -164,7 +164,7 @@ module Parse
       end
 
       def backoff_delay(attempt)
-        delay = [@base_delay * (2**(attempt - 1)), @max_delay].min
+        delay = [@base_delay * (2 ** (attempt - 1)), @max_delay].min
         delay * (1.0 + rand * @jitter)
       end
 

data/lib/parse/embeddings/binding_audit.rb

@@ -0,0 +1,211 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module Embeddings
+    # Checks that a `:vector` property's declared provider binding
+    # still matches the provider actually registered under that name.
+    #
+    # A `:vector` property may declare `provider:`, `model:`, and
+    # `dimensions:`. Only `provider:` was ever enforced. `dimensions:`
+    # is verified — but only against the vector a provider already
+    # returned, i.e. after the call has been made and paid for. And
+    # `model:` was never checked at all, which is the dangerous one: two
+    # generations of the same model family usually share a width
+    # (`voyage-3` and `voyage-3.5` are both 1024), so swapping the
+    # registered provider's model silently mixes incompatible
+    # embeddings into one index. Nothing raises, recall just quietly
+    # degrades, and the damage is only repairable by re-embedding.
+    #
+    # This module closes both gaps by comparing the declaration against
+    # the live provider BEFORE any request is issued.
+    #
+    # Auditing cannot happen at class-definition time: providers are
+    # registered by name and, as {Parse::Core::EmbedManaged} documents,
+    # registration may legitimately happen any time before the first
+    # save. So the audit runs lazily on each use and is also exposed as
+    # {.audit_all!} for an explicit boot-time or CI check.
+    module BindingAudit
+      # Raised when a property's declared binding disagrees with the
+      # registered provider.
+      class BindingMismatch < Parse::Embeddings::Error; end
+
+      # Raised when the audit cannot enumerate the classes it is meant
+      # to check. Distinct from {BindingMismatch}: nothing was found to
+      # be wrong, but nothing was verified either.
+      class DiscoveryFailed < Parse::Embeddings::Error; end
+
+      class << self
+        # Verify one property binding against a resolved provider.
+        #
+        # Deliberately NOT memoized. The check is a pair of comparisons
+        # against values already in memory, so caching it saves nothing
+        # measurable — while any cache key cheap enough to be worth
+        # computing (class name, provider object id) can go stale when a
+        # class is unloaded and redefined with a changed declaration, or
+        # when object ids are recycled. A validator that silently skips
+        # after a reload is worse than no validator, so correctness wins
+        # over an optimization with no observable benefit.
+        #
+        # @param klass [Class] the Parse::Object subclass.
+        # @param field [Symbol] the `:vector` property name.
+        # @param provider [Parse::Embeddings::Provider]
+        # @raise [BindingMismatch]
+        # @return [void]
+        def verify!(klass, field, provider)
+          declared = klass.vector_properties[field.to_sym]
+          return if declared.nil?
+
+          check!(klass, field, provider, declared)
+          nil
+        end
+
+        # Audit every declared binding whose provider is registered.
+        # Intended for boot or CI: it surfaces a drifted declaration
+        # before a single embedding is written, rather than on the
+        # first save that happens to touch it.
+        #
+        # @param classes [Array<Class>, nil] defaults to every
+        #   Parse::Object subclass carrying `:vector` properties.
+        # @param strict [Boolean] when true, an unregistered provider
+        #   is itself a failure; otherwise those bindings are skipped
+        #   (a provider may be registered later in boot).
+        # @return [Array<String>] human-readable problems, empty when clean.
+        def audit_all!(classes: nil, strict: false)
+          problems = []
+          begin
+            bindings = collect_bindings(classes)
+          rescue DiscoveryFailed => e
+            return [e.message]
+          end
+
+          bindings.each do |klass, field, declared|
+            provider_name = declared[:provider]
+            next if provider_name.nil?
+
+            begin
+              provider = Parse::Embeddings.provider(provider_name)
+            rescue Parse::Embeddings::ProviderNotRegistered => e
+              problems << "#{klass}##{field}: #{e.message}" if strict
+              next
+            end
+
+            begin
+              check!(klass, field, provider, declared)
+            rescue BindingMismatch => e
+              problems << e.message
+            end
+          end
+          problems
+        end
+
+        # {.audit_all!} that raises instead of returning problems.
+        #
+        # @raise [BindingMismatch] when any binding disagrees.
+        # @return [void]
+        def audit_all_or_raise!(classes: nil, strict: false)
+          problems = audit_all!(classes: classes, strict: strict)
+          return if problems.empty?
+
+          raise BindingMismatch,
+                "Parse::Embeddings binding audit failed:\n  - #{problems.join("\n  - ")}"
+        end
+
+        # Retained as a no-op for callers that invoked it when this
+        # module memoized verdicts.
+        # @return [void]
+        def reset!
+          nil
+        end
+
+        private
+
+        # Read a provider accessor, distinguishing "not implemented"
+        # from a legitimate nil. Returns `:unavailable` for the former
+        # so {#check!} can fail closed rather than skip the comparison.
+        def accessor(provider, method)
+          value = provider.public_send(method)
+          value.nil? ? :unavailable : value
+        rescue NotImplementedError, NoMethodError
+          :unavailable
+        end
+
+        def check!(klass, field, provider, declared)
+          declared_model = declared[:model]
+          if declared_model
+            actual_model = accessor(provider, :model_name)
+            # A declaration states a requirement. A provider that cannot
+            # answer what model it runs cannot satisfy it, so this fails
+            # closed — otherwise a custom provider without `model_name`
+            # would write same-width embeddings that are never checked
+            # against the declaration at all.
+            if actual_model == :unavailable
+              raise BindingMismatch,
+                    "#{klass}##{field} declares model: #{declared_model.inspect} but the " \
+                    "provider registered as #{declared[:provider].inspect} " \
+                    "(#{provider.class}) does not report a usable #model_name, so the " \
+                    "binding cannot be verified. Implement #model_name on the provider, " \
+                    "or drop `model:` from the property to opt out of the check."
+            end
+            if declared_model.to_s != actual_model.to_s
+              raise BindingMismatch,
+                    "#{klass}##{field} declares model: #{declared_model.inspect} but the " \
+                    "provider registered as #{declared[:provider].inspect} is running " \
+                    "#{actual_model.inspect}. Vectors from different models are not " \
+                    "comparable; embedding with the current provider would corrupt this " \
+                    "index. Update the declaration and re-embed, or register the declared " \
+                    "model."
+            end
+          end
+
+          declared_dims = declared[:dimensions]
+          if declared_dims
+            actual_dims = accessor(provider, :dimensions)
+            if actual_dims == :unavailable
+              raise BindingMismatch,
+                    "#{klass}##{field} declares dimensions: #{declared_dims} but the " \
+                    "provider registered as #{declared[:provider].inspect} " \
+                    "(#{provider.class}) does not report a usable #dimensions, so the " \
+                    "binding cannot be verified. #dimensions is required by the provider " \
+                    "protocol."
+            end
+            if declared_dims != actual_dims
+              raise BindingMismatch,
+                    "#{klass}##{field} declares dimensions: #{declared_dims} but the provider " \
+                    "registered as #{declared[:provider].inspect} emits #{actual_dims}-dim " \
+                    "vectors. Fix the declaration or configure the provider's width before " \
+                    "embedding."
+            end
+          end
+          nil
+        end
+
+        def collect_bindings(classes)
+          list = classes || default_classes
+          list.flat_map do |klass|
+            next [] unless klass.respond_to?(:vector_properties)
+            klass.vector_properties.map { |field, declared| [klass, field, declared] }
+          end
+        end
+
+        # Discovery must NOT swallow its own failure: an empty list from
+        # a crashed sweep is indistinguishable from a clean audit, so
+        # `audit_all_or_raise!` would report success having checked
+        # nothing. Failures propagate as {DiscoveryFailed} and
+        # {.audit_all!} converts them into a reported problem.
+        def default_classes
+          return [] unless defined?(Parse::Object)
+          ObjectSpace.each_object(Class).select do |k|
+            k < Parse::Object && k.respond_to?(:vector_properties) &&
+              !k.vector_properties.empty?
+          end
+        rescue StandardError => e
+          raise DiscoveryFailed,
+                "Parse::Embeddings::BindingAudit could not enumerate Parse::Object " \
+                "subclasses (#{e.class}: #{e.message}); the audit checked nothing. " \
+                "Pass `classes:` explicitly to audit a known set."
+        end
+      end
+    end
+  end
+end

data/lib/parse/embeddings/cache.rb

@@ -313,15 +313,15 @@ module Parse
         # to the other poisons the narrower/wider field.
         def key_for(provider, input, input_type)
           model = begin
-            provider.model_name
-          rescue NotImplementedError
-            "unknown"
-          end
+              provider.model_name
+            rescue NotImplementedError
+              "unknown"
+            end
           dims = begin
-            provider.dimensions
-          rescue NotImplementedError
-            "unknown"
-          end
+              provider.dimensions
+            rescue NotImplementedError
+              "unknown"
+            end
           "#{provider.class.name}|#{model}|#{dims}|#{input_type}|#{Digest::SHA256.hexdigest(input.to_s)}"
         end
 
@@ -347,15 +347,15 @@ module Parse
         def instrument_hit(provider, input_type)
           return unless defined?(ActiveSupport::Notifications)
           model = begin
-            provider.model_name
-          rescue NotImplementedError
-            nil
-          end
+              provider.model_name
+            rescue NotImplementedError
+              nil
+            end
           dims = begin
-            provider.dimensions
-          rescue NotImplementedError
-            nil
-          end
+              provider.dimensions
+            rescue NotImplementedError
+              nil
+            end
           payload = {
             provider: provider.class.name,
             model: model,
@@ -366,7 +366,7 @@ module Parse
             cached: true,
             error: nil,
           }
-          ActiveSupport::Notifications.instrument(Provider::AS_NOTIFICATION_NAME, payload) {}
+          ActiveSupport::Notifications.instrument(Provider::AS_NOTIFICATION_NAME, payload) { }
         end
       end
     end