rest_framework 1.2.0 → 2.0.0.beta1

data/lib/rest_framework/paginators/page_number_paginator.rb

@@ -4,12 +4,19 @@
 class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators::BasePaginator
   def initialize(**kwargs)
     super
-    # Exclude any `select` clauses since that would cause `count` to fail with a SQL `SyntaxError`.
-    @count = @data.except(:select).count
     @page_size = self._page_size
+    @total_count = @controller.class.page_total_count
 
-    @total_pages = @count / @page_size
-    @total_pages += 1 if @count % @page_size != 0
+    # Compute the total count (and total pages) unless disabled. On large tables `page_total_count`
+    # can be set to `false` to skip this `COUNT(*)` over the whole filtered set; `next` is then
+    # derived by fetching one extra record in `get_page`.
+    if @total_count
+      # Exclude any `select` clauses, since that would cause `count` to fail with a SQL
+      # `SyntaxError`.
+      @count = @data.except(:select).count
+      @total_pages = @count / @page_size
+      @total_pages += 1 if @count % @page_size != 0
+    end
   end
 
   def _page_size
@@ -17,7 +24,7 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
 
     # Get from query param, if allowed.
     if param = @controller.class.page_size_query_param
-      if raw = @controller.params[param].presence
+      if raw = @controller.request.query_parameters[param].presence
         parsed = raw.to_i
         page_size = parsed if parsed > 0
       end
@@ -38,9 +45,9 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
 
   # Get the page and return it so the caller can serialize it.
   def get_page(page_number = nil)
-    # If page number isn't provided, infer from the params or use 1 as a fallback value.
+    # If page number isn't provided, infer from the query params or use 1 as a fallback value.
     unless page_number
-      page_number = @controller&.params&.[](@controller.class.page_query_param&.to_sym)
+      page_number = @controller&.request&.query_parameters&.[](@controller.class.page_query_param)
       if page_number.blank?
         page_number = 1
       else
@@ -54,14 +61,23 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
 
     # Get the data page and return it so the caller can serialize the data in the proper format.
     page_index = @page_number - 1
-    @data.limit(@page_size).offset(page_index * @page_size)
+    offset = page_index * @page_size
+
+    # Without a total count we can't derive `next` from `total_pages`, so detect whether a further
+    # page exists with a cheap existence check (a `LIMIT 1` past this page) instead of a full count.
+    unless @total_count
+      @has_next = @data.except(:select).offset(offset + @page_size).exists?
+    end
+
+    @data.limit(@page_size).offset(offset)
   end
 
   # Wrap the serialized page with appropriate metadata.
   def get_paginated_response(serialized_page)
     page_query_param = @controller.class.page_query_param
     base_params = @controller.request.query_parameters.symbolize_keys
-    next_url = if @page_number < @total_pages
+    has_next = @total_count ? @page_number < @total_pages : @has_next
+    next_url = if has_next
       @controller.url_for({ **base_params, page_query_param => @page_number + 1 })
     end
     previous_url = if @page_number > 1

data/lib/rest_framework/routers.rb

@@ -2,221 +2,85 @@ require "action_dispatch/routing/mapper"
 
 module ActionDispatch::Routing
   class Mapper
-    # Internal interface to get the controller class from the name and current scope.
-    def _get_controller_class(name, pluralize: true, fallback_reverse_pluralization: true)
-      # Get class name.
-      name = name.to_s.camelize  # Camelize to leave plural names plural.
-      name = name.pluralize if pluralize
-      if name == name.pluralize
-        name_reverse = name.singularize
-      else
-        name_reverse = name.pluralize
-      end
-      name += "Controller"
-      name_reverse += "Controller"
-
-      # Get scope for the class.
-      if @scope[:module]
-        mod = @scope[:module].to_s.camelize.constantize
-      else
-        mod = Object
-      end
-
-      # Convert class name to class.
-      begin
-        controller = mod.const_get(name)
-      rescue NameError
-        if fallback_reverse_pluralization
-          reraise = false
-
-          begin
-            controller = mod.const_get(name_reverse)
-          rescue NameError
-            reraise = true
-          end
-
-          if reraise
-            raise
-          end
-        else
-          raise
-        end
-      end
-
-      controller
+    # Resolve a controller class from a route name and the current scope. The name must match the
+    # controller exactly (camelized, plus `Controller`) — there is no pluralization fallback.
+    def _rrf_controller_class(name)
+      mod = @scope[:module] ? @scope[:module].to_s.camelize.constantize : Object
+      mod.const_get("#{name.to_s.camelize}Controller")
     end
 
-    # Internal interface for routing extra actions.
-    def _route_extra_actions(actions, &block)
-      parsed_actions = RESTFramework::Utils.parse_extra_actions(actions)
-
-      parsed_actions.each do |action, config|
-        config[:methods].each do |m|
-          public_send(m, config[:path], action: action, **config[:kwargs])
+    # Route each action from a controller's action store.
+    def _rrf_route_actions(actions)
+      actions.each_value do |spec|
+        # Delegated actions keep their declared action name (so routing and OpenAPI show the real
+        # name); `method_for_action` redirects dispatch to `rrf_delegate`, which needs the scope.
+        kwargs = spec.kwargs
+        if !spec.builtin && spec.metadata&.[](:delegate)
+          kwargs = kwargs.merge(rrf_delegate_scope: spec.type)
         end
 
-        # Record that this route is an extra action and any metadata associated with it.
-        metadata = config[:metadata]
-        key = "#{@scope[:path]}/#{config[:path]}"
-        RESTFramework::EXTRA_ACTION_ROUTES.add(key)
-        RESTFramework::ROUTE_METADATA[key] = metadata if metadata
-
-        yield if block_given?
-      end
-    end
-
-    # Internal core implementation of the `rest_resource(s)` router, both singular and plural.
-    # @param default_singular [Boolean] the default plurality of the resource if the plurality is
-    #   not otherwise defined by the controller
-    # @param name [Symbol] the resource name, from which path and controller are deduced by default
-    def _rest_resources(default_singular, name, **kwargs, &block)
-      controller = kwargs.delete(:controller) || name
-      if controller.is_a?(Class)
-        controller_class = controller
-      else
-        controller_class = self._get_controller_class(controller, pluralize: !default_singular)
-      end
-
-      # Set controller if it's not explicitly set.
-      kwargs[:controller] = name unless kwargs[:controller]
-
-      # Passing `unscoped: true` will prevent a nested resource from being scoped.
-      unscoped = kwargs.delete(:unscoped)
-
-      # Determine plural/singular resource.
-      if !controller_class.singleton_controller.nil?
-        singular = controller_class.singleton_controller
-      else
-        singular = default_singular
-      end
-      resource_method = singular ? :resource : :resources
-
-      # Call either `resource` or `resources`, passing appropriate modifiers.
-      skip = RESTFramework::Utils.get_skipped_builtin_actions(controller_class, singular)
-      public_send(resource_method, name, except: skip, **kwargs) do
-        if controller_class.respond_to?(:extra_member_actions)
-          member do
-            self._route_extra_actions(controller_class.extra_member_actions)
-          end
+        spec.methods.each do |m|
+          public_send(m, spec.path, action: spec.name, **kwargs)
         end
 
-        collection do
-          # Route extra controller-defined actions.
-          self._route_extra_actions(controller_class.extra_actions)
-
-          # Route extra RRF-defined actions.
-          RESTFramework::RRF_BUILTIN_ACTIONS.each do |action, methods|
-            next unless controller_class.method_defined?(action)
-
-            [ methods ].flatten.each do |m|
-              # Anchor the route since Rails 8.1 OPTIONS routes are non-anchored by default, which
-              # causes parent OPTIONS routes to greedily intercept sub-path requests.
-              public_send(m, "", action: action, anchor: true) if self.respond_to?(m)
-            end
-          end
-
-          # Route bulk actions, if configured. These require a model and are gated by the `bulk`
-          # attribute, and may be individually excluded via `excluded_actions`.
-          if controller_class.model && controller_class.bulk
-            bulk_exclude = controller_class.excluded_actions&.to_set || Set.new
-            RESTFramework::RRF_BUILTIN_BULK_ACTIONS.each do |action, methods|
-              next unless controller_class.method_defined?(action)
-              next if bulk_exclude.include?(action)
+        # Record non-builtin (extra) actions and their metadata for the browsable API / OpenAPI.
+        next if spec.builtin
 
-              [ methods ].flatten.each do |m|
-                # Anchor the route since Rails 8.1 OPTIONS routes are non-anchored by default, which
-                # causes parent OPTIONS routes to greedily intercept sub-path requests.
-                public_send(m, "", action: action, anchor: true) if self.respond_to?(m)
-              end
-            end
-          end
-        end
-
-        if unscoped
-          yield if block_given?
-        else
-          scope(module: name, as: name) do
-            yield if block_given?
-          end
-        end
+        key = "#{@scope[:path]}/#{spec.path}"
+        RESTFramework::EXTRA_ACTION_ROUTES.add(key)
+        RESTFramework::ROUTE_METADATA[key] = spec.metadata if spec.metadata
       end
     end
 
-    # Public interface for creating singular RESTful resource routes.
-    def rest_resource(*names, **kwargs, &block)
-      names.each do |n|
-        self._rest_resources(true, n, **kwargs, &block)
+    # Route one or more controllers from their action stores. Plural model controllers get
+    # collection/member scopes; singular and non-model controllers route everything at the root.
+    # Passing several names condenses simple routes into one call; per-name options (`path:`, `as:`,
+    # `controller:`, and a block) only apply to a single name.
+    def rest_route(*names, **kwargs, &block)
+      if names.size > 1 && (block || (kwargs.keys & [ :path, :as, :controller ]).any?)
+        raise ArgumentError, "rest_route: options and a block require a single name"
       end
-    end
 
-    # Public interface for creating plural RESTful resource routes.
-    def rest_resources(*names, **kwargs, &block)
-      names.each do |n|
-        self._rest_resources(false, n, **kwargs, &block)
-      end
+      names.each { |name| _rrf_rest_route(name, **kwargs, &block) }
     end
 
-    # Route a controller without the default resourceful paths.
-    def rest_route(name = nil, **kwargs, &block)
+    # Route a single controller from its action store.
+    def _rrf_rest_route(name, **kwargs)
       controller = kwargs.delete(:controller) || name
-      route_root_to = kwargs.delete(:route_root_to)
       if controller.is_a?(Class)
         controller_class = controller
       else
-        controller_class = self._get_controller_class(controller, pluralize: false)
+        controller_class = self._rrf_controller_class(controller)
       end
 
       # Set controller if it's not explicitly set.
       kwargs[:controller] = name unless kwargs[:controller]
 
-      # Passing `unscoped: true` will prevent a nested resource from being scoped.
-      unscoped = kwargs.delete(:unscoped)
-
-      # Route actions using the resourceful router, but skip all builtin actions.
-      public_send(:resource, name, only: [], **kwargs) do
-        # Route a root for this resource.
-        if route_root_to
-          get("", action: route_root_to, as: "")
-        end
-
-        collection do
-          # Route extra controller-defined actions.
-          self._route_extra_actions(controller_class.extra_actions)
-
-          # Route extra RRF-defined actions.
-          RESTFramework::RRF_BUILTIN_ACTIONS.each do |action, methods|
-            next unless controller_class.method_defined?(action)
-
-            [ methods ].flatten.each do |m|
-              # Anchor the route since Rails 8.1 OPTIONS routes are non-anchored by default, which
-              # causes parent OPTIONS routes to greedily intercept sub-path requests.
-              public_send(m, "", action: action, anchor: true) if self.respond_to?(m)
-            end
+      has_model = !!controller_class.model
+      singular = controller_class.singular
+      actions = controller_class.actions
+      member_actions = controller_class.member_actions
+
+      # Use `resources` (plural) for plural model controllers to get the member `:id` scope; use
+      # `resource` (singular) for everything else.
+      resource_method = (has_model && !singular) ? :resources : :resource
+
+      public_send(resource_method, name, only: [], **kwargs) do
+        if has_model
+          if singular
+            # Singular model controller: actions and member actions are the same.
+            self._rrf_route_actions(actions)
+            self._rrf_route_actions(member_actions)
+          else
+            # Plural model controller: route collection/member actions separately.
+            collection { self._rrf_route_actions(actions) }
+            member { self._rrf_route_actions(member_actions) }
           end
-        end
-
-        if unscoped
-          yield if block_given?
         else
-          scope(module: name, as: name) do
-            yield if block_given?
-          end
+          # Non-model controller: only actions (there is no member `:id` scope).
+          self._rrf_route_actions(actions)
         end
-      end
-    end
-
-    # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
-    def rest_root(name = nil, **kwargs, &block)
-      # By default, use RootController#root.
-      root_action = kwargs.delete(:action) || :root
-      controller = kwargs.delete(:controller) || name || :root
-
-      # Remove path if name is nil (routing to the root of current namespace).
-      unless name
-        kwargs[:path] = ""
-      end
 
-      rest_route(controller, route_root_to: root_action, **kwargs) do
         yield if block_given?
       end
     end

data/lib/rest_framework/serializers/active_model_serializer_adapter_factory.rb

@@ -1,6 +1,6 @@
 # This is a helper factory to wrap an ActiveModelSerializer to provide a `serialize` method which
 # accepts both collections and individual records. Use `.for` to build adapters.
-# :nocov:
+# simplecov:disable
 class RESTFramework::Serializers::ActiveModelSerializerAdapterFactory
   def self.for(active_model_serializer)
     Class.new(active_model_serializer) do
@@ -14,7 +14,7 @@ class RESTFramework::Serializers::ActiveModelSerializerAdapterFactory
     end
   end
 end
-# :nocov:
+# simplecov:enable
 
 # Alias for convenience.
 # rubocop:disable Layout/LineLength

data/lib/rest_framework/serializers/base_serializer.rb

@@ -16,7 +16,7 @@ class RESTFramework::Serializers::BaseSerializer
   end
 
   # Synonym for `serialize` for compatibility with `active_model_serializers`.
-  # :nocov:
+  # simplecov:disable
   def serializable_hash(*args)
     self.serialize(*args)
   end
@@ -35,7 +35,7 @@ class RESTFramework::Serializers::BaseSerializer
   def associations(*args, **kwargs)
     []
   end
-  # :nocov:
+  # simplecov:enable
 end
 
 # Alias for convenience.

data/lib/rest_framework/serializers/native_serializer.rb

@@ -111,25 +111,77 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     controller_serializer || @controller.class.native_serializer_config
   end
 
-  # Get the associations limit from the controller.
-  def _associations_limit
-    return @_associations_limit if defined?(@_associations_limit)
-
-    limit = @controller&.class&.native_serializer_associations_limit
-
-    # Extract the limit from the query parameters if it's set.
-    if query_param = @controller&.class&.native_serializer_associations_limit_query_param
-      if @controller.request.query_parameters.key?(query_param)
-        query_limit = @controller.request.query_parameters[query_param].to_i
-        if query_limit > 0
-          limit = query_limit
-        else
-          limit = nil
-        end
-      end
-    end
+  # The record cap for a collection association (`nil` = unlimited). The default is applied even
+  # when the feature is off, so responses are always bounded. `key?` (not `||`) reads the
+  # `field_config` override so an explicit `nil` there means unlimited/uncapped rather than falling
+  # back to the controller default.
+  def _effective_association_limit(association_name, field_config)
+    controller = @controller&.class
+
+    default = field_config.key?(:limit) ?
+      field_config[:limit] : controller&.association_limit
+    return default unless controller&.enable_association_queries
+
+    requested = self._requested_association_limit(association_name)
+    return default if requested.nil?
+
+    max = field_config.key?(:limit_max) ?
+      field_config[:limit_max] : controller.association_limit_max
+
+    # `all` means "as many as allowed" — the cap, or unlimited when the cap is `nil`.
+    return max if requested == :all
+
+    max ? [ requested, max ].min : requested
+  end
+
+  # `all`, `none`, and `0` all mean "no limit" — `0` is free to reuse as a sentinel since an
+  # association is dropped via `except`, not `limit=0`. Anything else must be a plain positive
+  # integer, so a nested/array param or junk can't drive the query.
+  def _requested_association_limit(association_name)
+    return nil unless prefix = @controller.class.association_query_prefix.presence
+
+    raw = @controller.request&.query_parameters&.[]("#{prefix}.#{association_name}.limit")
+    return nil unless raw.is_a?(String)
+
+    raw = raw.strip
+    return :all if raw.in?(%w[all none])
+    return nil unless raw.match?(/\A\d+\z/)
+
+    # The regex guarantees a non-negative integer, so anything but zero is a positive limit.
+    limit = raw.to_i
+    limit.zero? ? :all : limit
+  end
+
+  # The fields to serialize for association `f`, honoring a consumer's `?<prefix>.<f>.fields=`
+  # request bounded by the allowlist. Only active when the feature is enabled.
+  def _effective_association_fields(association_name, ref, field_config)
+    default_fields = field_config[:fields]
+    return default_fields unless @controller&.class&.enable_association_queries
+    return default_fields if ref.polymorphic? # no single target class to bound the request
+
+    requested = self._requested_association_fields(association_name)
+    return default_fields if requested.blank?
+
+    # The primary key is always kept so records stay identifiable. `_valid_association_field?` is
+    # the last line of defense against leaking a non-serializable or nested-association field.
+    allowed = (default_fields + (field_config[:requestable_fields] || [])).uniq
+    valid = (requested & allowed).select { |sf| self._valid_association_field?(ref, sf) }
+    (Array(ref.klass.primary_key).map(&:to_s) + valid).uniq
+  end
+
+  # Only a plain scalar string is honored, so a nested-hash/array param can't reach `where`/`split`.
+  def _requested_association_fields(association_name)
+    return nil unless prefix = @controller.class.association_query_prefix.presence
+
+    raw = @controller.request&.query_parameters&.[]("#{prefix}.#{association_name}.fields")
+    return nil unless raw.is_a?(String)
+
+    raw.split(",").map { |x| x.strip.presence }.compact
+  end
 
-    @_associations_limit = limit
+  def _valid_association_field?(ref, field)
+    field.in?(ref.klass.column_names) ||
+      (ref.klass.method_defined?(field) && !ref.klass.reflect_on_association(field.to_sym))
   end
 
   # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
@@ -158,7 +210,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       elsif ref = reflections[f]
         sub_columns = []
         sub_methods = []
-        field_config[:sub_fields].each do |sf|
+        self._effective_association_fields(f, ref, field_config).each do |sf|
           if !ref.polymorphic? && sf.in?(ref.klass.column_names)
             sub_columns << sf
           else
@@ -169,9 +221,9 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
 
         # Apply certain rules regarding collection associations.
         if ref.collection?
-          # If we need to limit the number of serialized association records, then dynamically add a
-          # serializer method to do so.
-          if limit = self._associations_limit
+          # A finite limit needs a per-record `.limit` query, since eager `includes` can't cap rows
+          # per parent; an unlimited (`nil`) association falls through to `includes` preloading.
+          if limit = self._effective_association_limit(f, field_config)
             serializer_methods[f] = f
             self.define_singleton_method(f) do |record|
               next record.send(f).limit(limit).as_json(**sub_config)
@@ -181,7 +233,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
             #
             # # Even though we use a serializer method, if the count will later be added, then put
             # # this field into the includes_map.
-            # if @controller.class.native_serializer_include_associations_count
+            # if @controller.class.include_association_count
             #   includes_map[f] = f.to_sym
             # end
           else
@@ -190,7 +242,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           end
 
           # If we need to include the association count, then add it here.
-          if @controller.class.native_serializer_include_associations_count
+          if @controller.class.include_association_count
             method_name = "#{f}.count"
             serializer_methods[method_name] = method_name
             self.define_singleton_method(method_name) do |record|

data/lib/rest_framework/utils.rb

@@ -1,59 +1,6 @@
 module RESTFramework::Utils
   HTTP_VERB_ORDERING = %w[GET POST PUT PATCH DELETE OPTIONS HEAD]
 
-  # Convert `extra_actions` hash to a consistent format: `{path:, methods:, metadata:, kwargs:}`.
-  def self.parse_extra_actions(extra_actions)
-    (extra_actions || {}).map { |k, v|
-      path = k
-      kwargs = {}
-
-      # Convert structure to path/methods/kwargs.
-      if v.is_a?(Hash)
-        # Symbolize keys (which also makes a copy so we don't mutate the original).
-        v = v.symbolize_keys
-
-        # Cast method/methods to an array.
-        methods = [ v.delete(:methods), v.delete(:method) ].flatten.compact
-
-        # Override path if it's provided.
-        if v.key?(:path)
-          path = v.delete(:path)
-        end
-
-        # Extract metadata, if provided.
-        metadata = v.delete(:metadata).presence
-
-        # Pass any further kwargs to the underlying Rails interface.
-        kwargs = v
-      else
-        methods = [ v ].flatten
-      end
-
-      next [
-        k,
-        {
-          path: path,
-          methods: methods,
-          metadata: metadata,
-          kwargs: kwargs,
-        }.compact,
-      ]
-    }.to_h
-  end
-
-  def self.get_skipped_builtin_actions(controller_class, singular)
-    candidates = (
-      RESTFramework::BUILTIN_ACTIONS.keys - (singular ? [ :index ] : [])
-    ) + RESTFramework::BUILTIN_MEMBER_ACTIONS.keys
-
-    return candidates unless controller_class.model
-
-    exclude = controller_class.excluded_actions&.to_set || Set.new
-    candidates.reject do |action|
-      controller_class.method_defined?(action) && !exclude.include?(action)
-    end
-  end
-
   # Get the first route pattern which matches the given request.
   def self.get_request_route(application_routes, request)
     # Prefer the route already resolved by the router to avoid an expensive `recognize` call. This
@@ -172,9 +119,8 @@ module RESTFramework::Utils
     parsed_fields.map(&:to_s)
   end
 
-  # Get the fields for a given model, including not just columns (which includes
-  # foreign keys), but also associations. Note that we always return an array of
-  # strings, not symbols.
+  # Get the fields for a given model, including not just columns (which includes foreign keys), but
+  # also associations. Note that we always return an array of strings, not symbols.
   def self.fields_for(model, exclude_associations:, action_text:, active_storage:)
     foreign_keys = model.reflect_on_all_associations(:belongs_to).map(&:foreign_key)
     base_fields = model.column_names.reject { |c| c.in?(foreign_keys) }
@@ -208,23 +154,23 @@ module RESTFramework::Utils
     base_fields + associations + atf + asf
   end
 
-  # Get the sub-fields that may be serialized and filtered/ordered for a reflection.
-  def self.sub_fields_for(ref)
+  # Get the association's fields that may be serialized and filtered/ordered for a reflection.
+  def self.association_fields_for(ref)
     if !ref.polymorphic? && model = ref.klass
-      sub_fields = [ model.primary_key ].flatten.compact
+      fields = [ model.primary_key ].flatten.compact
       label_fields = RESTFramework.config.label_fields
 
       # Preferably find a database column to use as label.
       if match = label_fields.find { |f| f.in?(model.column_names) }
-        return sub_fields + [ match ]
+        return fields + [ match ]
       end
 
       # Otherwise, find a method.
       if match = label_fields.find { |f| model.method_defined?(f) }
-        return sub_fields + [ match ]
+        return fields + [ match ]
       end
 
-      return sub_fields
+      return fields
     end
 
     [ "id", "name" ]
@@ -243,6 +189,30 @@ module RESTFramework::Utils
     nil
   end
 
+  # Find the REST controller for `model` at the same namespace level as `current_controller`, e.g.
+  # `Api::Demo::MoviesController` + `Genre` => `Api::Demo::GenresController`, or `nil` if none. The
+  # `model` match guards against trusting a same-named controller for a different model.
+  def self.controller_for_model(current_controller, model)
+    return nil unless model && (base_name = current_controller.name)
+
+    namespace = base_name.deconstantize
+    model_name = model.model_name
+
+    # Plural for a collection controller, singular for a singular-resource one.
+    [ model_name.plural, model_name.singular ].each do |name|
+      candidate_name = "#{name.camelize}Controller"
+      candidate_name = "#{namespace}::#{candidate_name}" if namespace.present?
+
+      candidate = candidate_name.safe_constantize
+      next unless candidate.is_a?(Class) && candidate.include?(RESTFramework::Controller)
+      next unless candidate.model == model
+
+      return candidate
+    end
+
+    nil
+  end
+
   # Wrap a serializer with an adapter if it is an ActiveModel::Serializer.
   def self.wrap_ams(s)
     if defined?(ActiveModel::Serializer) && (s < ActiveModel::Serializer)
@@ -251,12 +221,4 @@ module RESTFramework::Utils
 
     s
   end
-
-  # Used for deprecated mixins that rely on model being determined from the controller name.
-  def self.get_model(controller_class)
-    begin
-      controller_class.name.demodulize.chomp("Controller").singularize.constantize
-    rescue NameError
-    end
-  end
 end