rest_framework 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e654cef83c3cf4505697e0417d637489a248b691ca157100b6a12dc3e0f3f9e
-  data.tar.gz: b656446d2fd724e2b91708e4df6248cd5e6676a311e8cd23d76f07951758bffd
+  metadata.gz: 9791b0cbb0a806afa00955abf151c7d04bd1820bdbe189f237badc9782f87d6b
+  data.tar.gz: 69e29341f8804fac7894c0065b0f5535d88b0e8d60577bc77677fe13d633f2d5
 SHA512:
-  metadata.gz: 3a9ee1d172c5e33813352b2190f2f38540226d93d84bf77cca34fab326231f6215a702c66e3965f5239d652e35eeb36a7286210826608e11ab9a35c8edf65704
-  data.tar.gz: e132e15651e2c9fd0cd9d1338ec2c5a795d369a6a001c2e4a957c7912dfd5539ea940945ea48c011e1c4be6e3b1feaf55b63934fdff5608135c2ac089fd83486
+  metadata.gz: f04bf8059e765db9e13a9729db43c2b26a914035063fe728e9ad0bcb1ab968bb8939a4d278e239a39f64b671d183bfdd7a2487248495cd7e5bd26b93ac49a103
+  data.tar.gz: '0908d43c8b2188e4dde5920a84eb621c0dea2dc170891e314d77d95b823a32af6681ae9a6028277f32282b88be03f8e95da55ec310f75e3c89ec8c3a09934f09'

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Gregory N. Schmit
+Copyright (c) 2022 Gregory N. Schmit
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.5.0

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,7 +1,6 @@
-require_relative '../errors'
-require_relative '../serializers'
-require_relative '../utils'
-
+require_relative "../errors"
+require_relative "../serializers"
+require_relative "../utils"
 
 # This module provides the common functionality for any controller mixins, a `root` action, and
 # the ability to route arbitrary actions with `extra_actions`. This is also where `api_response`
@@ -30,8 +29,8 @@ module RESTFramework::BaseControllerMixin
   end
 
   def self.included(base)
-    if base.is_a? Class
-      base.extend ClassMethods
+    if base.is_a?(Class)
+      base.extend(ClassMethods)
 
       # Add class attributes (with defaults) unless they already exist.
       {
@@ -43,8 +42,8 @@ module RESTFramework::BaseControllerMixin
         filter_backends: nil,
         paginator_class: nil,
         page_size: 20,
-        page_query_param: 'page',
-        page_size_query_param: 'page_size',
+        page_query_param: "page",
+        page_size_query_param: "page_size",
         max_page_size: nil,
         serializer_class: nil,
         serialize_to_json: true,
@@ -52,13 +51,13 @@ module RESTFramework::BaseControllerMixin
         singleton_controller: nil,
         skip_actions: nil,
       }.each do |a, default|
-        unless base.respond_to?(a)
-          base.class_attribute(a)
+        next if base.respond_to?(a)
 
-          # Set default manually so we can still support Rails 4. Maybe later we can use the default
-          # parameter on `class_attribute`.
-          base.send(:"#{a}=", default)
-        end
+        base.class_attribute(a)
+
+        # Set default manually so we can still support Rails 4. Maybe later we can use the default
+        # parameter on `class_attribute`.
+        base.send(:"#{a}=", default)
       end
 
       # Alias `extra_actions` to `extra_collection_actions`.
@@ -68,7 +67,11 @@ module RESTFramework::BaseControllerMixin
       end
 
       # Skip csrf since this is an API.
-      base.skip_before_action(:verify_authenticity_token) rescue nil
+      begin
+        base.skip_before_action(:verify_authenticity_token)
+      rescue
+        nil
+      end
 
       # Handle some common exceptions.
       base.rescue_from(ActiveRecord::RecordNotFound, with: :record_not_found)
@@ -82,7 +85,14 @@ module RESTFramework::BaseControllerMixin
 
   # Helper to get the configured serializer class.
   def get_serializer_class
-    return self.class.serializer_class
+    return nil unless serializer_class = self.class.serializer_class
+
+    # Wrap it with an adapter if it's an active_model_serializer.
+    if defined?(ActiveModel::Serializer) && (serializer_class < ActiveModel::Serializer)
+      serializer_class = RESTFramework::ActiveModelSerializerAdapterFactory.for(serializer_class)
+    end
+
+    return serializer_class
   end
 
   # Helper to get filtering backends, defaulting to no backends.
@@ -101,9 +111,9 @@ module RESTFramework::BaseControllerMixin
   end
 
   def record_invalid(e)
-    return api_response({
-      message: "Record invalid.", exception: e, errors: e.record&.errors
-    }, status: 400)
+    return api_response(
+      {message: "Record invalid.", exception: e, errors: e.record&.errors}, status: 400
+    )
   end
 
   def record_not_found(e)
@@ -111,15 +121,15 @@ module RESTFramework::BaseControllerMixin
   end
 
   def record_not_saved(e)
-    return api_response({
-      message: "Record not saved.", exception: e, errors: e.record&.errors
-    }, status: 406)
+    return api_response(
+      {message: "Record not saved.", exception: e, errors: e.record&.errors}, status: 406
+    )
   end
 
   def record_not_destroyed(e)
-    return api_response({
-      message: "Record not destroyed.", exception: e, errors: e.record&.errors
-    }, status: 406)
+    return api_response(
+      {message: "Record not destroyed.", exception: e, errors: e.record&.errors}, status: 406
+    )
   end
 
   # Helper to render a browsable API for `html` format, along with basic `json`/`xml` formats, and
@@ -138,38 +148,38 @@ module RESTFramework::BaseControllerMixin
     end
 
     respond_to do |format|
-      if payload == ''
-        format.json {head :no_content} if self.serialize_to_json
-        format.xml {head :no_content} if self.serialize_to_xml
+      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.serialize_to_json
+        } if self.class.serialize_to_json
         format.xml {
           xkwargs = kwargs.merge(xml_kwargs)
           render(xml: payload, layout: false, **xkwargs)
-        } if self.serialize_to_xml
+        } 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.serialize_to_json
-          @xml_payload = '' if self.serialize_to_xml
+        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.serialize_to_json
-          @xml_payload = payload.to_xml if self.serialize_to_xml
+          @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)
+        @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] = ''
+          hkwargs[:html] = ""
           render(**hkwargs)
         end
       }

data/lib/rest_framework/controller_mixins/models.rb

@@ -1,13 +1,12 @@
-require_relative 'base'
-require_relative '../filters'
-
+require_relative "base"
+require_relative "../filters"
 
 # This module provides the core functionality for controllers based on models.
 module RESTFramework::BaseModelControllerMixin
   include RESTFramework::BaseControllerMixin
 
   def self.included(base)
-    if base.is_a? Class
+    if base.is_a?(Class)
       RESTFramework::BaseControllerMixin.included(base)
 
       # Add class attributes (with defaults) unless they already exist.
@@ -22,7 +21,7 @@ module RESTFramework::BaseModelControllerMixin
 
         # Attributes for finding records.
         find_by_fields: nil,
-        find_by_query_param: 'find_by',
+        find_by_query_param: "find_by",
 
         # Attributes for create/update parameters.
         allowed_parameters: nil,
@@ -32,27 +31,28 @@ module RESTFramework::BaseModelControllerMixin
         native_serializer_config: nil,
         native_serializer_singular_config: nil,
         native_serializer_plural_config: nil,
+        native_serializer_except_query_param: "except",
 
         # Attributes for default model filtering (and ordering).
         filterset_fields: nil,
         ordering_fields: nil,
-        ordering_query_param: 'ordering',
+        ordering_query_param: "ordering",
         ordering_no_reorder: false,
         search_fields: nil,
-        search_query_param: 'search',
+        search_query_param: "search",
         search_ilike: false,
 
         # Other misc attributes.
         create_from_recordset: true,  # Option for `recordset.create` vs `Model.create` behavior.
         filter_recordset_before_find: true,  # Option to control if filtering is done before find.
       }.each do |a, default|
-        unless base.respond_to?(a)
-          base.class_attribute(a)
+        next if base.respond_to?(a)
 
-          # Set default manually so we can still support Rails 4. Maybe later we can use the default
-          # parameter on `class_attribute`.
-          base.send(:"#{a}=", default)
-        end
+        base.class_attribute(a)
+
+        # Set default manually so we can still support Rails 4. Maybe later we can use the default
+        # parameter on `class_attribute`.
+        base.send(:"#{a}=", default)
       end
     end
   end
@@ -105,7 +105,7 @@ module RESTFramework::BaseModelControllerMixin
 
   # Helper to get the configured serializer class, or `NativeSerializer` as a default.
   def get_serializer_class
-    return self.class.serializer_class || RESTFramework::NativeSerializer
+    return super || RESTFramework::NativeSerializer
   end
 
   # Helper to get filtering backends, defaulting to using `ModelFilter` and `ModelOrderingFilter`.
@@ -143,8 +143,8 @@ module RESTFramework::BaseModelControllerMixin
       body_params
     end
   end
-  alias :get_create_params :get_body_params
-  alias :get_update_params :get_body_params
+  alias_method :get_create_params, :get_body_params
+  alias_method :get_update_params, :get_body_params
 
   # Get the model for this controller.
   def get_model(from_get_recordset: false)
@@ -160,7 +160,7 @@ module RESTFramework::BaseModelControllerMixin
 
     # Try to determine model from controller name.
     begin
-      return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
+      return @model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize
     rescue NameError
     end
 
@@ -196,48 +196,51 @@ module RESTFramework::BaseModelControllerMixin
       recordset = self.get_filtered_data(recordset)
     end
 
-    # Return the record.
-    if find_by_value = params[:id]  # Route key is always :id by Rails convention.
-      return self.get_recordset.find_by!(find_by_key => find_by_value)
-    end
-    return nil
+    # Return the record. Route key is always :id by Rails convention.
+    return recordset.find_by!(find_by_key => params[:id])
   end
 end
 
-
 # Mixin for listing records.
 module RESTFramework::ListModelMixin
   def index
+    api_response(self._index)
+  end
+
+  def _index
     @records = self.get_filtered_data(self.get_recordset)
 
     # Handle pagination, if enabled.
     if self.class.paginator_class
       paginator = self.class.paginator_class.new(data: @records, controller: self)
       page = paginator.get_page
-      serialized_page = self.get_serializer_class.new(object: page, controller: self).serialize
-      data = paginator.get_paginated_response(serialized_page)
+      serialized_page = self.get_serializer_class.new(page, controller: self).serialize
+      return paginator.get_paginated_response(serialized_page)
     else
-      data = self.get_serializer_class.new(object: @records, controller: self).serialize
+      return self.get_serializer_class.new(@records, controller: self).serialize
     end
-
-    return api_response(data)
   end
 end
 
-
 # Mixin for showing records.
 module RESTFramework::ShowModelMixin
   def show
+    api_response(self._show)
+  end
+
+  def _show
     @record = self.get_record
-    serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
-    return api_response(serialized_record)
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for creating records.
 module RESTFramework::CreateModelMixin
   def create
+    api_response(self._create)
+  end
+
+  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)
@@ -245,39 +248,43 @@ module RESTFramework::CreateModelMixin
       # Otherwise, perform a "bare" create.
       @record = self.get_model.create!(self.get_create_params)
     end
-    serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
-    return api_response(serialized_record)
+
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for updating records.
 module RESTFramework::UpdateModelMixin
   def update
+    api_response(self._update)
+  end
+
+  def _update
     @record = self.get_record
     @record.update!(self.get_update_params)
-    serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
-    return api_response(serialized_record)
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for destroying records.
 module RESTFramework::DestroyModelMixin
   def destroy
+    self._destroy
+    api_response("")
+  end
+
+  def _destroy
     @record = self.get_record
     @record.destroy!
-    api_response('')
   end
 end
 
-
 # Mixin that includes show/list mixins.
 module RESTFramework::ReadOnlyModelControllerMixin
   include RESTFramework::BaseModelControllerMixin
 
   def self.included(base)
-    if base.is_a? Class
+    if base.is_a?(Class)
       RESTFramework::BaseModelControllerMixin.included(base)
     end
   end
@@ -286,13 +293,12 @@ module RESTFramework::ReadOnlyModelControllerMixin
   include RESTFramework::ShowModelMixin
 end
 
-
 # Mixin that includes all the CRUD mixins.
 module RESTFramework::ModelControllerMixin
   include RESTFramework::BaseModelControllerMixin
 
   def self.included(base)
-    if base.is_a? Class
+    if base.is_a?(Class)
       RESTFramework::BaseModelControllerMixin.included(base)
     end
   end

data/lib/rest_framework/controller_mixins.rb

@@ -1,6 +1,5 @@
 module RESTFramework::ControllerMixins
 end
 
-
-require_relative 'controller_mixins/base'
-require_relative 'controller_mixins/models'
+require_relative "controller_mixins/base"
+require_relative "controller_mixins/models"

data/lib/rest_framework/errors.rb

@@ -2,10 +2,9 @@
 class RESTFramework::Error < StandardError
 end
 
-
 class RESTFramework::NilPassedToAPIResponseError < RESTFramework::Error
   def message
-    return <<~MSG.split("\n").join(' ')
+    return <<~MSG.split("\n").join(" ")
       Payload of `nil` was passed to `api_response`; this is unsupported. If you want a blank
       response, pass `''` (an empty string) as the payload. If this was the result of a `find_by`
       (or similar Active Record method) not finding a record, you should use the bang version (e.g.,

data/lib/rest_framework/filters.rb

@@ -8,7 +8,6 @@ class RESTFramework::BaseFilter
   end
 end
 
-
 # A simple filtering backend that supports filtering a recordset based on fields defined on the
 # controller class.
 class RESTFramework::ModelFilter < RESTFramework::BaseFilter
@@ -31,19 +30,19 @@ class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   end
 end
 
-
 # A filter backend which handles ordering of the recordset.
 class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   # Convert ordering string to an ordering configuration.
   def _get_ordering
     return nil if @controller.class.ordering_query_param.blank?
+
     ordering_fields = @controller.send(:get_ordering_fields)
     order_string = @controller.params[@controller.class.ordering_query_param]
 
     unless order_string.blank?
       ordering = {}
-      order_string.split(',').each do |field|
-        if field[0] == '-'
+      order_string.split(",").each do |field|
+        if field[0] == "-"
           column = field[1..-1]
           direction = :desc
         else
@@ -63,7 +62,7 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   # Order data according to the request query parameters.
   def get_filtered_data(data)
     ordering = self._get_ordering
-    reorder = !@controller.send(:ordering_no_reorder)
+    reorder = !@controller.class.ordering_no_reorder
 
     if ordering && !ordering.empty?
       return data.send(reorder ? :reorder : :order, _get_ordering)
@@ -73,19 +72,21 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   end
 end
 
-
 # Multi-field text searching on models.
 class RESTFramework::ModelSearchFilter < RESTFramework::BaseFilter
   # Filter data according to the request query parameters.
   def get_filtered_data(data)
     fields = @controller.send(:get_search_fields)
-    search = @controller.request.query_parameters[@controller.send(:search_query_param)]
+    search = @controller.request.query_parameters[@controller.class.search_query_param]
 
     # Ensure we use array conditions to prevent SQL injection.
     unless search.blank?
-      return data.where(fields.map { |f|
-        "CAST(#{f} AS CHAR) #{@controller.send(:search_ilike) ? "ILIKE" : "LIKE"} ?"
-      }.join(' OR '), *(["%#{search}%"] * fields.length))
+      return data.where(
+        fields.map { |f|
+          "CAST(#{f} AS CHAR) #{@controller.class.search_ilike ? "ILIKE" : "LIKE"} ?"
+        }.join(" OR "),
+        *(["%#{search}%"] * fields.length),
+      )
     end
 
     return data

data/lib/rest_framework/generators/controller_generator.rb

@@ -1,7 +1,6 @@
-require 'rails/generators'
+require "rails/generators"
 
-
-# Some projects don't have the inflection "REST" as an acronym, so this is a helper class to prevent
+# Most projects don't have the inflection "REST" as an acronym, so this is a helper class to prevent
 # this generator from being namespaced under `r_e_s_t_framework`.
 # :nocov:
 class RESTFrameworkCustomGeneratorControllerNamespace < String
@@ -11,18 +10,17 @@ class RESTFrameworkCustomGeneratorControllerNamespace < String
 end
 # :nocov:
 
-
 class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
-  PATH_REGEX = /^\/*([a-z0-9_\/]*[a-z0-9_])(?:[\.a-z\/]*)$/
+  PATH_REGEX = %r{^[a-z0-9][a-z0-9_/]+$}
 
   desc <<~END
-  Description:
+    Description:
       Generates a new REST Framework controller.
 
       Specify the controller as a path, including the module, if needed, like:
       'parent_module/controller_name'.
 
-  Example:
+    Example:
       `rails generate rest_framework:controller user_api/groups`
 
       Generates a controller at `app/controllers/user_api/groups_controller.rb` named
@@ -31,10 +29,7 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
 
   argument :path, type: :string
   class_option(
-    :parent_class,
-    type: :string,
-    default: 'ApplicationController',
-    desc: "Inheritance parent",
+    :parent_class, type: :string, default: "ApplicationController", desc: "Inheritance parent"
   )
   class_option(
     :include_base,
@@ -50,11 +45,13 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
   end
 
   def create_rest_controller_file
-    unless (path_match = PATH_REGEX.match(self.path))
-      raise StandardError.new("Path isn't correct.")
+    unless PATH_REGEX.match?(self.path)
+      raise StandardError, "Path isn't valid."
     end
 
-    cleaned_path = path_match[1]
+    # Remove '_controller' from end of path, if it exists.
+    cleaned_path = self.path.delete_suffix("_controller")
+
     content = <<~END
       class #{cleaned_path.camelize}Controller < #{options[:parent_class]}
         include RESTFramework::#{
@@ -62,6 +59,6 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
         }
       end
     END
-    create_file("app/controllers/#{path}_controller.rb", content)
+    create_file("app/controllers/#{cleaned_path}_controller.rb", content)
   end
 end

data/lib/rest_framework/generators.rb

@@ -1,5 +1,4 @@
 module RESTFramework::Generators
 end
 
-
-require_relative 'generators/controller_generator'
+require_relative "generators/controller_generator"

data/lib/rest_framework/paginators.rb

@@ -15,7 +15,6 @@ class RESTFramework::BasePaginator
   end
 end
 
-
 # A simple paginator based on page numbers.
 #
 # Example: http://example.com/api/users/?page=3&page_size=50
@@ -26,7 +25,7 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
     @page_size = self._page_size
 
     @total_pages = @count / @page_size
-    @total_pages += 1 if (@count % @page_size != 0)
+    @total_pages += 1 if @count % @page_size != 0
   end
 
   def _page_size
@@ -60,7 +59,7 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
   # 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
+    unless page_number
       page_number = @controller&.params&.[](self._page_query_param)
       if page_number.blank?
         page_number = 1
@@ -90,7 +89,6 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
   end
 end
 
-
 # TODO: implement this
 # class RESTFramework::CountOffsetPaginator
 # end

data/lib/rest_framework/routers.rb

@@ -1,11 +1,11 @@
-require 'action_dispatch/routing/mapper'
-require_relative 'utils'
+require "action_dispatch/routing/mapper"
+require_relative "utils"
 
 module ActionDispatch::Routing
   class Mapper
     # Internal interface to get the controller class from the name and current scope.
     protected def _get_controller_class(name, pluralize: true, fallback_reverse_pluralization: true)
-      # get class name
+      # Get class name.
       name = name.to_s.camelize  # camelize to leave plural names plural
       name = name.pluralize if pluralize
       if name == name.pluralize
@@ -16,14 +16,14 @@ module ActionDispatch::Routing
       name += "Controller"
       name_reverse += "Controller"
 
-      # get scope for the class
+      # Get scope for the class.
       if @scope[:module]
         mod = @scope[:module].to_s.classify.constantize
       else
         mod = Object
       end
 
-      # convert class name to class
+      # Convert class name to class.
       begin
         controller = mod.const_get(name)
       rescue NameError
@@ -83,15 +83,15 @@ module ActionDispatch::Routing
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do
-            actions = RESTFramework::Utils::parse_extra_actions(
-              controller_class.extra_member_actions
+            actions = RESTFramework::Utils.parse_extra_actions(
+              controller_class.extra_member_actions,
             )
             self._route_extra_actions(actions)
           end
         end
 
         collection do
-          actions = RESTFramework::Utils::parse_extra_actions(controller_class.extra_actions)
+          actions = RESTFramework::Utils.parse_extra_actions(controller_class.extra_actions)
           self._route_extra_actions(actions)
         end
 
@@ -127,11 +127,11 @@ module ActionDispatch::Routing
       kwargs[:controller] = name unless kwargs[:controller]
 
       # Route actions using the resourceful router, but skip all builtin actions.
-      actions = RESTFramework::Utils::parse_extra_actions(controller_class.extra_actions)
+      actions = RESTFramework::Utils.parse_extra_actions(controller_class.extra_actions)
       public_send(:resource, name, only: [], **kwargs) do
         # Route a root for this resource.
         if route_root_to
-          get '', action: route_root_to
+          get("", action: route_root_to)
         end
 
         self._route_extra_actions(actions, &block)
@@ -146,13 +146,12 @@ module ActionDispatch::Routing
 
       # Remove path if name is nil (routing to the root of current namespace).
       unless name
-        kwargs[:path] = ''
+        kwargs[:path] = ""
       end
 
       return rest_route(controller, route_root_to: root_action, **kwargs) do
         yield if block_given?
       end
     end
-
   end
 end

data/lib/rest_framework/serializers.rb

@@ -1,14 +1,23 @@
+# The base serializer defines the interface for all REST Framework serializers.
 class RESTFramework::BaseSerializer
-  def initialize(object: nil, controller: nil, **kwargs)
+  attr_accessor :object
+
+  def initialize(object=nil, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
 
-  def serialize
+  # The primary interface for extracting a native Ruby types. This works both for records and
+  # collections.
+  def serialize(**kwargs)
     raise NotImplementedError
   end
-end
 
+  # Synonym for `serializable_hash` or compatibility with ActiveModelSerializers.
+  def serializable_hash(**kwargs)
+    return self.serialize(**kwargs)
+  end
+end
 
 # This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
 # top-level being either an array or a hash).
@@ -18,8 +27,8 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :plural_config
   class_attribute :action_config
 
-  def initialize(many: nil, model: nil, **kwargs)
-    super(**kwargs)
+  def initialize(object=nil, many: nil, model: nil, **kwargs)
+    super(object, **kwargs)
 
     if many.nil?
       # Determine if we are dealing with many objects or just one.
@@ -31,9 +40,9 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     # Determine model either explicitly, or by inspecting @object or @controller.
     @model = model
     @model ||= @object.class if @object.is_a?(ActiveRecord::Base)
-    @model ||= @object[0].class if (
+    @model ||= @object[0].class if
       @many && @object.is_a?(Enumerable) && @object.is_a?(ActiveRecord::Base)
-    )
+
     @model ||= @controller.send(:get_model) if @controller
   end
 
@@ -66,23 +75,66 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return nil unless @controller
 
     if @many == true
-      controller_serializer = @controller.try(:native_serializer_plural_config)
+      controller_serializer = @controller.class.try(:native_serializer_plural_config)
     elsif @many == false
-      controller_serializer = @controller.try(:native_serializer_singular_config)
+      controller_serializer = @controller.class.try(:native_serializer_singular_config)
     end
 
-    return controller_serializer || @controller.try(:native_serializer_config)
+    return controller_serializer || @controller.class.try(:native_serializer_config)
   end
 
-  # Get a configuration passable to `serializable_hash` for the object.
-  def get_serializer_config
+  # Helper to filter (mutate) a single subconfig for specific keys.
+  def self.filter_subconfig(subconfig, except, additive: false)
+    return subconfig unless subconfig
+
+    if subconfig.is_a?(Array)
+      subconfig = subconfig.map(&:to_sym)
+      if additive
+        # Only add fields which are not already included.
+        subconfig += except - subconfig
+      else
+        subconfig -= except
+      end
+    elsif subconfig.is_a?(Hash)
+      subconfig.symbolize_keys!
+      subconfig.reject! { |k, _v| k.in?(except) }
+    end
+
+    return subconfig
+  end
+
+  # Helper to filter out configuration properties based on the :except query parameter.
+  def filter_except(config)
+    return config unless @controller
+
+    except_query_param = @controller.class.try(:native_serializer_except_query_param)
+    if except = @controller.request.query_parameters[except_query_param]
+      except = except.split(",").map(&:strip).map(&:to_sym)
+
+      unless except.empty?
+        # Duplicate the config to avoid mutating class state.
+        config = config.deep_dup
+
+        # Filter `only`, `except` (additive), `include`, and `methods`.
+        self.class.filter_subconfig(config[:only], except)
+        self.class.filter_subconfig(config[:except], except, additive: true)
+        self.class.filter_subconfig(config[:include], except)
+        self.class.filter_subconfig(config[:methods], except)
+      end
+    end
+
+    return config
+  end
+
+  # Get the raw serializer config.
+  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
     end
 
     # Return a serializer config if one is defined on the controller.
-    if serializer_config = get_controller_native_serializer_config
+    if serializer_config = self.get_controller_native_serializer_config
       return serializer_config
     end
 
@@ -103,13 +155,16 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return {}
   end
 
-  # Convert the object (record or recordset) to Ruby primitives.
-  def serialize
-    raise "No object available to serialize!" unless @object
+  # Get a configuration passable to `serializable_hash` for the object, filtered if required.
+  def get_serializer_config
+    return filter_except(self._get_raw_serializer_config)
+  end
 
-    if @object.is_a?(Enumerable)
+  def serialize(**kwargs)
+    if @object.respond_to?(:to_ary)
       return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
     end
+
     return @object.serializable_hash(self.get_serializer_config)
   end
 
@@ -118,6 +173,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     @_nested_config ||= self.get_serializer_config
     return @_nested_config[key]
   end
+
   def []=(key, value)
     @_nested_config ||= self.get_serializer_config
     return @_nested_config[key] = value
@@ -128,20 +184,20 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     @_nested_config ||= self.new.get_serializer_config
     return @_nested_config[key]
   end
+
   def self.[]=(key, value)
     @_nested_config ||= self.new.get_serializer_config
     return @_nested_config[key] = value
   end
 end
 
-
 # :nocov:
 # Alias NativeModelSerializer -> NativeSerializer.
 class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
   def initialize(**kwargs)
     super
     ActiveSupport::Deprecation.warn(
-      <<~MSG.split("\n").join(' ')
+      <<~MSG.split("\n").join(" "),
         RESTFramework::NativeModelSerializer is deprecated and will be removed in future versions of
         REST Framework; you should use RESTFramework::NativeSerializer instead.
       MSG
@@ -149,3 +205,19 @@ class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
   end
 end
 # :nocov:
+
+# 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.
+class RESTFramework::ActiveModelSerializerAdapterFactory
+  def self.for(active_model_serializer)
+    return Class.new(active_model_serializer) do
+      def serialize
+        if self.object.respond_to?(:to_ary)
+          return self.object.map { |r| self.class.superclass.new(r).serializable_hash }
+        end
+
+        return self.serializable_hash
+      end
+    end
+  end
+end

data/lib/rest_framework/utils.rb

@@ -2,7 +2,7 @@ module RESTFramework::Utils
   # Helper to take extra_actions hash and convert to a consistent format:
   # `{paths:, methods:, kwargs:}`.
   def self.parse_extra_actions(extra_actions)
-    return (extra_actions || {}).map do |k,v|
+    return (extra_actions || {}).map do |k, v|
       kwargs = {action: k}
       path = k
 
@@ -38,7 +38,7 @@ module RESTFramework::Utils
   # Helper to get the current route pattern, stripped of the `(:format)` segment.
   def self.get_route_pattern(application_routes, request)
     application_routes.router.recognize(request) do |route, _, _|
-      return route.path.spec.to_s.gsub(/\(\.:format\)$/, '')
+      return route.path.spec.to_s.gsub(/\(\.:format\)$/, "")
     end
   end
 

data/lib/rest_framework/version.rb

@@ -18,7 +18,7 @@ module RESTFramework
       end
 
       # No VERSION file, so version is unknown.
-      return 'unknown'
+      return "unknown"
     end
 
     def self.stamp_version
@@ -30,5 +30,5 @@ module RESTFramework
     end
   end
 
-  VERSION = Version.get_version()
+  VERSION = Version.get_version
 end

data/lib/rest_framework.rb

@@ -1,7 +1,6 @@
 module RESTFramework
 end
 
-
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
 require_relative "rest_framework/errors"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-10 00:00:00.000000000 Z
+date: 2022-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: A framework for DRY RESTful APIs in Ruby on Rails.