rest_framework 0.9.16 → 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|
@@ -246,28 +246,38 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           includes[f] = sub_config
           includes_map[f] = f.to_sym
         end
-      elsif ref = reflections["rich_text_#{f}"]
+      elsif @controller.class.enable_action_text && ref = reflections["rich_text_#{f}"]
         # ActionText Integration: Define rich text serializer method.
         includes_map[f] = :"rich_text_#{f}"
         serializer_methods[f] = f
         self.define_singleton_method(f) do |record|
           next record.send(f).to_s
         end
-      elsif ref = attachment_reflections[f]
+      elsif @controller.class.enable_active_storage && ref = attachment_reflections[f]
         # ActiveStorage Integration: Define attachment serializer method.
         if ref.macro == :has_one_attached
           serializer_methods[f] = f
           includes_map[f] = {"#{f}_attachment": :blob}
           self.define_singleton_method(f) do |record|
             attached = record.send(f)
-            next attached.attachment ? {signed_id: attached.signed_id, url: attached.url} : nil
+            next attached.attachment ? {
+              filename: attached.filename,
+              signed_id: attached.signed_id,
+              url: attached.url,
+            } : nil
           end
         elsif ref.macro == :has_many_attached
           serializer_methods[f] = f
           includes_map[f] = {"#{f}_attachments": :blob}
           self.define_singleton_method(f) do |record|
             # Iterating the collection yields attachment objects.
-            next record.send(f).map { |a| {signed_id: a.signed_id, url: a.url} }
+            next record.send(f).map { |a|
+              {
+                filename: a.filename,
+                signed_id: a.signed_id,
+                url: a.url,
+              }
+            }
           end
         end
       elsif @model.method_defined?(f)

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,
@@ -153,16 +153,21 @@ module RESTFramework::Utils
   end
 
   # Parse fields hashes.
-  def self.parse_fields_hash(fields_hash, model, exclude_associations: nil)
-    parsed_fields = fields_hash[:only] || (
-      model ? self.fields_for(model, exclude_associations: exclude_associations) : []
+  def self.parse_fields_hash(h, model, exclude_associations:, action_text:, active_storage:)
+    parsed_fields = h[:only] || (
+      model ? self.fields_for(
+        model,
+        exclude_associations: exclude_associations,
+        action_text: action_text,
+        active_storage: active_storage,
+      ) : []
     )
-    parsed_fields += fields_hash[:include].map(&:to_s) if fields_hash[:include]
-    parsed_fields -= fields_hash[:exclude].map(&:to_s) if fields_hash[:exclude]
-    parsed_fields -= fields_hash[:except].map(&:to_s) if fields_hash[:except]
+    parsed_fields += h[:include].map(&:to_s) if h[:include]
+    parsed_fields -= h[:exclude].map(&:to_s) if h[:exclude]
+    parsed_fields -= h[:except].map(&:to_s) if h[:except]
 
     # Warn for any unknown keys.
-    (fields_hash.keys - [:only, :except, :include, :exclude]).each do |k|
+    (h.keys - [:only, :except, :include, :exclude]).each do |k|
       Rails.logger.warn("RRF: Unknown key in fields hash: #{k}")
     end
 
@@ -173,16 +178,24 @@ module RESTFramework::Utils
   # 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: nil)
+  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) }
 
     return base_fields if exclude_associations
 
-    # Add associations in addition to normal columns.
-    return base_fields + model.reflections.map { |association, ref|
+    # ActionText Integration: Determine the normalized field names for action text attributes.
+    atf = action_text ? model.reflect_on_all_associations(:has_one).collect(&:name).select { |n|
+      n.to_s.start_with?("rich_text_")
+    }.map { |n| n.to_s.delete_prefix("rich_text_") } : []
+
+    # ActiveStorage Integration: Determine the normalized field names for active storage attributes.
+    asf = active_storage ? model.attachment_reflections.keys : []
+
+    # Associations:
+    associations = model.reflections.map { |association, ref|
       # Ignore associations for which we have custom integrations.
-      if ref.class_name.in?(%w(ActiveStorage::Attachment ActiveStorage::Blob ActionText::RichText))
+      if ref.class_name.in?(%w(ActionText::RichText ActiveStorage::Attachment ActiveStorage::Blob))
         next nil
       end
 
@@ -193,11 +206,9 @@ module RESTFramework::Utils
       end
 
       next association
-    }.compact + model.reflect_on_all_associations(:has_one).collect(&:name).select { |n|
-      n.to_s.start_with?("rich_text_")
-    }.map { |n|
-      n.to_s.delete_prefix("rich_text_")
-    } + model.attachment_reflections.keys
+    }.compact
+
+    return base_fields + associations + atf + asf
   end
 
   # Get the sub-fields that may be serialized and filtered/ordered for a reflection.
@@ -223,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.9.16
+  version: 0.11.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-21 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