Refactor param parsers

Author: numbata

lib/grape-swagger/request_param_parser_registry.rb

@@ -19,25 +19,30 @@ def initialize
     end
 
     def register(klass)
+      remove_parser(klass)
       @parsers << klass
     end
 
     def insert_before(before_klass, klass)
-      insert_at = @parsers.index(before_klass)
-      insert_at = @parsers.length - 1 if insert_at.nil?
+      remove_parser(klass)
+      insert_at = @parsers.index(before_klass) || @parsers.size
       @parsers.insert(insert_at, klass)
     end
 
     def insert_after(after_klass, klass)
+      remove_parser(klass)
       insert_at = @parsers.index(after_klass)
-      insert_at = @parsers.length - 1 if insert_at.nil?
-      @parsers.insert(insert_at + 1, klass)
+      @parsers.insert(insert_at ? insert_at + 1 : @parsers.size, klass)
     end
 
-    def each
-      @parsers.each do |klass|
-        yield klass
-      end
+    def each(&)
+      @parsers.each(&)
+    end
+
+    private
+
+    def remove_parser(klass)
+      @parsers.reject! { |k| k == klass }
     end
   end
 end

lib/grape-swagger/request_param_parsers/body.rb

@@ -18,10 +18,9 @@ def initialize(_route, params, settings, endpoint)
       def parse
         public_params.each_with_object({}) do |(name, options), memo|
           name = name.to_s
-          param_type = options[:type]
-          param_type = param_type.to_s unless param_type.nil?
+          param_type = options[:type]&.to_s
 
-          if param_type_is_array?(param_type)
+          if array_param?(param_type)
             options[:is_array] = true
             name += '[]' if array_use_braces?
           end
@@ -36,8 +35,8 @@ def array_use_braces?
         @array_use_braces ||= settings[:array_use_braces] && !includes_body_param?
       end
 
-      def param_type_is_array?(param_type)
-        return false unless param_type
+      def array_param?(param_type)
+        return false if param_type.nil?
         return true if param_type == 'Array'
 
         param_types = param_type.match(/\[(.*)\]$/)

lib/grape-swagger/request_param_parsers/headers.rb

@@ -17,18 +17,15 @@ def parse
         return {} unless route.headers
 
         route.headers.each_with_object({}) do |(name, definition), accum|
-          params = {
-            documentation: {
-              desc: definition['description'] || definition[:description],
-              in: 'header'
-            }
-          }
-          params[:type] = definition[:type].titleize if definition[:type]
+          # Extract the description from any key type (string or symbol)
+          description = definition[:description] || definition['description']
+          doc = { desc: description, in: 'header' }
 
-          accum[name] = definition
-                        .symbolize_keys
-                        .except(:description, 'description')
-                        .merge(params)
+          header_attrs = definition.symbolize_keys.except(:description, 'description')
+          header_attrs[:type] = definition[:type].titleize if definition[:type]
+          header_attrs[:documentation] = doc
+
+          accum[name] = header_attrs
         end
       end
     end

lib/grape-swagger/request_param_parsers/route.rb

@@ -18,7 +18,6 @@ def initialize(route, _params, _settings, _endpoint)
       def parse
         stackable_values = route.app&.inheritable_setting&.namespace_stackable
 
-        get_path_params(stackable_values)
         path_params = build_path_params(stackable_values)
 
         fulfill_params(path_params)
@@ -54,29 +53,13 @@ def fulfill_params(path_params)
           # The route.params hash includes both parametrized params (with a string as a key)
           # and well-defined params from body/query (with a symbol as a key).
           # We avoid overriding well-defined params with parametrized ones.
-          next if param.is_a?(String) && accum.key?(param.to_sym)
+          key = param.is_a?(String) ? param.to_sym : param
+          next if param.is_a?(String) && accum.key?(key)
 
-          value = (path_params[param] || {}).merge(
-            definition.is_a?(Hash) ? definition : {}
-          )
-
-          accum[param.to_sym] = value.empty? ? DEFAULT_PARAM_TYPE : value
-        end
-      end
-
-      # Iterates over namespaces recursively
-      # to build a hash of path params with options, including type
-      def get_path_params(stackable_values)
-        params = {}
-        return param unless stackable_values
-        return params unless stackable_values.is_a? Grape::Util::StackableValues
-
-        stackable_values&.new_values&.dig(:namespace)&.each do |namespace| # rubocop:disable Style/SafeNavigationChainLength
-          space = namespace.space.to_s.gsub(':', '')
-          params[space] = namespace.options || {}
+          defined_options = definition.is_a?(Hash) ? definition : {}
+          value = (path_params[param] || {}).merge(defined_options)
+          accum[key] = value.empty? ? DEFAULT_PARAM_TYPE : value
         end
-        inherited_params = get_path_params(stackable_values.inherited_values)
-        inherited_params.merge(params)
       end
     end
   end

spec/lib/request_param_parsers/body_spec.rb

@@ -109,16 +109,16 @@
     end
   end
 
-  describe '#param_type_is_array?' do
+  describe '#array_param?' do
     it 'returns true if the value passed represents an array' do
-      expect(parser.send(:param_type_is_array?, 'Array')).to be_truthy
-      expect(parser.send(:param_type_is_array?, '[String]')).to be_truthy
-      expect(parser.send(:param_type_is_array?, 'Array[Integer]')).to be_truthy
+      expect(parser.send(:array_param?, 'Array')).to be_truthy
+      expect(parser.send(:array_param?, '[String]')).to be_truthy
+      expect(parser.send(:array_param?, 'Array[Integer]')).to be_truthy
     end
 
     it 'returns false if the value passed does not represent an array' do
-      expect(parser.send(:param_type_is_array?, 'String')).to be_falsey
-      expect(parser.send(:param_type_is_array?, '[String, Integer]')).to be_falsey
+      expect(parser.send(:array_param?, 'String')).to be_falsey
+      expect(parser.send(:array_param?, '[String, Integer]')).to be_falsey
     end
   end
 end