grape 1.8.0 → 4.0.1

data/lib/grape/dsl/settings.rb

@@ -7,172 +7,66 @@ module Grape
     # matter where they're defined, and inheritable settings which apply only
     # in the current scope and scopes nested under it.
     module Settings
-      extend ActiveSupport::Concern
-
-      attr_writer :inheritable_setting, :top_level_setting
+      attr_writer :inheritable_setting
 
       # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting
-        @top_level_setting ||= build_top_level_setting
+        return @top_level_setting if @top_level_setting
+
+        @top_level_setting = Grape::Util::InheritableSetting.new
+        # Doesn't try to inherit settings from +Grape::API::Instance+ which also responds to
+        # +inheritable_setting+, however, it doesn't contain any user-defined settings.
+        # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
+        # in the chain for every endpoint.
+        @top_level_setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
+        @top_level_setting
       end
 
       # Fetch our current inheritable settings, which are inherited by
       # nested scopes but not shared across siblings.
       def inheritable_setting
-        @inheritable_setting ||= Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from top_level_setting }
-      end
+        return @inheritable_setting if @inheritable_setting
 
-      # @param type [Symbol]
-      # @param key [Symbol]
-      def unset(type, key)
-        setting = inheritable_setting.send(type)
-        setting.delete key
+        @inheritable_setting = Grape::Util::InheritableSetting.new
+        @inheritable_setting.inherit_from top_level_setting
+        @inheritable_setting
       end
 
-      # @param type [Symbol]
-      # @param key [Symbol]
-      # @param value [Object] will be stored if the value is currently empty
-      # @return either the old value, if it wasn't nil, or the given value
-      def get_or_set(type, key, value)
-        setting = inheritable_setting.send(type)
-        if value.nil?
-          setting[key]
-        else
-          setting[key] = value
-        end
-      end
-
-      # @param key [Symbol]
-      # @param value [Object]
-      # @return (see #get_or_set)
       def global_setting(key, value = nil)
-        get_or_set :global, key, value
-      end
-
-      # @param key [Symbol]
-      def unset_global_setting(key)
-        unset :global, key
+        get_or_set(inheritable_setting.global, key, value)
       end
 
-      # (see #global_setting)
       def route_setting(key, value = nil)
-        get_or_set :route, key, value
-      end
-
-      # (see #unset_global_setting)
-      def unset_route_setting(key)
-        unset :route, key
+        inheritable_setting.route_setting(key, value)
       end
 
-      # (see #global_setting)
       def namespace_setting(key, value = nil)
-        get_or_set :namespace, key, value
+        get_or_set(inheritable_setting.namespace, key, value)
       end
 
-      # (see #unset_global_setting)
-      def unset_namespace_setting(key)
-        unset :namespace, key
-      end
-
-      # (see #global_setting)
-      def namespace_inheritable(key, value = nil)
-        get_or_set :namespace_inheritable, key, value
-      end
-
-      # (see #unset_global_setting)
-      def unset_namespace_inheritable(key)
-        unset :namespace_inheritable, key
-      end
-
-      # @param key [Symbol]
-      def namespace_inheritable_to_nil(key)
-        inheritable_setting.namespace_inheritable[key] = nil
-      end
-
-      # (see #global_setting)
-      def namespace_stackable(key, value = nil)
-        get_or_set :namespace_stackable, key, value
-      end
-
-      def namespace_reverse_stackable(key, value = nil)
-        get_or_set :namespace_reverse_stackable, key, value
-      end
-
-      def namespace_stackable_with_hash(key)
-        settings = get_or_set :namespace_stackable, key, nil
-        return if settings.blank?
-
-        settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
-      end
-
-      def namespace_reverse_stackable_with_hash(key)
-        settings = get_or_set :namespace_reverse_stackable, key, nil
-        return if settings.blank?
-
-        settings.each_with_object({}) do |setting, result|
-          result.merge!(setting) { |_k, s1, _s2| s1 }
-        end
-      end
-
-      # (see #unset_global_setting)
-      def unset_namespace_stackable(key)
-        unset :namespace_stackable, key
-      end
-
-      # (see #global_setting)
-      def api_class_setting(key, value = nil)
-        get_or_set :api_class, key, value
-      end
-
-      # (see #unset_global_setting)
-      def unset_api_class_setting(key)
-        unset :api_class, key
-      end
-
-      # Fork our inheritable settings to a new instance, copied from our
-      # parent's, but separate so we won't modify it. Every call to this
-      # method should have an answering call to #namespace_end.
-      def namespace_start
-        @inheritable_setting = Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from inheritable_setting }
-      end
-
-      # Set the inheritable settings pointer back up by one level.
-      def namespace_end
-        route_end
-        @inheritable_setting = inheritable_setting.parent
-      end
-
-      # Stop defining settings for the current route and clear them for the
-      # next, within a namespace.
-      def route_end
-        inheritable_setting.route_end
-      end
+      private
 
       # Execute the block within a context where our inheritable settings are forked
       # to a new copy (see #namespace_start).
-      def within_namespace(&block)
-        namespace_start
+      def within_namespace
+        new_inheritable_settings = Grape::Util::InheritableSetting.new
+        new_inheritable_settings.inherit_from inheritable_setting
+
+        @inheritable_setting = new_inheritable_settings
 
-        result = yield if block
+        result = yield
 
-        namespace_end
+        inheritable_setting.route_end
+        @inheritable_setting = inheritable_setting.parent
         reset_validations!
 
         result
       end
 
-      private
+      def get_or_set(setting, key, value)
+        return setting[key] if value.nil?
 
-      # Builds the current class :inheritable_setting. If available, it inherits from
-      # the superclass's :inheritable_setting.
-      def build_top_level_setting
-        Grape::Util::InheritableSetting.new.tap do |setting|
-          # Doesn't try to inherit settings from +Grape::API::Instance+ which also responds to
-          # +inheritable_setting+, however, it doesn't contain any user-defined settings.
-          # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
-          # in the chain for every endpoint.
-          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
-        end
+        setting[key] = value
       end
     end
   end

data/lib/grape/dsl/validations.rb

@@ -3,41 +3,48 @@
 module Grape
   module DSL
     module Validations
-      extend ActiveSupport::Concern
+      # Opens a root-level ParamsScope, defining parameter coercions and
+      # validations for the endpoint.
+      # @yield instance context of the new scope
+      def params(&)
+        Grape::Validations::ParamsScope.new(api: self, type: Hash, &)
+      end
+
+      # Declare the contract to be used for the endpoint's parameters.
+      # @param contract [Class<Dry::Validation::Contract> | Dry::Schema::Processor]
+      #   The contract or schema to be used for validation. Optional.
+      # @yield a block yielding a new instance of Dry::Schema::Params
+      #   subclass, allowing to define the schema inline. When the
+      #   +contract+ parameter is a schema, it will be used as a parent. Optional.
+      def contract(contract = nil, &block)
+        raise ArgumentError, 'either contract or block must be provided' unless contract || block
+        raise ArgumentError, 'cannot inherit from contract, only schema' if block && contract.respond_to?(:schema)
 
-      include Grape::DSL::Configuration
+        Grape::Validations::ContractScope.new(self, contract, &block)
+      end
 
-      module ClassMethods
-        # Clears all defined parameters and validations. The main purpose of it is to clean up
-        # settings, so next endpoint won't interfere with previous one.
-        #
-        #    params do
-        #      # params for the endpoint below this block
-        #    end
-        #    post '/current' do
-        #      # whatever
-        #    end
-        #
-        #    # somewhere between them the reset_validations! method gets called
-        #
-        #    params do
-        #      # params for the endpoint below this block
-        #    end
-        #    post '/next' do
-        #      # whatever
-        #    end
-        def reset_validations!
-          unset_namespace_stackable :declared_params
-          unset_namespace_stackable :validations
-          unset_namespace_stackable :params
-        end
+      private
 
-        # Opens a root-level ParamsScope, defining parameter coercions and
-        # validations for the endpoint.
-        # @yield instance context of the new scope
-        def params(&block)
-          Grape::Validations::ParamsScope.new(api: self, type: Hash, &block)
-        end
+      # Clears all defined parameters and validations. The main purpose of it is to clean up
+      # settings, so next endpoint won't interfere with previous one.
+      #
+      #    params do
+      #      # params for the endpoint below this block
+      #    end
+      #    post '/current' do
+      #      # whatever
+      #    end
+      #
+      #    # somewhere between them the reset_validations! method gets called
+      #
+      #    params do
+      #      # params for the endpoint below this block
+      #    end
+      #    post '/next' do
+      #      # whatever
+      #    end
+      def reset_validations!
+        inheritable_setting.reset_validations!
       end
     end
   end

data/lib/grape/dsl/version_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    # Immutable value object holding the resolved options from
+    # +Grape::DSL::Routing#version+. Stored on the inheritable settings as
+    # +Grape::Util::InheritableSetting#version_options+ and read by internal call
+    # sites (`Path`, `Endpoint`, `API::Instance#cascade?`,
+    # `Middleware::Versioner::Base`) via accessors.
+    #
+    # Defaults are duplicated on +#initialize+ here and on +#version+'s
+    # signature on purpose: keeping them on both sides means each entry point
+    # is self-documenting without needing to import a shared constant — the
+    # DSL signature shows what a user sees in the IDE, and the Data object
+    # has working defaults when constructed directly (spec fixtures, a
+    # middleware built by hand). The two must stay in lockstep.
+    VersionOptions = Data.define(:using, :cascade, :parameter, :strict, :vendor) do
+      def initialize(using: :path, cascade: true, parameter: 'apiver', strict: false, vendor: nil)
+        super
+      end
+    end
+  end
+end

data/lib/grape/endpoint/options.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Grape
+  class Endpoint
+    # Immutable value object holding the keyword inputs passed to
+    # +Grape::Endpoint.new+. Internal to {Grape::Endpoint}, which builds it
+    # from the +**options+ Hash in #initialize so the public +options+ reader
+    # stays a plain Hash for downstream gems (e.g. grape-swagger).
+    Options = Data.define(:path, :http_methods, :api, :route_options, :app, :params, :requirements, :anchor) do
+      def initialize(path:, http_methods:, api:, route_options: {}, app: nil, params: {}, requirements: nil, anchor: true)
+        # +Array()+ hands back the very Array it was given, so defaulting an
+        # empty one by appending would append to the caller's Array — and raise
+        # FrozenError on a frozen one. Build a new Array instead of growing
+        # theirs: nothing about constructing an endpoint should be visible in
+        # the path the caller passed in.
+        paths = Array(path)
+        super(
+          path: paths.presence || ['/'],
+          http_methods: Array(http_methods),
+          api:, route_options:, app:, params:, requirements:, anchor:
+        )
+      end
+    end
+  end
+end