rest_framework 0.1.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cb7ba6d5e7861525dca18f908afa1f398f614af654223ac03de15f7014dafaa
-  data.tar.gz: 7938b5b0225e089f2cd3a168b80763ebcc63dd65655ae4c87b045e923477191a
+  metadata.gz: '09c24135bd79001e0113aa92f21e63c5dcb67e93891db2a5df36b4d83d1c5da2'
+  data.tar.gz: ba3bd5829fdb9fd3c61a6050f5800c91a0077c76e78aedb049f850e581027f67
 SHA512:
-  metadata.gz: cb1583fe183387972e1537bc2b90ebe9b224381e46515ffd202f3ad86cb4a545f906264644fff537b5937f8e4f985f39eb3123c6d47e2e8e5c1be31b425aad54
-  data.tar.gz: 3a8b3a6e63a4ca03250d8e6697eda885abd6940f8b580f073ffa0c237a59a535d4997aa4591651c01cda61fd3f021508ed69d298a19512f783a9604b6dbcdd7c
+  metadata.gz: c89c8af64c2eeb36dba79747770df5497d8505f2a4ced03ed6e25e81804a3a8a8f656e87bb0739a31d26be8e1f0fdcdd9e3df25721766e2e5d4bb2a01d40746f
+  data.tar.gz: 4bd5bdf9f2735622a07795245f605137c0310d16b3596fc544e9ade2046744a499ea0fdf1e7f11c7f5fc49f137650cceefadcf805884e6a6df5361ed919211d4

data/README.md

@@ -2,6 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/rest_framework.svg)](https://badge.fury.io/rb/rest_framework)
 [![Build Status](https://travis-ci.org/gregschmit/rails-rest-framework.svg?branch=master)](https://travis-ci.org/gregschmit/rails-rest-framework)
+[![Coverage Status](https://coveralls.io/repos/github/gregschmit/rails-rest-framework/badge.svg?branch=master)](https://coveralls.io/github/gregschmit/rails-rest-framework?branch=master)
 
 A framework for DRY RESTful APIs in Ruby on Rails.
 
@@ -78,8 +79,8 @@ class Api::ReadOnlyMoviesController < ApiController
 end
 ```
 
-Note that you can also override `get_model` and `get_recordset` instance methods to override the API
-behavior dynamically per-request.
+Note that you can also override the `get_recordset` instance method to override the API behavior
+dynamically per-request.
 
 ### Routing
 

data/lib/rest_framework.rb

@@ -4,8 +4,10 @@ end
 
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
+require_relative "rest_framework/errors"
 require_relative "rest_framework/filters"
 require_relative "rest_framework/paginators"
 require_relative "rest_framework/routers"
 require_relative "rest_framework/serializers"
 require_relative "rest_framework/version"
+require_relative "rest_framework/generators"

data/lib/rest_framework/VERSION_STAMP

@@ -1 +1 @@
-0.1.1
+0.2.3

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,3 +1,4 @@
+require_relative '../errors'
 require_relative '../serializers'
 
 
@@ -33,6 +34,9 @@ module RESTFramework::BaseControllerMixin
 
       # Add class attributes (with defaults) unless they already exist.
       {
+        filter_pk_from_request_body: true,
+        exclude_body_fields: [:created_at, :created_by, :updated_at, :updated_by],
+        accept_generic_params_as_body_params: true,
         extra_actions: nil,
         extra_member_actions: nil,
         filter_backends: nil,
@@ -42,14 +46,16 @@ module RESTFramework::BaseControllerMixin
         page_size_query_param: 'page_size',
         max_page_size: nil,
         serializer_class: nil,
+        serialize_to_json: true,
+        serialize_to_xml: true,
         singleton_controller: nil,
         skip_actions: nil,
       }.each do |a, default|
         unless base.respond_to?(a)
           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`.
+          # 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
@@ -60,10 +66,10 @@ module RESTFramework::BaseControllerMixin
         base.alias_method(:extra_collection_actions=, :extra_actions=)
       end
 
-      # skip csrf since this is an API
+      # Skip csrf since this is an API.
       base.skip_before_action(:verify_authenticity_token) rescue nil
 
-      # handle some common exceptions
+      # Handle some common exceptions.
       base.rescue_from(ActiveRecord::RecordNotFound, with: :record_not_found)
       base.rescue_from(ActiveRecord::RecordInvalid, with: :record_invalid)
       base.rescue_from(ActiveRecord::RecordNotSaved, with: :record_not_saved)
@@ -118,7 +124,9 @@ module RESTFramework::BaseControllerMixin
     begin
       formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet
     rescue NameError
+      # :nocov:
       formatter = ActionDispatch::Routing::ConsoleFormatter
+      # :nocov:
     end
     return ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes).format(
       formatter.new
@@ -129,39 +137,42 @@ module RESTFramework::BaseControllerMixin
 
   # Helper to render a browsable API for `html` format, along with basic `json`/`xml` formats, and
   # with support or passing custom `kwargs` to the underlying `render` calls.
-  def api_response(payload, html_kwargs: nil, json_kwargs: nil, xml_kwargs: nil, **kwargs)
+  def api_response(payload, html_kwargs: nil, **kwargs)
     html_kwargs ||= {}
-    json_kwargs ||= {}
-    xml_kwargs ||= {}
-
-    # allow blank (no-content) responses
-    @blank = kwargs[:blank]
+    json_kwargs = kwargs.delete(:json_kwargs) || {}
+    xml_kwargs = kwargs.delete(:xml_kwargs) || {}
+
+    # Raise helpful error if payload is nil. Usually this happens when a record is not found (e.g.,
+    # when passing something like `User.find_by(id: some_id)` to `api_response`). The caller should
+    # actually be calling `find_by!` to raise ActiveRecord::RecordNotFound and allowing the REST
+    # framework to catch this error and return an appropriate error response.
+    if payload.nil?
+      raise RESTFramework::NilPassedToAPIResponseError
+    end
 
     respond_to do |format|
-      if @blank
-        format.json {head :no_content}
-        format.xml {head :no_content}
+      if payload == ''
+        format.json {head :no_content} if self.serialize_to_json
+        format.xml {head :no_content} if self.serialize_to_xml
       else
-        if payload.respond_to?(:to_json)
-          format.json {
-            jkwargs = kwargs.merge(json_kwargs)
-            render(json: payload, layout: false, **jkwargs)
-          }
-        end
-        if payload.respond_to?(:to_xml)
-          format.xml {
-            xkwargs = kwargs.merge(xml_kwargs)
-            render(xml: payload, layout: false, **xkwargs)
-          }
-        end
+        format.json {
+          jkwargs = kwargs.merge(json_kwargs)
+          render(json: payload, layout: false, **jkwargs)
+        } if self.serialize_to_json
+        format.xml {
+          xkwargs = kwargs.merge(xml_kwargs)
+          render(xml: payload, layout: false, **xkwargs)
+        } if self.serialize_to_xml
+        # TODO: possibly support more formats here if supported?
       end
       format.html {
         @payload = payload
-        @json_payload = ''
-        @xml_payload = ''
-        unless @blank
-          @json_payload = payload.to_json if payload.respond_to?(:to_json)
-          @xml_payload = payload.to_xml if payload.respond_to?(:to_xml)
+        if payload == ''
+          @json_payload = '' if self.serialize_to_json
+          @xml_payload = '' if self.serialize_to_xml
+        else
+          @json_payload = payload.to_json if self.serialize_to_json
+          @xml_payload = payload.to_xml if self.serialize_to_xml
         end
         @template_logo_text ||= "Rails REST Framework"
         @title ||= self.controller_name.camelize

data/lib/rest_framework/controller_mixins/models.rb

@@ -16,17 +16,18 @@ module RESTFramework::BaseModelControllerMixin
         model: nil,
         recordset: nil,
 
-        # Attributes for create/update parameters.
-        allowed_parameters: nil,
-        allowed_action_parameters: nil,
-
         # Attributes for configuring record fields.
         fields: nil,
         action_fields: nil,
 
+        # Attributes for create/update parameters.
+        allowed_parameters: nil,
+        allowed_action_parameters: nil,
+
         # Attributes for the default native serializer.
         native_serializer_config: nil,
-        native_serializer_action_config: nil,
+        native_serializer_singular_config: nil,
+        native_serializer_plural_config: nil,
 
         # Attributes for default model filtering (and ordering).
         filterset_fields: nil,
@@ -34,13 +35,13 @@ module RESTFramework::BaseModelControllerMixin
         ordering_query_param: 'ordering',
 
         # Other misc attributes.
-        disable_creation_from_recordset: nil,  # Option to disable `recordset.create` behavior.
+        disable_creation_from_recordset: false,  # Option to disable `recordset.create` behavior.
       }.each do |a, default|
         unless base.respond_to?(a)
           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`.
+          # 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
@@ -49,36 +50,34 @@ module RESTFramework::BaseModelControllerMixin
 
   protected
 
-  # Get a native serializer config for the current action.
-  # @return [RESTFramework::NativeModelSerializer]
-  def get_native_serializer_config
-    action_serializer_config = self.class.native_serializer_action_config || {}
-    action = self.action_name.to_sym
-
-    # Handle case where :index action is not defined.
-    if action == :index && !action_serializer_config.key?(:index)
-      # Default is :show if `singleton_controller`, otherwise :list.
-      action = self.class.singleton_controller ? :show : :list
-    end
+  def _get_specific_action_config(action_config_key, generic_config_key)
+    action_config = self.class.send(action_config_key) || {}
+    action = self.action_name&.to_sym
 
-    return (action_serializer_config[action] if action) || self.class.native_serializer_config
-  end
+    # Index action should use :list serializer if :index is not provided.
+    action = :list if action == :index && !action_config.key?(:index)
 
-  # Helper to get the configured serializer class, or `NativeModelSerializer` as a default.
-  # @return [RESTFramework::BaseSerializer]
-  def get_serializer_class
-    return self.class.serializer_class || RESTFramework::NativeModelSerializer
+    return (action_config[action] if action) || self.class.send(generic_config_key)
   end
 
   # Get a list of parameters allowed for the current action.
   def get_allowed_parameters
-    allowed_action_parameters = self.class.allowed_action_parameters || {}
-    action = self.action_name.to_sym
+    return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)&.map(&:to_s)
+  end
 
-    # index action should use :list allowed parameters if :index is not provided
-    action = :list if action == :index && !allowed_action_parameters.key?(:index)
+  # 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 ||
+      []
+    )
+  end
 
-    return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
+  # Helper to get the configured serializer class, or `NativeSerializer` as a default.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class || RESTFramework::NativeSerializer
   end
 
   # Get the list of filtering backends to use.
@@ -89,70 +88,81 @@ module RESTFramework::BaseModelControllerMixin
     ]
   end
 
-  # Get a list of fields for the current action.
-  def get_fields
-    action_fields = self.class.action_fields || {}
-    action = self.action_name.to_sym
+  # 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
+
+      # Filter the request body.
+      body_params = request.request_parameters.select { |p|
+        fields.include?(p)
+      }
+
+      # Add query params in place of missing body params, if configured.
+      if self.class.accept_generic_params_as_body_params
+        (fields - body_params.keys).each do |k|
+          if (value = params[k])
+            body_params[k] = value
+          end
+        end
+      end
 
-    # index action should use :list fields if :index is not provided
-    action = :list if action == :index && !action_fields.key?(:index)
+      # Filter primary key if configured.
+      if self.class.filter_pk_from_request_body
+        body_params.delete(self.get_model&.primary_key)
+      end
 
-    return (action_fields[action] if action) || self.class.fields || []
-  end
+      # Filter fields in exclude_body_fields.
+      (self.class.exclude_body_fields || []).each do |f|
+        body_params.delete(f.to_s)
+      end
 
-  # Filter the request body for keys in current action's allowed_parameters/fields config.
-  def get_body_params
-    fields = self.get_allowed_parameters || self.get_fields
-    return @get_body_params ||= (request.request_parameters.select { |p|
-      fields.include?(p.to_sym) || fields.include?(p.to_s)
-    })
+      body_params
+    end
   end
   alias :get_create_params :get_body_params
   alias :get_update_params :get_body_params
 
-  # Get a record by the primary key from the filtered recordset.
+  # Get a record by the primary key from the (non-filtered) recordset.
   def get_record
-    records = self.get_filtered_data(self.get_recordset)
-    if pk = params[self.model.primary_key]
-      return records.find(pk)
+    if pk = params[self.get_model.primary_key]
+      return self.get_recordset.find(pk)
     end
     return nil
   end
 
-  # Internal interface for get_model, protecting against infinite recursion with get_recordset.
-  def _get_model(from_internal_get_recordset: false)
+  # Get the model for this controller.
+  def get_model(from_get_recordset: false)
     return @model if instance_variable_defined?(:@model) && @model
-    return self.class.model if self.class.model
-    unless from_internal_get_recordset  # prevent infinite recursion
-      recordset = self._get_recordset(from_internal_get_model: true)
-      return (@model = recordset.klass) if recordset
+    return (@model = self.class.model) if self.class.model
+
+    # Delegate to the recordset's model, if it's defined.
+    unless from_get_recordset  # prevent infinite recursion
+      if (recordset = self.get_recordset)
+        return @model = recordset.klass
+      end
     end
+
+    # Try to determine model from controller name.
     begin
       return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
     rescue NameError
     end
-    return nil
-  end
 
-  # Internal interface for get_recordset, protecting against infinite recursion with get_model.
-  def _get_recordset(from_internal_get_model: false)
-    return @recordset if instance_variable_defined?(:@recordset) && @recordset
-    return self.class.recordset if self.class.recordset
-    unless from_internal_get_model  # prevent infinite recursion
-      model = self._get_model(from_internal_get_recordset: true)
-      return (@recordset = model.all) if model
-    end
     return nil
   end
 
-  # Get the model for this controller.
-  def get_model
-    return _get_model
-  end
-
   # Get the set of records this controller has access to.
   def get_recordset
-    return _get_recordset
+    return @recordset if instance_variable_defined?(:@recordset) && @recordset
+    return (@recordset = self.class.recordset) if self.class.recordset
+
+    # If there is a model, return that model's default scope (all records by default).
+    if (model = self.get_model(from_get_recordset: true))
+      return @recordset = model.all
+    end
+
+    return nil
   end
 end
 
@@ -219,7 +229,7 @@ module RESTFramework::DestroyModelMixin
   def destroy
     @record = self.get_record
     @record.destroy!
-    api_response(nil)
+    api_response('')
   end
 end
 

data/lib/rest_framework/errors.rb

@@ -0,0 +1,26 @@
+# Top-level class for all REST Framework errors.
+class RESTFramework::Error < StandardError
+end
+
+class RESTFramework::NilPassedToAPIResponseError < RESTFramework::Error
+  def message
+    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.,
+      `find_by!`) to raise `ActiveRecord::RecordNotFound`, which the REST controller will catch and
+      return an appropriate error response.
+    MSG
+  end
+end
+
+class RESTFramework::UnserializableError < RESTFramework::Error
+  def initialize(object)
+    @object = object
+    return super
+  end
+
+  def message
+    return "Unable to serialize `#{@object.inspect}` (of type `#{@object.class}`)."
+  end
+end

data/lib/rest_framework/filters.rb

@@ -14,10 +14,10 @@ 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.class.filterset_fields || @controller.send(:get_fields)
+    fields = @controller.class.filterset_fields&.map(&:to_s) || @controller.send(:get_fields)
     return @controller.request.query_parameters.select { |p|
-      fields.include?(p.to_sym) || fields.include?(p.to_s)
-    }.to_hash.symbolize_keys
+      fields.include?(p)
+    }.to_h.symbolize_keys  # convert from HashWithIndifferentAccess to Hash w/keys
   end
 
   # Filter data according to the request query parameters.

data/lib/rest_framework/generators.rb

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

data/lib/rest_framework/generators/controller_generator.rb

@@ -0,0 +1,67 @@
+require 'rails/generators'
+
+
+# Some 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
+  def camelize
+    return "RESTFramework"
+  end
+end
+# :nocov:
+
+
+class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
+  PATH_REGEX = /^\/*([a-z0-9_\/]*[a-z0-9_])(?:[\.a-z\/]*)$/
+
+  desc <<~END
+  Description:
+      Generates a new REST Framework controller.
+
+      Specify the controller as a path, including the module, if needed, like:
+      'parent_module/controller_name'.
+
+  Example:
+      `rails generate rest_framework:controller user_api/groups`
+
+      Generates a controller at `app/controllers/user_api/groups_controller.rb` named
+      `UserApi::GroupsController`.
+  END
+
+  argument :path, type: :string
+  class_option(
+    :parent_class,
+    type: :string,
+    default: 'ApplicationController',
+    desc: "Inheritance parent",
+  )
+  class_option(
+    :include_base,
+    type: :boolean,
+    default: false,
+    desc: "Include `BaseControllerMixin`, not `ModelControllerMixin`",
+  )
+
+  # Some projects may not have the inflection "REST" as an acronym, which changes this generator to
+  # be namespaced in `r_e_s_t_framework`, which is weird.
+  def self.namespace
+    return RESTFrameworkCustomGeneratorControllerNamespace.new("rest_framework:controller")
+  end
+
+  def create_rest_controller_file
+    unless (path_match = PATH_REGEX.match(self.path))
+      raise StandardError.new("Path isn't correct.")
+    end
+
+    cleaned_path = path_match[1]
+    content = <<~END
+      class #{cleaned_path.camelize}Controller < #{options[:parent_class]}
+        include RESTFramework::#{
+          options[:include_base] ? "BaseControllerMixin" : "ModelControllerMixin"
+        }
+      end
+    END
+    create_file("app/controllers/#{path}_controller.rb", content)
+  end
+end

data/lib/rest_framework/routers.rb

@@ -1,5 +1,6 @@
 require 'action_dispatch/routing/mapper'
 
+
 module ActionDispatch::Routing
   class Mapper
     # Internal helper to take extra_actions hash and convert to a consistent format.
@@ -24,6 +25,11 @@ module ActionDispatch::Routing
             path = v.delete(:path)
           end
 
+          # Set the action to be the action key unless it's already defined.
+          if !kwargs[:action]
+            kwargs[:action] = k
+          end
+
           # Pass any further kwargs to the underlying Rails interface.
           kwargs = kwargs.merge(v)
         elsif v.is_a?(Symbol) || v.is_a?(String)

data/lib/rest_framework/serializers.rb

@@ -1,17 +1,18 @@
 class RESTFramework::BaseSerializer
-  attr_reader :errors
-
   def initialize(object: nil, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
+
+  def serialize
+    raise NotImplementedError
+  end
 end
 
 
-# This serializer uses `.as_json` to serialize objects. Despite the name, `.as_json` is an
-# `ActiveModel` method which converts objects to Ruby primitives (with the top-level being either
-# an array or a hash).
-class RESTFramework::NativeModelSerializer < RESTFramework::BaseSerializer
+# This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
+# top-level being either an array or a hash).
+class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :config
   class_attribute :singular_config
   class_attribute :plural_config
@@ -21,12 +22,19 @@ class RESTFramework::NativeModelSerializer < RESTFramework::BaseSerializer
     super(**kwargs)
 
     if many.nil?
-      @many = @object.respond_to?(:count) ? @object.count : nil
+      # Determine if we are dealing with many objects or just one.
+      @many = @object.is_a?(Enumerable)
     else
       @many = many
     end
 
-    @model = model || (@controller ? @controller.send(:get_model) : nil)
+    # 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 (
+      @many && @object.is_a?(Enumerable) && @object.is_a?(ActiveRecord::Base)
+    )
+    @model ||= @controller.send(:get_model) if @controller
   end
 
   # Get controller action, if possible.
@@ -34,8 +42,8 @@ class RESTFramework::NativeModelSerializer < RESTFramework::BaseSerializer
     return @controller&.action_name&.to_sym
   end
 
-  # Get a locally defined configuration, if one is defined.
-  def get_local_serializer_config
+  # Get a locally defined native serializer configuration, if one is defined.
+  def get_local_native_serializer_config
     action = self.get_action
 
     if action && self.action_config
@@ -45,43 +53,70 @@ class RESTFramework::NativeModelSerializer < RESTFramework::BaseSerializer
       return self.action_config[action] if self.action_config[action]
     end
 
-    # No action_config, so try singular/plural config.
-    return self.plural_config if @many && self.plural_config
-    return self.singular_config if !@many && self.singular_config
+    # No action_config, so try singular/plural config if explicitly instructed to via @many.
+    return self.plural_config if @many == true && self.plural_config
+    return self.singular_config if @many == false && self.singular_config
 
-    # Lastly, try returning the default config.
-    return self.config
+    # Lastly, try returning the default config, or singular/plural config in that order.
+    return self.config || self.singular_config || self.plural_config
   end
 
-  # Get a configuration passable to `as_json` for the object.
+  # Helper to get a native serializer configuration from the controller.
+  def get_controller_native_serializer_config
+    return nil unless @controller
+
+    if @many == true
+      controller_serializer = @controller.try(:native_serializer_plural_config)
+    elsif @many == false
+      controller_serializer = @controller.try(:native_serializer_singular_config)
+    end
+
+    return controller_serializer || @controller.try(:native_serializer_config)
+  end
+
+  # Get a configuration passable to `serializable_hash` for the object.
   def get_serializer_config
     # Return a locally defined serializer config if one is defined.
-    if local_config = self.get_local_serializer_config
+    if local_config = self.get_local_native_serializer_config
       return local_config
     end
 
-    # Return a serializer config if one is defined.
-    if serializer_config = @controller.send(:get_native_serializer_config)
+    # Return a serializer config if one is defined on the controller.
+    if serializer_config = get_controller_native_serializer_config
       return serializer_config
     end
 
     # If the config wasn't determined, build a serializer config from model fields.
-    fields = @controller.try(:get_fields) if @controller
-    unless fields.blank?
-      columns, methods = fields.partition { |f| f.to_s.in?(@model.column_names) }
+    fields = @controller.send(:get_fields) if @controller
+    if fields
+      if @model
+        columns, methods = fields.partition { |f| f.in?(@model.column_names) }
+      else
+        columns = fields
+        methods = []
+      end
+
       return {only: columns, methods: methods}
     end
 
+    # By default, pass an empty configuration, allowing the serialization of all columns.
     return {}
   end
 
   # Convert the object (record or recordset) to Ruby primitives.
   def serialize
     if @object
-      @many = @object.respond_to?(:each) if @many.nil?
-      return @object.as_json(self.get_serializer_config)
+      begin
+        if @object.is_a?(Enumerable)
+          return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
+        end
+        return @object.serializable_hash(self.get_serializer_config)
+      rescue NoMethodError
+      end
     end
-    return nil
+
+    # Raise an error if we cannot serialize the object.
+    raise RESTFramework::UnserializableError.new(@object)
   end
 
   # Allow a serializer instance to be used as a hash directly in a nested serializer config.
@@ -112,3 +147,19 @@ class RESTFramework::NativeModelSerializer < RESTFramework::BaseSerializer
     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(' ')
+        RESTFramework::NativeModelSerializer is deprecated and will be removed in future versions of
+        REST Framework; you should use RESTFramework::NativeSerializer instead.
+      MSG
+    )
+  end
+end
+# :nocov:

data/lib/rest_framework/version.rb

@@ -2,19 +2,21 @@ module RESTFramework
   module Version
     @_version = nil
 
-    def self.get_version
+    def self.get_version(skip_git: false)
       # Return cached @_version, if available.
       return @_version if @_version
 
       # First, attempt to get the version from git.
-      begin
-        version = `git describe 2>/dev/null`.strip
-        raise "blank version" if version.nil? || version.match(/^\w*$/)
-        # Check for local changes.
-        changes = `git status --porcelain 2>/dev/null`
-        version << '.localchanges' if changes.strip.length > 0
-        return version
-      rescue
+      unless skip_git
+        begin
+          version = `git describe 2>/dev/null`.strip
+          raise "blank version" if version.nil? || version.match(/^\w*$/)
+          # Check for local changes.
+          changes = `git status --porcelain 2>/dev/null`
+          version << '.localchanges' if changes.strip.length > 0
+          return version
+        rescue
+        end
       end
 
       # Git failed, so try to find a VERSION_STAMP.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-28 00:00:00.000000000 Z
+date: 2021-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,7 +43,10 @@ files:
 - lib/rest_framework/controller_mixins/base.rb
 - lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
+- lib/rest_framework/errors.rb
 - lib/rest_framework/filters.rb
+- lib/rest_framework/generators.rb
+- lib/rest_framework/generators/controller_generator.rb
 - lib/rest_framework/paginators.rb
 - lib/rest_framework/routers.rb
 - lib/rest_framework/serializers.rb