grape 1.8.0 → 4.0.1

data/lib/grape/validations/oneof_collector.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Stand-in for the +@api+ object that {ParamsScope} normally writes to.
+    # Used when evaluating a single variant block of a +oneof:+ schema so that
+    # the variant's validators are captured locally rather than registered on
+    # the real API. Exposes only the slice of the API surface that
+    # ParamsScope and its helpers touch during definition.
+    class OneofCollector
+      extend Forwardable
+
+      attr_reader :inheritable_setting
+
+      def_delegator :@inheritable_setting, :validations
+
+      def initialize
+        @inheritable_setting = Grape::Util::InheritableSetting.new
+        @inheritable_setting.do_not_document!
+      end
+
+      def configuration
+        nil
+      end
+
+      # Evaluate +variant_block+ in a fresh +ParamsScope+ backed by a new
+      # collector and return the validators that the block registered.
+      def self.collect(variant_block)
+        collector = new
+        ParamsScope.new(api: collector, type: Hash, &variant_block)
+        collector.validations
+      end
+    end
+  end
+end

data/lib/grape/validations/param_scope_tracker.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Holds per-request mutable state that must not live on shared ParamsScope
+    # instances. Both trackers are identity-keyed hashes so that ParamsScope
+    # objects can serve as keys without relying on value equality.
+    #
+    # Lifecycle is managed by Endpoint#run_validators via +.track+.
+    # Use +.current+ to access the instance for the running request.
+    class ParamScopeTracker
+      # Fiber-local key used to store the current tracker.
+      # Fiber[] (Ruby 3.0+) is used instead of Thread.current[] so that
+      # fiber-based servers (e.g. Falcon with async) isolate each request's
+      # tracker within its own fiber rather than sharing state across all
+      # fibers running on the same thread.
+      FIBER_KEY = :grape_param_scope_tracker
+      EMPTY_PARAMS = [].freeze
+
+      def self.track
+        previous = Fiber[FIBER_KEY]
+        Fiber[FIBER_KEY] = new
+        yield
+      ensure
+        Fiber[FIBER_KEY] = previous
+      end
+
+      def self.current
+        Fiber[FIBER_KEY]
+      end
+
+      def store_index(scope, index)
+        index_tracker.store(scope, index)
+      end
+
+      def index_for(scope)
+        index_tracker[scope]
+      end
+
+      # Returns qualifying params for +scope+, or EMPTY_PARAMS if none were stored.
+      # Note: an explicitly stored empty array and "never stored" are treated identically
+      # by callers (both yield a blank result that falls through to the parent params).
+      def qualifying_params(scope)
+        qualifying_params_tracker.fetch(scope, EMPTY_PARAMS)
+      end
+
+      def store_qualifying_params(scope, params)
+        qualifying_params_tracker.store(scope, params)
+      end
+
+      private
+
+      def index_tracker
+        @index_tracker ||= {}.compare_by_identity
+      end
+
+      def qualifying_params_tracker
+        @qualifying_params_tracker ||= {}.compare_by_identity
+      end
+    end
+  end
+end

data/lib/grape/validations/params_documentation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Documents parameters of an endpoint. Reads from a frozen
+    # +ValidationsSpec+; never mutates the user's validations hash.
+    module ParamsDocumentation
+      def document_params(attrs, spec)
+        return if @api.inheritable_setting.do_not_document?
+
+        documented_attrs = attrs.to_h do |name|
+          [full_name(name), extract_details(spec)]
+        end
+        @api.inheritable_setting.add_params_documentation(documented_attrs)
+      end
+
+      private
+
+      def extract_details(spec)
+        details = {}
+        details[:required] = spec.required?
+        details[:type] = TypeCache[spec.coerce_type] if spec.coerce_type
+        details[:values] = spec.values if spec.values
+        details[:except_values] = spec.except_values if spec.except_values
+        details[:default] = spec.default unless spec.default.nil?
+
+        length = spec.raw[:length]
+        if length.is_a?(Hash)
+          details[:min_length] = length[:min] if length.key?(:min)
+          details[:max_length] = length[:max] if length.key?(:max)
+        end
+
+        desc = spec.raw[:desc] || spec.raw[:description]
+        details[:desc] = desc if desc
+
+        documentation = spec.raw[:documentation]
+        details[:documentation] = documentation if documentation
+
+        details
+      end
+
+      class TypeCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, type|
+            h[type] = type.to_s
+          end
+        end
+      end
+    end
+  end
+end