grape 2.0.0 → 2.1.3

data/lib/grape/router/attribute_translator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  class Router
-    # this could be an OpenStruct, but doesn't work in Ruby 2.3.0, see https://bugs.ruby-lang.org/issues/12251
-    class AttributeTranslator
-      attr_reader :attributes
-
-      ROUTE_ATTRIBUTES = %i[
-        prefix
-        version
-        settings
-        format
-        description
-        http_codes
-        headers
-        entity
-        details
-        requirements
-        request_method
-        namespace
-      ].freeze
-
-      ROUTER_ATTRIBUTES = %i[pattern index].freeze
-
-      def initialize(**attributes)
-        @attributes = attributes
-      end
-
-      (ROUTER_ATTRIBUTES + ROUTE_ATTRIBUTES).each do |attr|
-        define_method attr do
-          attributes[attr]
-        end
-      end
-
-      def to_h
-        attributes
-      end
-
-      def method_missing(method_name, *args)
-        if setter?(method_name[-1])
-          attributes[method_name[0..]] = *args
-        else
-          attributes[method_name]
-        end
-      end
-
-      def respond_to_missing?(method_name, _include_private = false)
-        if setter?(method_name[-1])
-          true
-        else
-          @attributes.key?(method_name)
-        end
-      end
-
-      private
-
-      def setter?(method_name)
-        method_name[-1] == '='
-      end
-    end
-  end
-end

data/lib/grape/util/lazy_block.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    class LazyBlock
-      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

data/lib/grape/util/lazy_object.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-# Based on https://github.com/HornsAndHooves/lazy_object
-
-module Grape
-  module Util
-    class LazyObject < BasicObject
-      attr_reader :callable
-
-      def initialize(&callable)
-        @callable = callable
-      end
-
-      def __target_object__
-        @__target_object__ ||= callable.call
-      end
-
-      def ==(other)
-        __target_object__ == other
-      end
-
-      def !=(other)
-        __target_object__ != other
-      end
-
-      def !
-        !__target_object__
-      end
-
-      def method_missing(method_name, *args, &block)
-        if __target_object__.respond_to?(method_name)
-          __target_object__.send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, include_priv = false)
-        __target_object__.respond_to?(method_name, include_priv)
-      end
-    end
-  end
-end

data/lib/grape/util/lazy_value.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Util
-    class LazyValue
-      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
-
-    class LazyValueEnumerable < LazyValue
-      def [](key)
-        if @value_hash[key].nil?
-          LazyValue.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
-                             LazyValueHash.new(value)
-                           when Array
-                             LazyValueArray.new(value)
-                           else
-                             LazyValue.new(value)
-                           end
-      end
-    end
-
-    class LazyValueArray < LazyValueEnumerable
-      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
-
-    class LazyValueHash < LazyValueEnumerable
-      def initialize(hash)
-        super
-        @value_hash = ActiveSupport::HashWithIndifferentAccess.new
-        hash.each do |key, value|
-          self[key] = value
-        end
-      end
-
-      def evaluate
-        @value_hash.transform_values(&:evaluate)
-      end
-    end
-  end
-end