Makes #declared unavailable to before filters

In response to issue ruby-grape#1074

This adds a mechanism by which Grape::DSL::InsideRoute methods may be
overriden after certain filters are run.

The first problem case of a filter being utilized before it should that
necessitated this enhancement is the `#declared` method, which was
returning un-coerced params in `before` filters.

There may be other problem cases, which may be rectified using this same
mechanism.

README.md

@@ -534,6 +534,10 @@ The returned hash is a `Hashie::Mash` instance, allowing you to access parameter
   declared(params).user == declared(params)["user"]
 ```
 
+
+`#declared` is not available to `before` filters, as those are evaluated prior
+to parameter coercion.
+
 ### Include missing
 
 By default `declared(params)` includes parameters that have `nil` values. If you want to return only the parameters that are not `nil`, you can use the `include_missing` option. By default, `include_missing` is set to `true`. Consider the following API:

lib/grape/dsl/inside_route.rb

@@ -6,49 +6,77 @@ module InsideRoute
       extend ActiveSupport::Concern
       include Grape::DSL::Settings
 
-      # A filtering method that will return a hash
-      # consisting only of keys that have been declared by a
-      # `params` statement against the current/target endpoint or parent
-      # namespaces.
+      # Denotes a situation where a DSL method has been invoked in a
+      # filter which it should not yet be available in
+      class MethodNotYetAvailable < StandardError; end
+
+      # Returns a module which may be extended by an instance of a class
+      # including this module.  This allows these DSL methods to be redefined
+      # as filters are evaluated.
       #
-      # @param params [Hash] The initial hash to filter. Usually this will just be `params`
-      # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces`
-      # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
-      # you want only to return params declared against the current/target endpoint.
-      def declared(params, options = {}, declared_params = nil)
-        options[:include_missing] = true unless options.key?(:include_missing)
-        options[:include_parent_namespaces] = true unless options.key?(:include_parent_namespaces)
+      # @param type [Symbol] The type of filter for which evaluation has been
+      #   completed
+      # @return [Module] A module containing method overrides suitable for the
+      #   position in the filter evaluation sequence denoted by +type+.  This
+      #   defaults to an empty module if no overrides are defined for the given
+      #   filter +type+.
+      def self.post_filter_methods(type)
+        @post_filter_modules ||= { before: PostBeforeFilter }
+        @post_filter_modules[type] || Module.new
+      end
 
-        declared_params ||= (!options[:include_parent_namespaces] ? route_setting(:declared_params) : (route_setting(:saved_declared_params) || [])).flatten(1) || []
+      # Methods which should not be available in filters until the before filter
+      # has completed
+      module PostBeforeFilter
+        def declared(params, options = {}, declared_params = nil)
+          options[:include_missing] = true unless options.key?(:include_missing)
+          options[:include_parent_namespaces] = true unless options.key?(:include_parent_namespaces)
 
-        fail ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
+          declared_params ||= (!options[:include_parent_namespaces] ? route_setting(:declared_params) : (route_setting(:saved_declared_params) || [])).flatten(1) || []
 
-        if params.is_a? Array
-          params.map do |param|
-            declared(param || {}, options, declared_params)
-          end
-        else
-          declared_params.inject(Hashie::Mash.new) do |hash, key|
-            key = { key => nil } unless key.is_a? Hash
+          fail ArgumentError, 'Tried to filter for declared parameters but none exist.' unless declared_params
+
+          if params.is_a? Array
+            params.map do |param|
+              declared(param || {}, options, declared_params)
+            end
+          else
+            declared_params.inject(Hashie::Mash.new) do |hash, key|
+              key = { key => nil } unless key.is_a? Hash
 
-            key.each_pair do |parent, children|
-              output_key = options[:stringify] ? parent.to_s : parent.to_sym
+              key.each_pair do |parent, children|
+                output_key = options[:stringify] ? parent.to_s : parent.to_sym
 
-              next unless options[:include_missing] || params.key?(parent)
+                next unless options[:include_missing] || params.key?(parent)
 
-              hash[output_key] = if children
-                                   children_params = params[parent] || (children.is_a?(Array) ? [] : {})
-                                   declared(children_params, options, Array(children))
-                                 else
-                                   params[parent]
-                                 end
-            end
+                hash[output_key] = if children
+                                     children_params = params[parent] || (children.is_a?(Array) ? [] : {})
+                                     declared(children_params, options, Array(children))
+                                   else
+                                     params[parent]
+                                   end
+              end
 
-            hash
+              hash
+            end
           end
         end
       end
 
+      # A filtering method that will return a hash
+      # consisting only of keys that have been declared by a
+      # `params` statement against the current/target endpoint or parent
+      # namespaces.
+      #
+      # @param params [Hash] The initial hash to filter. Usually this will just be `params`
+      # @param options [Hash] Can pass `:include_missing`, `:stringify` and `:include_parent_namespaces`
+      # options. `:include_parent_namespaces` defaults to true, hence must be set to false if
+      # you want only to return params declared against the current/target endpoint.
+      def declared(*params)
+        raise MethodNotYetAvailable,
+          "#declared is not available prior to parameter validation."
+      end
+
       # The API version as specified in the URL.
       def version
         env[Grape::Env::API_VERSION]

lib/grape/endpoint.rb

@@ -235,8 +235,6 @@ def run(env)
         # Retrieve validations from this namespace and all parent namespaces.
         validation_errors = []
 
-        # require 'pry-byebug'; binding.pry
-
         route_setting(:saved_validations).each do |validator|
           begin
             validator.validate!(params)
@@ -319,6 +317,7 @@ def run_filters(filters, type = :other)
           instance_eval(&filter)
         end
       end
+      extend DSL::InsideRoute.post_filter_methods(type)
     end
 
     def befores

spec/grape/dsl/inside_route_spec.rb

@@ -343,8 +343,9 @@ def initialize
       describe '#declared' do
         # see endpoint_spec.rb#declared for spec coverage
 
-        it 'returns an empty hash' do
-          expect(subject.declared({})).to eq({})
+        it 'is not available by default' do
+          expect { subject.declared({}) }.to raise_error(
+            Grape::DSL::InsideRoute::MethodNotYetAvailable)
         end
       end
     end

spec/grape/endpoint_spec.rb

@@ -239,6 +239,16 @@ def app
       end
     end
 
+    it 'does not work in a before filter' do
+      subject.before do
+        declared(params)
+      end
+      subject.get('/declared'){ declared(params) }
+
+      expect { get('/declared') }.to raise_error(
+        Grape::DSL::InsideRoute::MethodNotYetAvailable)
+    end
+
     it 'has as many keys as there are declared params' do
       inner_params = nil
       subject.get '/declared' do