Add Grape::Middleware::Versioner::Base and use Grape::Util::Registry

lib/grape/middleware/versioner.rb

@@ -11,14 +11,16 @@
 module Grape
   module Middleware
     module Versioner
+      extend Grape::Util::Registry
+
       module_function
 
       # @param strategy [Symbol] :path, :header, :accept_version_header or :param
       # @return a middleware class based on strategy
       def using(strategy)
-        Grape::Middleware::Versioner.const_get(:"#{strategy.to_s.camelize}")
-      rescue NameError
-        raise Grape::Exceptions::InvalidVersionerOption, strategy
+        raise Grape::Exceptions::InvalidVersionerOption, strategy unless registry.key?(strategy)
+
+        registry[strategy]
       end
     end
   end

lib/grape/middleware/versioner/accept_version_header.rb

@@ -17,8 +17,6 @@ module Versioner
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class AcceptVersionHeader < Base
-        include VersionerHelpers
-
         def before
           potential_version = env[Grape::Http::Headers::HTTP_ACCEPT_VERSION]&.strip
           not_acceptable!('Accept-Version header must be set.') if strict? && potential_version.blank?

lib/grape/middleware/versioner/base.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Versioner
+      class Base < Grape::Middleware::Base
+        DEFAULT_PATTERN = /.*/i.freeze
+        DEFAULT_PARAMETER = 'apiver'
+
+        def self.inherited(klass)
+          super
+          return if klass.name.blank?
+
+          short_name = klass.name.demodulize.underscore
+          Versioner.register(short_name, klass)
+        end
+
+        def default_options
+          {
+            versions: nil,
+            prefix: nil,
+            mount_path: nil,
+            pattern: DEFAULT_PATTERN,
+            version_options: {
+              strict: false,
+              cascade: true,
+              parameter: DEFAULT_PARAMETER
+            }
+          }
+        end
+
+        def versions
+          options[:versions]
+        end
+
+        def prefix
+          options[:prefix]
+        end
+
+        def mount_path
+          options[:mount_path]
+        end
+
+        def pattern
+          options[:pattern]
+        end
+
+        def version_options
+          options[:version_options]
+        end
+
+        def strict?
+          version_options[:strict]
+        end
+
+        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
+        # of routes (see Grape::Router) for more information). To prevent
+        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
+        def cascade?
+          version_options[:cascade]
+        end
+
+        def parameter_key
+          version_options[:parameter]
+        end
+
+        def vendor
+          version_options[:vendor]
+        end
+
+        def error_headers
+          cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
+        end
+
+        def potential_version_match?(potential_version)
+          versions.blank? || versions.any? { |v| v.to_s == potential_version }
+        end
+
+        def version_not_found!
+          throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
+        end
+      end
+    end
+  end
+end

lib/grape/middleware/versioner/header.rb

@@ -22,8 +22,6 @@ module Versioner
       # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
-        include VersionerHelpers
-
         def before
           match_best_quality_media_type! do |media_type|
             env.update(

lib/grape/middleware/versioner/param.rb

@@ -19,8 +19,6 @@ module Versioner
       #
       #   env['api.version'] => 'v1'
       class Param < Base
-        include VersionerHelpers
-
         def before
           potential_version = Rack::Utils.parse_nested_query(env[Rack::QUERY_STRING])[parameter_key]
           return if potential_version.blank?

lib/grape/middleware/versioner/path.rb

@@ -17,8 +17,6 @@ module Versioner
       #   env['api.version'] => 'v1'
       #
       class Path < Base
-        include VersionerHelpers
-
         def before
           path_info = Grape::Router.normalize_path(env[Rack::PATH_INFO])
           return if path_info == '/'