rest_framework 0.5.4 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 413ee55f2eecbb8a8cdd3b133852d83a3e3fdb7e43f19c8deae12adcb3d38977
-  data.tar.gz: 6582a4d8acd988ad3034af3191b75454fcf602c5f968772e18fa9d5535b71dea
+  metadata.gz: a9e50f091ca2fab796992252f39a700ab1c22ad89b50953654240ac5273cd7ac
+  data.tar.gz: ed46ccce3fb8986f207f5b8e996f1a9577e58834f70fcc7de0c36a3e54b8f65f
 SHA512:
-  metadata.gz: 19cb82822923617face6c76e0fd36cfa001f23e88393210990842563b0483891dab03638e11c65bf1182db6ebe0d164cf09bb3e35a7ea06b9769c729e16b85d5
-  data.tar.gz: fc853858e022b126d67f878c63f2e46e18a1f03d03e2aeda90f7c8996b6a461bd41d41d44fadb59d46256aa9c35b18efc1c5e9b7970f712dce010af0c9178e68
+  metadata.gz: ed76863c305eb92f712affbb0d43b1470c518f933226a86c60983690edf5846faadc7dca0278d1075ed903d6637b45c4eeff1788e00ef130ec49457f94dba4f4
+  data.tar.gz: 16b12ff971d7201669d0114804e8664dc641065c771c4cb34ba1ac21899f1fd14fd396d363f76619a58dba67688b88e35ae69b34be80e4975b6f94cfe6760c67

data/VERSION

@@ -1 +1 @@
-0.5.4
+0.5.7

data/lib/rest_framework/controller_mixins/base.rb

@@ -45,6 +45,7 @@ module RESTFramework::BaseControllerMixin
         page_query_param: "page",
         page_size_query_param: "page_size",
         max_page_size: nil,
+        rescue_unknown_format_with: :json,
         serializer_class: nil,
         serialize_to_json: true,
         serialize_to_xml: true,
@@ -145,42 +146,55 @@ module RESTFramework::BaseControllerMixin
       raise RESTFramework::NilPassedToAPIResponseError
     end
 
-    respond_to do |format|
-      if payload == ""
-        format.json { head(:no_content) } if self.class.serialize_to_json
-        format.xml { head(:no_content) } if self.class.serialize_to_xml
-      else
-        format.json {
-          jkwargs = kwargs.merge(json_kwargs)
-          render(json: payload, layout: false, **jkwargs)
-        } if self.class.serialize_to_json
-        format.xml {
-          xkwargs = kwargs.merge(xml_kwargs)
-          render(xml: payload, layout: false, **xkwargs)
-        } if self.class.serialize_to_xml
-        # TODO: possibly support more formats here if supported?
-      end
-      format.html {
-        @payload = payload
+    # Flag to track if we had to rescue unknown format.
+    already_rescued_unknown_format = false
+
+    begin
+      respond_to do |format|
         if payload == ""
-          @json_payload = "" if self.class.serialize_to_json
-          @xml_payload = "" if self.class.serialize_to_xml
+          format.json { head(:no_content) } if self.class.serialize_to_json
+          format.xml { head(:no_content) } if self.class.serialize_to_xml
         else
-          @json_payload = payload.to_json if self.class.serialize_to_json
-          @xml_payload = payload.to_xml if self.class.serialize_to_xml
-        end
-        @template_logo_text ||= "Rails REST Framework"
-        @title ||= self.controller_name.camelize
-        @route_groups ||= RESTFramework::Utils.get_routes(Rails.application.routes, request)
-        hkwargs = kwargs.merge(html_kwargs)
-        begin
-          render(**hkwargs)
-        rescue ActionView::MissingTemplate  # fallback to rest_framework layout
-          hkwargs[:layout] = "rest_framework"
-          hkwargs[:html] = ""
-          render(**hkwargs)
+          format.json {
+            jkwargs = kwargs.merge(json_kwargs)
+            render(json: payload, layout: false, **jkwargs)
+          } if self.class.serialize_to_json
+          format.xml {
+            xkwargs = kwargs.merge(xml_kwargs)
+            render(xml: payload, layout: false, **xkwargs)
+          } if self.class.serialize_to_xml
+          # TODO: possibly support more formats here if supported?
         end
-      }
+        format.html {
+          @payload = payload
+          if payload == ""
+            @json_payload = "" if self.class.serialize_to_json
+            @xml_payload = "" if self.class.serialize_to_xml
+          else
+            @json_payload = payload.to_json if self.class.serialize_to_json
+            @xml_payload = payload.to_xml if self.class.serialize_to_xml
+          end
+          @template_logo_text ||= "Rails REST Framework"
+          @title ||= self.controller_name.camelize
+          @route_groups ||= RESTFramework::Utils.get_routes(Rails.application.routes, request)
+          hkwargs = kwargs.merge(html_kwargs)
+          begin
+            render(**hkwargs)
+          rescue ActionView::MissingTemplate  # fallback to rest_framework layout
+            hkwargs[:layout] = "rest_framework"
+            hkwargs[:html] = ""
+            render(**hkwargs)
+          end
+        }
+      end
+    rescue ActionController::UnknownFormat
+      if !already_rescued_unknown_format && rescue_format = self.class.rescue_unknown_format_with
+        request.format = rescue_format
+        already_rescued_unknown_format = true
+        retry
+      else
+        raise
+      end
     end
   end
 end

data/lib/rest_framework/controller_mixins/models.rb

@@ -59,7 +59,7 @@ module RESTFramework::BaseModelControllerMixin
   end
 
   def _get_specific_action_config(action_config_key, generic_config_key)
-    action_config = self.class.send(action_config_key) || {}
+    action_config = self.class.send(action_config_key)&.with_indifferent_access || {}
     action = self.action_name&.to_sym
 
     # Index action should use :list serializer if :index is not provided.
@@ -71,35 +71,33 @@ module RESTFramework::BaseModelControllerMixin
   # Get a list of fields for the current action.
   def get_fields
     return (
-      _get_specific_action_config(:action_fields, :fields)&.map(&:to_s) ||
-      self.get_model&.column_names ||
-      []
+      _get_specific_action_config(:action_fields, :fields) || self.get_model&.column_names || []
     )
   end
 
   # Get a list of find_by fields for the current action.
   def get_find_by_fields
-    return self.class.find_by_fields&.map(&:to_s) || self.get_fields
+    return self.class.find_by_fields || self.get_fields
   end
 
   # Get a list of find_by fields for the current action.
   def get_filterset_fields
-    return self.class.filterset_fields&.map(&:to_s) || self.get_fields
+    return self.class.filterset_fields || self.get_fields
   end
 
   # Get a list of ordering fields for the current action.
   def get_ordering_fields
-    return self.class.ordering_fields&.map(&:to_s) || self.get_fields
+    return self.class.ordering_fields || self.get_fields
   end
 
   # Get a list of search fields for the current action.
   def get_search_fields
-    return self.class.search_fields&.map(&:to_s) || self.get_fields
+    return self.class.search_fields || self.get_fields
   end
 
   # Get a list of parameters allowed for the current action.
   def get_allowed_parameters
-    return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)&.map(&:to_s)
+    return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)
   end
 
   # Helper to get the configured serializer class, or `NativeSerializer` as a default.
@@ -117,7 +115,8 @@ module RESTFramework::BaseModelControllerMixin
   # Filter the request body for keys in current action's allowed_parameters/fields config.
   def get_body_params
     return @_get_body_params ||= begin
-      fields = self.get_allowed_parameters || self.get_fields
+      # Map fields to strings because body keys will be string.
+      fields = (self.get_allowed_parameters || self.get_fields).map(&:to_s)
 
       # Filter the request body.
       body_params = request.request_parameters.select { |p| fields.include?(p) }
@@ -137,7 +136,7 @@ module RESTFramework::BaseModelControllerMixin
       end
 
       # Filter fields in exclude_body_fields.
-      (self.class.exclude_body_fields || []).each { |f| body_params.delete(f.to_s) }
+      (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
 
       body_params
     end
@@ -181,8 +180,13 @@ module RESTFramework::BaseModelControllerMixin
 
   # Get a single record by primary key or another column, if allowed.
   def get_record
+    # Cache the result.
+    return @_get_record if @_get_record
+
     recordset = self.get_recordset
-    find_by_fields = self.get_find_by_fields
+
+    # Map find_by fields to strings because query param value is a string.
+    find_by_fields = self.get_find_by_fields.map(&:to_s)
     find_by_key = self.get_model.primary_key
 
     # Find by another column if it's permitted.
@@ -196,18 +200,18 @@ module RESTFramework::BaseModelControllerMixin
     end
 
     # Return the record. Route key is always :id by Rails convention.
-    return recordset.find_by!(find_by_key => params[:id])
+    return @_get_record = recordset.find_by!(find_by_key => params[:id])
   end
 end
 
 # Mixin for listing records.
 module RESTFramework::ListModelMixin
   def index
-    api_response(self._index)
+    api_response(self.index!)
   end
 
-  def _index
-    @records = self.get_filtered_data(self.get_recordset)
+  def index!
+    @records ||= self.get_filtered_data(self.get_recordset)
 
     # Handle pagination, if enabled.
     if self.class.paginator_class
@@ -224,11 +228,11 @@ end
 # Mixin for showing records.
 module RESTFramework::ShowModelMixin
   def show
-    api_response(self._show)
+    api_response(self.show!)
   end
 
-  def _show
-    @record = self.get_record
+  def show!
+    @record ||= self.get_record
     return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
@@ -236,16 +240,16 @@ end
 # Mixin for creating records.
 module RESTFramework::CreateModelMixin
   def create
-    api_response(self._create)
+    api_response(self.create!)
   end
 
-  def _create
+  def create!
     if self.get_recordset.respond_to?(:create!) && self.create_from_recordset
       # Create with any properties inherited from the recordset.
-      @record = self.get_recordset.create!(self.get_create_params)
+      @record ||= self.get_recordset.create!(self.get_create_params)
     else
       # Otherwise, perform a "bare" create.
-      @record = self.get_model.create!(self.get_create_params)
+      @record ||= self.get_model.create!(self.get_create_params)
     end
 
     return self.get_serializer_class.new(@record, controller: self).serialize
@@ -255,11 +259,11 @@ end
 # Mixin for updating records.
 module RESTFramework::UpdateModelMixin
   def update
-    api_response(self._update)
+    api_response(self.update!)
   end
 
-  def _update
-    @record = self.get_record
+  def update!
+    @record ||= self.get_record
     @record.update!(self.get_update_params)
     return self.get_serializer_class.new(@record, controller: self).serialize
   end
@@ -268,12 +272,12 @@ end
 # Mixin for destroying records.
 module RESTFramework::DestroyModelMixin
   def destroy
-    self._destroy
+    self.destroy!
     api_response("")
   end
 
-  def _destroy
-    @record = self.get_record
+  def destroy!
+    @record ||= self.get_record
     @record.destroy!
   end
 end

data/lib/rest_framework/filters.rb

@@ -13,15 +13,15 @@ end
 class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   # Filter params for keys allowed by the current action's filterset_fields/fields config.
   def _get_filter_params
-    fields = @controller.get_filterset_fields
-    return @controller.request.query_parameters.select { |p, _|
-      fields.include?(p)
-    }.to_h.symbolize_keys  # convert from HashWithIndifferentAccess to Hash w/keys
+    # Map filterset fields to strings because query parameter keys are strings.
+    fields = @controller.get_filterset_fields.map(&:to_s)
+
+    return @controller.request.query_parameters.select { |p, _| fields.include?(p) }
   end
 
   # Filter data according to the request query parameters.
   def get_filtered_data(data)
-    filter_params = self._get_filter_params
+    filter_params = self._get_filter_params.symbolize_keys
     unless filter_params.blank?
       return data.where(**filter_params)
     end
@@ -36,11 +36,12 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   def _get_ordering
     return nil if @controller.class.ordering_query_param.blank?
 
-    ordering_fields = @controller.get_ordering_fields
+    # Ensure ordering_fields are strings since the split param will be strings.
+    ordering_fields = @controller.get_ordering_fields.map(&:to_s)
     order_string = @controller.params[@controller.class.ordering_query_param]
 
     unless order_string.blank?
-      ordering = {}
+      ordering = {}.with_indifferent_access
       order_string.split(",").each do |field|
         if field[0] == "-"
           column = field[1..-1]
@@ -50,7 +51,7 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
           direction = :asc
         end
         if column.in?(ordering_fields)
-          ordering[column.to_sym] = direction
+          ordering[column] = direction
         end
       end
       return ordering

data/lib/rest_framework/routers.rb

@@ -6,7 +6,7 @@ module ActionDispatch::Routing
     # 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.to_s.camelize  # Camelize to leave plural names plural.
       name = name.pluralize if pluralize
       if name == name.pluralize
         name_reverse = name.singularize

data/lib/rest_framework/serializers.rb

@@ -1,21 +1,38 @@
 # The base serializer defines the interface for all REST Framework serializers.
 class RESTFramework::BaseSerializer
+  # Add `object` accessor to be compatible with `ActiveModel::Serializer`.
   attr_accessor :object
 
-  def initialize(object=nil, controller: nil, **kwargs)
+  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
+  def initialize(object=nil, *args, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
 
   # The primary interface for extracting a native Ruby types. This works both for records and
-  # collections.
-  def serialize(**kwargs)
+  # collections. We accept and ignore `*args` for compatibility with `active_model_serializers`.
+  def serialize(*args)
     raise NotImplementedError
   end
 
-  # Synonym for `serializable_hash` or compatibility with ActiveModelSerializers.
-  def serializable_hash(**kwargs)
-    return self.serialize(**kwargs)
+  # Synonym for `serialize` for compatibility with `active_model_serializers`.
+  def serializable_hash(*args)
+    return self.serialize(*args)
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.fragment_cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def associations(*args, **kwargs)
+    return []
   end
 end
 
@@ -27,8 +44,9 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :plural_config
   class_attribute :action_config
 
-  def initialize(object=nil, many: nil, model: nil, **kwargs)
-    super(object, **kwargs)
+  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
+  def initialize(object=nil, *args, many: nil, model: nil, **kwargs)
+    super(object, *args, **kwargs)
 
     if many.nil?
       # Determine if we are dealing with many objects or just one.
@@ -146,10 +164,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
       except = except.split(",").map(&:strip).map(&:to_sym)
 
       unless except.empty?
-        # Duplicate the cfg to avoid mutating class state.
-        cfg = cfg.deep_dup
-
-        # Filter `only`, `except` (additive), `include`, and `methods`.
+        # Filter `only`, `except` (additive), `include`, `methods`, and `serializer_methods`.
         if cfg[:only]
           cfg[:only] = self.class.filter_subcfg(cfg[:only], except: except)
         else
@@ -157,14 +172,14 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
         end
         cfg[:include] = self.class.filter_subcfg(cfg[:include], except: except)
         cfg[:methods] = self.class.filter_subcfg(cfg[:methods], except: except)
+        cfg[:serializer_methods] = self.class.filter_subcfg(
+          cfg[:serializer_methods], except: except
+        )
       end
     elsif only_param && only = @controller.request.query_parameters[only_param].presence
       only = only.split(",").map(&:strip).map(&:to_sym)
 
       unless only.empty?
-        # Duplicate the cfg to avoid mutating class state.
-        cfg = cfg.deep_dup
-
         # For the `except` part of the serializer, we need to append any columns not in `only`.
         model = @controller.get_model
         except_cols = model&.column_names&.map(&:to_sym)&.reject { |c| c.in?(only) }
@@ -177,27 +192,31 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
         end
         cfg[:include] = self.class.filter_subcfg(cfg[:include], only: only)
         cfg[:methods] = self.class.filter_subcfg(cfg[:methods], only: only)
+        cfg[:serializer_methods] = self.class.filter_subcfg(cfg[:serializer_methods], only: only)
       end
     end
 
     return cfg
   end
 
-  # Get the raw serializer config.
+  # Get the raw serializer config. Use `deep_dup` on any class mutables (array, hash, etc) to avoid
+  # mutating class state.
   def _get_raw_serializer_config
     # Return a locally defined serializer config if one is defined.
     if local_config = self.get_local_native_serializer_config
-      return local_config
+      return local_config.deep_dup
     end
 
     # Return a serializer config if one is defined on the controller.
     if serializer_config = self.get_controller_native_serializer_config
-      return serializer_config
+      return serializer_config.deep_dup
     end
 
     # If the config wasn't determined, build a serializer config from model fields.
     fields = @controller.get_fields if @controller
     if fields
+      fields = fields.deep_dup
+
       if @model
         columns, methods = fields.partition { |f| f.in?(@model.column_names) }
       else
@@ -214,15 +233,31 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
 
   # Get a configuration passable to `serializable_hash` for the object, filtered if required.
   def get_serializer_config
-    return @_serializer_config ||= filter_except(self._get_raw_serializer_config)
+    return filter_except(self._get_raw_serializer_config)
+  end
+
+  # Internal helper to serialize a single record and merge results of `serializer_methods`.
+  def _serialize(record, config, serializer_methods)
+    # Ensure serializer_methods is either falsy, or an array.
+    if serializer_methods && !serializer_methods.respond_to?(:to_ary)
+      serializer_methods = [serializer_methods]
+    end
+
+    # Merge serialized record with any serializer method results.
+    return record.serializable_hash(config).merge(
+      serializer_methods&.map { |m| [m.to_sym, self.send(m, record)] }.to_h,
+    )
   end
 
-  def serialize(**kwargs)
+  def serialize(*args)
+    config = self.get_serializer_config
+    serializer_methods = config.delete(:serializer_methods)
+
     if @object.respond_to?(:to_ary)
-      return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
+      return @object.map { |r| self._serialize(r, config, serializer_methods) }
     end
 
-    return @object.serializable_hash(self.get_serializer_config)
+    return self._serialize(@object, config, serializer_methods)
   end
 
   # Allow a serializer instance to be used as a hash directly in a nested serializer config.

data/lib/rest_framework/utils.rb

@@ -9,7 +9,7 @@ module RESTFramework::Utils
       path = k
 
       # Convert structure to path/methods/kwargs.
-      if v.is_a?(Hash)  # allow kwargs
+      if v.is_a?(Hash)  # Allow kwargs to be used to define path differently from the key.
         v = v.symbolize_keys
 
         # Ensure methods is an array.
@@ -49,7 +49,7 @@ module RESTFramework::Utils
 
   # Helper to normalize a path pattern by replacing URL params with generic placeholder, and
   # removing the `(.:format)` at the end.
-  def self.normalize_path(path)
+  def self.comparable_path(path)
     return path.gsub("(.:format)", "").gsub(/:[0-9A-Za-z_-]+/, ":x")
   end
 
@@ -58,7 +58,7 @@ module RESTFramework::Utils
     current_route ||= self.get_request_route(application_routes, request)
     current_path = current_route.path.spec.to_s
     current_levels = current_path.count("/")
-    current_normalized_path = self.normalize_path(current_path)
+    current_comparable_path = self.comparable_path(current_path)
 
     # Return routes that match our current route subdomain/pattern, grouped by controller. We
     # precompute certain properties of the route for performance.
@@ -77,8 +77,9 @@ module RESTFramework::Utils
         route: r,
         verb: r.verb,
         path: path,
-        normalized_path: self.normalize_path(path),
-        relative_path: path.split("/")[current_levels..]&.join("/"),
+        comparable_path: self.comparable_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("/")&.gsub("(.:format)", ""),
         controller: r.defaults[:controller].presence,
         action: r.defaults[:action].presence,
         subdomain: r.defaults[:subdomain].presence,
@@ -87,8 +88,8 @@ module RESTFramework::Utils
       }
     }.select { |r|
       (
-        r[:subdomain] == request.subdomain.presence &&
-        r[:normalized_path].start_with?(current_normalized_path) &&
+        (!r[:subdomain] || r[:subdomain] == request.subdomain.presence) &&
+        r[:comparable_path].start_with?(current_comparable_path) &&
         r[:controller] &&
         r[:action]
       )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.7
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-14 00:00:00.000000000 Z
+date: 2022-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails