grape 2.4.0 → 4.0.1

data/lib/grape/serve_stream/stream_response.rb

@@ -18,6 +18,13 @@ module Grape
       def ==(other)
         stream == other.stream
       end
+      alias eql? ==
+
+      # Mirrors #==, which keys on the stream alone and does not check the
+      # class, so the class must stay out of the hash too.
+      def hash
+        stream.hash
+      end
     end
   end
 end

data/lib/grape/testing.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Grape
+  module Testing
+    module RunBeforeEach
+      def run
+        self.class.run_before_each(self)
+        super
+      end
+    end
+
+    module ClassMethods
+      def before_each(&block)
+        raise ArgumentError, 'a block is required' unless block
+
+        @before_each ||= []
+        @before_each << block
+      end
+
+      def reset_before_each
+        @before_each&.clear
+      end
+
+      def run_before_each(endpoint)
+        superclass.run_before_each(endpoint) unless self == Grape::Endpoint
+        @before_each&.each { |blk| blk.call(endpoint) }
+      end
+    end
+
+    Grape::Endpoint.prepend(RunBeforeEach)
+    Grape::Endpoint.extend(ClassMethods)
+  end
+end

data/lib/grape/util/api_description.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class ApiDescription
+      DSL_METHODS = %i[
+        body_name
+        consumes
+        default_response
+        deprecated
+        detail
+        entity
+        headers
+        hidden
+        http_codes
+        is_array
+        named
+        nickname
+        params
+        produces
+        security
+        summary
+        tags
+      ].freeze
+
+      def initialize(description, endpoint_configuration, &)
+        @endpoint_configuration = endpoint_configuration
+        @attributes = { description: }
+        instance_eval(&)
+      end
+
+      DSL_METHODS.each do |attribute|
+        define_method attribute do |value|
+          @attributes[attribute] = value
+        end
+      end
+
+      alias success entity
+      alias failure http_codes
+
+      # @deprecated Use {#default_response}. The description is read back
+      #   through an ActiveSupport::OrderedOptions, where +default+ is
+      #   +Hash#default+ rather than a key lookup, and grape-swagger has always
+      #   asked the route for +default_response+.
+      def default(value)
+        Grape.deprecator.warn('`default` in a `desc` block is deprecated. Use `default_response` instead.')
+        default_response(value)
+      end
+
+      def configuration
+        @configuration ||= eval_endpoint_config(@endpoint_configuration)
+      end
+
+      def settings
+        @attributes
+      end
+
+      private
+
+      def eval_endpoint_config(configuration)
+        return configuration if configuration.is_a?(Hash)
+
+        configuration.evaluate
+      end
+    end
+  end
+end

data/lib/grape/util/cache.rb

@@ -2,15 +2,35 @@
 
 module Grape
   module Util
+    # Base class for the lazily-filled lookup caches (coercers, dry-types,
+    # path parts, ...). Subclasses assign a default-block +Hash+ to +@cache+
+    # in their +initialize+.
+    #
+    # Lookups are synchronized: caches are written at API *definition* time
+    # (a +params+ block runs when the class body is evaluated), which is not
+    # covered by the compile-time +Grape::API::Instance::LOCK+ and can happen
+    # concurrently — e.g. parallel eager loading, or two threads autoloading
+    # different API files. A +Monitor+ (reentrant) rather than a +Mutex+,
+    # because a cache miss may re-enter the same cache: building a
+    # multiple-type coercer through +Types::CoercerCache+ builds its member
+    # coercers through +Types.build_coercer+, which lands in the same cache.
     class Cache
       include Singleton
 
       attr_reader :cache
 
+      def initialize
+        @monitor = Monitor.new
+      end
+
+      def [](key)
+        @monitor.synchronize { @cache[key] }
+      end
+
       class << self
         extend Forwardable
-        def_delegators :cache, :[]
-        def_delegators :instance, :cache
+
+        def_delegators :instance, :[], :cache
       end
     end
   end

data/lib/grape/util/deep_freeze.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module DeepFreeze
+      module_function
+
+      # Recursively freezes Hash (keys and values), Array (elements), and String
+      # objects. All other types are returned as-is.
+      #
+      # Intentionally left unfrozen:
+      #   - Procs / lambdas — may be deferred DB-backed callables
+      #   - Classes / Modules — shared constants that must remain open
+      #   - Coercers and ParamsScope — self-freeze at construction
+      def deep_freeze(obj)
+        case obj
+        when Hash
+          obj.each do |k, v|
+            deep_freeze(k)
+            deep_freeze(v)
+          end
+          obj.freeze
+        when Array
+          obj.each { |v| deep_freeze(v) }
+          obj.freeze
+        when String
+          obj.freeze
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/freeze_on_new.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    # Extend into a class whose instances are shared across requests:
+    # +new+ returns a frozen instance, so any later ivar write — e.g.
+    # request-time memoization — raises FrozenError instead of being a
+    # latent data race.
+    #
+    # Must stay a +new+ wrapper (never an +initialize+ wrapper): the freeze
+    # runs after the entire initialize chain, so subclasses may assign ivars
+    # after +super+. Extending a hierarchy base covers its subclasses —
+    # singleton classes inherit along the class hierarchy.
+    module FreezeOnNew
+      def new(...)
+        super.freeze
+      end
+    end
+  end
+end