rest_framework 0.10.0 → 0.11.0

data/lib/rest_framework/paginators/page_number_paginator.rb

@@ -13,34 +13,35 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
   end
 
   def _page_size
-    page_size = nil
+    page_size = 1
 
     # Get from context, if allowed.
-    if @controller.page_size_query_param
-      if page_size = @controller.params[@controller.page_size_query_param].presence
+    if param = @controller.class.page_size_query_param
+      if page_size = @controller.params[param].presence
         page_size = page_size.to_i
       end
     end
 
     # Otherwise, get from config.
-    if !page_size && @controller.page_size
-      page_size = @controller.page_size
+    if !page_size && @controller.class.page_size
+      page_size = @controller.class.page_size.to_i
     end
 
     # Ensure we don't exceed the max page size.
-    if @controller.max_page_size && page_size > @controller.max_page_size
-      page_size = @controller.max_page_size
+    max_page_size = @controller.class.max_page_size&.to_i
+    if max_page_size && page_size > max_page_size
+      page_size = max_page_size
     end
 
     # Ensure we return at least 1.
-    return page_size.zero? ? 1 : page_size
+    return [page_size, 1].max
   end
 
   # 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.
     unless page_number
-      page_number = @controller&.params&.[](@controller.page_query_param&.to_sym)
+      page_number = @controller&.params&.[](@controller.class.page_query_param&.to_sym)
       if page_number.blank?
         page_number = 1
       else
@@ -57,9 +58,9 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
     return @data.limit(@page_size).offset(page_index * @page_size)
   end
 
-  # Wrap the serialized page with appropriate metadata. TODO: include links.
+  # Wrap the serialized page with appropriate metadata.
   def get_paginated_response(serialized_page)
-    page_query_param = @controller.page_query_param
+    page_query_param = @controller.class.page_query_param
     base_params = @controller.params.to_unsafe_h
     next_url = if @page_number < @total_pages
       @controller.url_for({**base_params, page_query_param => @page_number + 1})

data/lib/rest_framework/routers.rb

@@ -27,7 +27,17 @@ module ActionDispatch::Routing
         controller = mod.const_get(name)
       rescue NameError
         if fallback_reverse_pluralization
-          controller = mod.const_get(name_reverse)
+          reraise = false
+
+          begin
+            controller = mod.const_get(name_reverse)
+          rescue
+            reraise = true
+          end
+
+          if reraise
+            raise
+          end
         else
           raise
         end

data/lib/rest_framework/serializers/native_serializer.rb

@@ -55,12 +55,12 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     return nil unless @controller
 
     if @many == true
-      controller_serializer = @controller.try(:native_serializer_plural_config)
+      controller_serializer = @controller.class.native_serializer_plural_config
     elsif @many == false
-      controller_serializer = @controller.try(:native_serializer_singular_config)
+      controller_serializer = @controller.class.native_serializer_singular_config
     end
 
-    return controller_serializer || @controller.try(:native_serializer_config)
+    return controller_serializer || @controller.class.native_serializer_config
   end
 
   # Filter a single subconfig for specific keys. By default, keys from `fields` are removed from the
@@ -114,8 +114,8 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
   def filter_from_request(cfg)
     return cfg unless @controller
 
-    except_param = @controller.try(:native_serializer_except_query_param)
-    only_param = @controller.try(:native_serializer_only_query_param)
+    except_param = @controller.class.native_serializer_except_query_param
+    only_param = @controller.class.native_serializer_only_query_param
     if except_param && except = @controller.request&.query_parameters&.[](except_param).presence
       if except = except.split(",").map(&:strip).map(&:to_sym).presence
         # Filter `only`, `except` (additive), `include`, `methods`, and `serializer_methods`.
@@ -160,10 +160,10 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
   def _get_associations_limit
     return @_get_associations_limit if defined?(@_get_associations_limit)
 
-    limit = @controller&.native_serializer_associations_limit
+    limit = @controller&.class&.native_serializer_associations_limit
 
     # Extract the limit from the query parameters if it's set.
-    if query_param = @controller&.native_serializer_associations_limit_query_param
+    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
@@ -195,7 +195,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     attachment_reflections = @model.attachment_reflections
 
     fields.each do |f|
-      field_config = @controller.class.field_config_for(f)
+      field_config = @controller.class.field_configuration[f]
       next if field_config[:write_only]
 
       if f.in?(column_names)
@@ -226,7 +226,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.native_serializer_include_associations_count
+            # if @controller.class.native_serializer_include_associations_count
             #   includes_map[f] = f.to_sym
             # end
           else
@@ -235,7 +235,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           end
 
           # If we need to include the association count, then add it here.
-          if @controller.native_serializer_include_associations_count
+          if @controller.class.native_serializer_include_associations_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,14 +1,12 @@
 module RESTFramework::Utils
   HTTP_VERB_ORDERING = %w(GET POST PUT PATCH DELETE OPTIONS HEAD)
 
-  # Convert `extra_actions` hash to a consistent format: `{path:, methods:, kwargs:}`, and
-  # additional metadata fields.
+  # Convert `extra_actions` hash to a consistent format: `{path:, methods:, kwargs:}`.
   #
   # If a controller is provided, labels will be added to any metadata fields.
   def self.parse_extra_actions(extra_actions, controller: nil)
     return (extra_actions || {}).map { |k, v|
       path = k
-      metadata = {}
 
       # Convert structure to path/methods/kwargs.
       if v.is_a?(Hash)  # Allow kwargs to be used to define path differently from the key.
@@ -19,11 +17,9 @@ module RESTFramework::Utils
           methods = v.delete(:method)
         end
 
-        # First, remove the route metadata.
-        metadata = v.delete(:metadata) || {}
-
-        # Add label to fields.
-        if controller && metadata[:fields]
+        # Add label to metadata fields, if any exist.
+        metadata = v[:metadata]
+        if controller && metadata&.key?(:fields)
           metadata[:fields] = metadata[:fields].map { |f|
             [f, {}]
           }.to_h if metadata[:fields].is_a?(Array)
@@ -56,8 +52,6 @@ module RESTFramework::Utils
           path: path,
           methods: methods,
           kwargs: kwargs,
-          type: :extra,
-          metadata: metadata.presence,
         }.compact,
       ]
     }.to_h
@@ -91,25 +85,28 @@ module RESTFramework::Utils
     current_levels = current_path.count("/")
     current_comparable_path = %r{^#{Regexp.quote(self.comparable_path(current_path))}(/|$)}
 
-    # Add helpful properties of the current route.
-    path_args = current_route.required_parts.map { |n| request.path_parameters[n] }
-    route_props = {
-      with_path_args: ->(r) {
-        r.format(r.required_parts.each_with_index.map { |p, i| [p, path_args[i]] }.to_h)
-      },
-    }
+    # Get current route path parameters.
+    path_params = current_route.required_parts.map { |n| request.path_parameters[n] }
 
     # Return routes that match our current route subdomain/pattern, grouped by controller. We
     # precompute certain properties of the route for performance.
-    return route_props, application_routes.routes.select { |r|
+    return application_routes.routes.select { |r|
       # We `select` first to avoid unnecessarily calculating metadata for routes we don't even want
       # to show.
       (r.defaults[:subdomain].blank? || r.defaults[:subdomain] == request.subdomain) &&
-        current_comparable_path.match?(self.comparable_path(r.path.spec.to_s)) &&
-        r.defaults[:controller].present? &&
-        r.defaults[:action].present?
+          current_comparable_path.match?(self.comparable_path(r.path.spec.to_s)) &&
+          r.defaults[:controller].present? &&
+          r.defaults[:action].present?
     }.map { |r|
       path = r.path.spec.to_s.gsub("(.:format)", "")
+
+      # Starts at the number of levels in current path, and removes the `(.:format)` at the end.
+      relative_path = path.split("/")[current_levels..]&.join("/").presence || "/"
+
+      # This path is what would need to be concatenated onto the current path to get to the
+      # destination path.
+      concat_path = relative_path.gsub(/^[^\/]*/, "").presence || "/"
+
       levels = path.count("/")
       matches_path = current_path == path
       matches_params = r.required_parts.length == current_route.required_parts.length
@@ -118,8 +115,11 @@ module RESTFramework::Utils
         route: r,
         verb: r.verb,
         path: path,
-        # Starts at the number of levels in current path, and removes the `(.:format)` at the end.
-        relative_path: path.split("/")[current_levels..]&.join("/").presence || "/",
+        path_with_params: r.format(
+          r.required_parts.each_with_index.map { |p, i| [p, path_params[i]] }.to_h,
+        ),
+        relative_path: relative_path,
+        concat_path: concat_path,
         controller: r.defaults[:controller].presence,
         action: r.defaults[:action].presence,
         matches_path: matches_path,
@@ -234,7 +234,7 @@ module RESTFramework::Utils
   end
 
   # Get a field's id/ids variation.
-  def self.get_id_field(field, reflection)
+  def self.id_field_for(field, reflection)
     if reflection.collection?
       return "#{field.singularize}_ids"
     elsif reflection.belongs_to?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-23 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -54,7 +54,7 @@ files:
 - lib/rest_framework/engine.rb
 - lib/rest_framework/errors.rb
 - lib/rest_framework/errors/base_error.rb
-- lib/rest_framework/errors/nil_passed_to_api_response_error.rb
+- lib/rest_framework/errors/nil_passed_to_render_api_error.rb
 - lib/rest_framework/errors/unknown_model_error.rb
 - lib/rest_framework/filters.rb
 - lib/rest_framework/filters/base_filter.rb