grape 0.1.1 → 2.4.0

data/lib/grape/router/route.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class Route < BaseRoute
+      extend Forwardable
+
+      FORWARD_MATCH_METHOD = ->(input, pattern) { input.start_with?(pattern.origin) }
+      NON_FORWARD_MATCH_METHOD = ->(input, pattern) { pattern.match?(input) }
+
+      attr_reader :app, :request_method
+
+      def_delegators :pattern, :path, :origin
+
+      def initialize(method, origin, path, options)
+        @request_method = upcase_method(method)
+        @pattern = Grape::Router::Pattern.new(origin, path, options)
+        @match_function = options[:forward_match] ? FORWARD_MATCH_METHOD : NON_FORWARD_MATCH_METHOD
+        super(options)
+      end
+
+      def convert_to_head_request!
+        @request_method = Rack::HEAD
+      end
+
+      def exec(env)
+        @app.call(env)
+      end
+
+      def apply(app)
+        @app = app
+        self
+      end
+
+      def match?(input)
+        return false if input.blank?
+
+        @match_function.call(input, pattern)
+      end
+
+      def params(input = nil)
+        return params_without_input if input.blank?
+
+        parsed = pattern.params(input)
+        return {} unless parsed
+
+        parsed.compact.symbolize_keys
+      end
+
+      private
+
+      def params_without_input
+        @params_without_input ||= pattern.captures_default.merge(attributes.params)
+      end
+
+      def upcase_method(method)
+        method_s = method.to_s
+        Grape::HTTP_SUPPORTED_METHODS.detect { |m| m.casecmp(method_s).zero? } || method_s.upcase
+      end
+    end
+  end
+end

data/lib/grape/router.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    attr_reader :map, :compiled
+
+    # Taken from Rails
+    #     normalize_path("/foo")  # => "/foo"
+    #     normalize_path("/foo/") # => "/foo"
+    #     normalize_path("foo")   # => "/foo"
+    #     normalize_path("")      # => "/"
+    #     normalize_path("/%ab")  # => "/%AB"
+    # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
+    def self.normalize_path(path)
+      return +'/' unless path
+
+      # Fast path for the overwhelming majority of paths that don't need to be normalized
+      return path.dup if path == '/' || (path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//})))
+
+      # Slow path
+      encoding = path.encoding
+      path = +"/#{path}"
+      path.squeeze!('/')
+
+      unless path == '/'
+        path.delete_suffix!('/')
+        path.gsub!(/(%[a-f0-9]{2})/) { ::Regexp.last_match(1).upcase }
+      end
+
+      path.force_encoding(encoding)
+    end
+
+    def initialize
+      @neutral_map = []
+      @neutral_regexes = []
+      @map = Hash.new { |hash, key| hash[key] = [] }
+      @optimized_map = Hash.new { |hash, key| hash[key] = // }
+    end
+
+    def compile!
+      return if compiled
+
+      @union = Regexp.union(@neutral_regexes)
+      @neutral_regexes = nil
+      (Grape::HTTP_SUPPORTED_METHODS + ['*']).each do |method|
+        next unless map.key?(method)
+
+        routes = map[method]
+        optimized_map = routes.map.with_index { |route, index| route.to_regexp(index) }
+        @optimized_map[method] = Regexp.union(optimized_map)
+      end
+      @compiled = true
+    end
+
+    def append(route)
+      map[route.request_method] << route
+    end
+
+    def associate_routes(pattern, options)
+      Grape::Router::GreedyRoute.new(pattern, options).then do |greedy_route|
+        @neutral_regexes << greedy_route.to_regexp(@neutral_map.length)
+        @neutral_map << greedy_route
+      end
+    end
+
+    def call(env)
+      with_optimization do
+        response, route = identity(env)
+        response || rotation(env, route)
+      end
+    end
+
+    def recognize_path(input)
+      any = with_optimization { greedy_match?(input) }
+      return if any == default_response
+
+      any.endpoint
+    end
+
+    private
+
+    def identity(env)
+      route = nil
+      response = transaction(env) do |input, method|
+        route = match?(input, method)
+        process_route(route, env) if route
+      end
+      [response, route]
+    end
+
+    def rotation(env, exact_route = nil)
+      response = nil
+      input, method = *extract_input_and_method(env)
+      map[method].each do |route|
+        next if exact_route == route
+        next unless route.match?(input)
+
+        response = process_route(route, env)
+        break unless cascade?(response)
+      end
+      response
+    end
+
+    def transaction(env)
+      input, method = *extract_input_and_method(env)
+
+      # using a Proc is important since `return` will exit the enclosing function
+      cascade_or_return_response = proc do |response|
+        if response
+          cascade?(response).tap do |cascade|
+            return response unless cascade
+
+            # we need to close the body if possible before dismissing
+            response[2].try(:close)
+          end
+        end
+      end
+
+      last_response_cascade = cascade_or_return_response.call(yield(input, method))
+      last_neighbor_route = greedy_match?(input)
+
+      # If last_neighbor_route exists and request method is OPTIONS,
+      # return response by using #call_with_allow_headers.
+      return call_with_allow_headers(env, last_neighbor_route) if last_neighbor_route && method == Rack::OPTIONS && !last_response_cascade
+
+      route = match?(input, '*')
+
+      return last_neighbor_route.options[:endpoint].call(env) if last_neighbor_route && last_response_cascade && route
+
+      last_response_cascade = cascade_or_return_response.call(process_route(route, env)) if route
+
+      return call_with_allow_headers(env, last_neighbor_route) if !last_response_cascade && last_neighbor_route
+
+      nil
+    end
+
+    def process_route(route, env)
+      prepare_env_from_route(env, route)
+      route.exec(env)
+    end
+
+    def make_routing_args(default_args, route, input)
+      args = default_args || { route_info: route }
+      args.merge(route.params(input))
+    end
+
+    def extract_input_and_method(env)
+      input = string_for(env[Rack::PATH_INFO])
+      method = env[Rack::REQUEST_METHOD]
+      [input, method]
+    end
+
+    def with_optimization
+      compile! unless compiled
+      yield || default_response
+    end
+
+    def default_response
+      headers = Grape::Util::Header.new.merge('X-Cascade' => 'pass')
+      [404, headers, ['404 Not Found']]
+    end
+
+    def match?(input, method)
+      @optimized_map[method].match(input) { |m| @map[method].detect { |route| m[route.regexp_capture_index] } }
+    end
+
+    def greedy_match?(input)
+      @union.match(input) { |m| @neutral_map.detect { |route| m[route.regexp_capture_index] } }
+    end
+
+    def call_with_allow_headers(env, route)
+      prepare_env_from_route(env, route)
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = route.options[:allow_header]
+      route.options[:endpoint].call(env)
+    end
+
+    def prepare_env_from_route(env, route)
+      input, = *extract_input_and_method(env)
+      env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(env[Grape::Env::GRAPE_ROUTING_ARGS], route, input)
+    end
+
+    def cascade?(response)
+      response && response[1]['X-Cascade'] == 'pass'
+    end
+
+    def string_for(input)
+      self.class.normalize_path(input)
+    end
+  end
+end

data/lib/grape/serve_stream/file_body.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Grape
+  module ServeStream
+    CHUNK_SIZE = 16_384
+
+    # Class helps send file through API
+    class FileBody
+      attr_reader :path
+
+      # @param path [String]
+      def initialize(path)
+        @path = path
+      end
+
+      # Need for Rack::Sendfile middleware
+      #
+      # @return [String]
+      def to_path
+        path
+      end
+
+      def each
+        File.open(path, 'rb') do |file|
+          while (chunk = file.read(CHUNK_SIZE))
+            yield chunk
+          end
+        end
+      end
+
+      def ==(other)
+        path == other.path
+      end
+    end
+  end
+end

data/lib/grape/serve_stream/sendfile_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module ServeStream
+    # Response should respond to to_path method
+    # for using Rack::SendFile middleware
+    class SendfileResponse < Rack::Response
+      def respond_to?(method_name, include_all = false)
+        if method_name == :to_path
+          @body.respond_to?(:to_path, include_all)
+        else
+          super
+        end
+      end
+
+      def to_path
+        @body.to_path
+      end
+    end
+  end
+end

data/lib/grape/serve_stream/stream_response.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Grape
+  module ServeStream
+    # A simple class used to identify responses which represent streams (or files) and do not
+    # need to be formatted or pre-read by Rack::Response
+    class StreamResponse
+      attr_reader :stream
+
+      # @param stream [Object]
+      def initialize(stream)
+        @stream = stream
+      end
+
+      # Equality provided mostly for tests.
+      #
+      # @return [Boolean]
+      def ==(other)
+        stream == other.stream
+      end
+    end
+  end
+end

data/lib/grape/types/invalid_value.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# only exists to make it shorter for external use
+module Grape
+  module Types
+    InvalidValue = Class.new(Grape::Validations::Types::InvalidValue)
+  end
+end

data/lib/grape/util/base_inheritable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    # Base for classes which need to operate with own values kept
+    # in the hash and inherited values kept in a Hash-like object.
+    class BaseInheritable
+      attr_accessor :inherited_values, :new_values
+
+      # @param inherited_values [Object] An object implementing an interface
+      #   of the Hash class.
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
+        @new_values = {}
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.dup
+      end
+
+      def keys
+        if new_values.any?
+          inherited_values.keys.tap do |combined|
+            combined.concat(new_values.keys)
+            combined.uniq!
+          end
+        else
+          inherited_values.keys
+        end
+      end
+
+      def key?(name)
+        inherited_values.key?(name) || new_values.key?(name)
+      end
+    end
+  end
+end

data/lib/grape/util/cache.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class Cache
+      include Singleton
+
+      attr_reader :cache
+
+      class << self
+        extend Forwardable
+        def_delegators :cache, :[]
+        def_delegators :instance, :cache
+      end
+    end
+  end
+end

data/lib/grape/util/endpoint_configuration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class EndpointConfiguration < Lazy::ValueHash
+    end
+  end
+end

data/lib/grape/util/header.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    if Gem::Version.new(Rack.release) >= Gem::Version.new('3')
+      require 'rack/headers'
+      Header = Rack::Headers
+    else
+      require 'rack/utils'
+      Header = Rack::Utils::HeaderHash
+    end
+  end
+end

data/lib/grape/util/inheritable_setting.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    # A branchable, inheritable settings object which can store both stackable
+    # and inheritable values (see InheritableValues and StackableValues).
+    class InheritableSetting
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
+
+      # Retrieve global settings.
+      def self.global
+        @global ||= {}
+      end
+
+      # Clear all global settings.
+      # @api private
+      # @note only for testing
+      def self.reset_global!
+        @global = {}
+      end
+
+      # Instantiate a new settings instance, with blank values. The fresh
+      # instance can then be set to inherit from an existing instance (see
+      # #inherit_from).
+      def initialize
+        self.route = {}
+        self.api_class = {}
+        self.namespace = InheritableValues.new # only inheritable from a parent when
+        # used with a mount, or should every API::Class be a separate namespace by default?
+        self.namespace_inheritable = InheritableValues.new
+        self.namespace_stackable = StackableValues.new
+        self.namespace_reverse_stackable = ReverseStackableValues.new
+
+        self.point_in_time_copies = []
+
+        self.parent = nil
+      end
+
+      # Return the class-level global properties.
+      def global
+        self.class.global
+      end
+
+      # Set our inherited values to the given parent's current values. Also,
+      # update the inherited values on any settings instances which were forked
+      # from us.
+      # @param parent [InheritableSetting]
+      def inherit_from(parent)
+        return if parent.nil?
+
+        self.parent = parent
+
+        namespace_inheritable.inherited_values = parent.namespace_inheritable
+        namespace_stackable.inherited_values = parent.namespace_stackable
+        namespace_reverse_stackable.inherited_values = parent.namespace_reverse_stackable
+        self.route = parent.route.merge(route)
+
+        point_in_time_copies.map { |cloned_one| cloned_one.inherit_from parent }
+      end
+
+      # Create a point-in-time copy of this settings instance, with clones of
+      # all our values. Note that, should this instance's parent be set or
+      # changed via #inherit_from, it will copy that inheritence to any copies
+      # which were made.
+      def point_in_time_copy
+        self.class.new.tap do |new_setting|
+          point_in_time_copies << new_setting
+          new_setting.point_in_time_copies = []
+
+          new_setting.namespace = namespace.clone
+          new_setting.namespace_inheritable = namespace_inheritable.clone
+          new_setting.namespace_stackable = namespace_stackable.clone
+          new_setting.namespace_reverse_stackable = namespace_reverse_stackable.clone
+          new_setting.route = route.clone
+          new_setting.api_class = api_class
+
+          new_setting.inherit_from(parent)
+        end
+      end
+
+      # Resets the instance store of per-route settings.
+      # @api private
+      def route_end
+        @route = {}
+      end
+
+      # Return a serializable hash of our values.
+      def to_hash
+        {
+          global: global.clone,
+          route: route.clone,
+          namespace: namespace.to_hash,
+          namespace_inheritable: namespace_inheritable.to_hash,
+          namespace_stackable: namespace_stackable.to_hash,
+          namespace_reverse_stackable: namespace_reverse_stackable.to_hash
+        }
+      end
+    end
+  end
+end

data/lib/grape/util/inheritable_values.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class InheritableValues < BaseInheritable
+      def [](name)
+        values[name]
+      end
+
+      def []=(name, value)
+        new_values[name] = value
+      end
+
+      def merge(new_hash)
+        values.merge!(new_hash)
+      end
+
+      def to_hash
+        values
+      end
+
+      protected
+
+      def values
+        @inherited_values.merge(@new_values)
+      end
+    end
+  end
+end

data/lib/grape/util/lazy/block.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Block
+        def initialize(&new_block)
+          @block = new_block
+        end
+
+        def evaluate_from(configuration)
+          @block.call(configuration)
+        end
+
+        def evaluate
+          @block.call({})
+        end
+
+        def lazy?
+          true
+        end
+
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/lazy/value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Value
+        attr_reader :access_keys
+
+        def initialize(value, access_keys = [])
+          @value = value
+          @access_keys = access_keys
+        end
+
+        def evaluate_from(configuration)
+          matching_lazy_value = configuration.fetch(@access_keys)
+          matching_lazy_value.evaluate
+        end
+
+        def evaluate
+          @value
+        end
+
+        def lazy?
+          true
+        end
+
+        def reached_by(parent_access_keys, access_key)
+          @access_keys = parent_access_keys + [access_key]
+          self
+        end
+
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/lazy/value_array.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueArray < ValueEnumerable
+        def initialize(array)
+          super
+          @value_hash = []
+          array.each_with_index do |value, index|
+            self[index] = value
+          end
+        end
+
+        def evaluate
+          @value_hash.map(&:evaluate)
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/lazy/value_enumerable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueEnumerable < Value
+        def [](key)
+          if @value_hash[key].nil?
+            Value.new(nil).reached_by(access_keys, key)
+          else
+            @value_hash[key].reached_by(access_keys, key)
+          end
+        end
+
+        def fetch(access_keys)
+          fetched_keys = access_keys.dup
+          value = self[fetched_keys.shift]
+          fetched_keys.any? ? value.fetch(fetched_keys) : value
+        end
+
+        def []=(key, value)
+          @value_hash[key] = case value
+                             when Hash
+                               ValueHash.new(value)
+                             when Array
+                               ValueArray.new(value)
+                             else
+                               Value.new(value)
+                             end
+        end
+      end
+    end
+  end
+end