rest_framework 0.1.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96d6394bfb8dee90ee31a05289a86db5409a118a3d456b9bf927397ceea055a7
-  data.tar.gz: 6dc5181f02dafae6d0831a7802480375097836eb3e3e799c78076d0331a2f728
+  metadata.gz: 8d9ce4741f59e6f68bfa18bc2e6c11202c91fbe251eeaa5562f8f718e6e8afaa
+  data.tar.gz: 652ad42a8d0bad99e552af9117112df707e67d4c1e6dd2dd983e7925933fcab6
 SHA512:
-  metadata.gz: e811d984f82150ad789d1e3437fc178095dcaffa8270b15b96dd375d7dbf649e0983f8001a4fe09c4ea4abe89ba8c8cad9e44ae25c21bbecb65adf5542efd8fc
-  data.tar.gz: 1d64e212a2bb7331cba06020e9a9405b54ab558e691f4ef349ffc156a702f352209108fc62265b2ff8369a15656bdc4b158db13201b630d0ae3e2853e3b7c553
+  metadata.gz: 26036468d40ccc77a203981ba442265ef82c7a991fee800ee3d7925d96d09a696f3db06930e8252c49cf63e86d2aee2fd121a735e5e06609585299ff984d6992
+  data.tar.gz: 3c53d8eed996e380ab3390acfde7a3cef262d38a1355d0016aa6d8129b8e329c99003c0181ec1602f5bb1ba8869355e6b1eb0ff366d8b814ff83f6bb3c9cbf4d

data/README.md

@@ -2,6 +2,8 @@
 
 [![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)
+[![Maintainability](https://api.codeclimate.com/v1/badges/ba5df7706cb544d78555/maintainability)](https://codeclimate.com/github/gregschmit/rails-rest-framework/maintainability)
 
 A framework for DRY RESTful APIs in Ruby on Rails.
 
@@ -78,8 +80,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.3
+0.2.4

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::NativeSerializer]
-  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 `NativeSerializer` as a default.
-  # @return [RESTFramework::BaseSerializer]
-  def get_serializer_class
-    return self.class.serializer_class || RESTFramework::NativeSerializer
+    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.get_model.primary_key]
-      return records.find(pk)
+      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 (@model = 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
+
+    # 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)
+  # Get the set of records this controller has access to.
+  def get_recordset
     return @recordset if instance_variable_defined?(:@recordset) && @recordset
     return (@recordset = 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
+    # 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
 
-  # Get the set of records this controller has access to.
-  def get_recordset
-    return _get_recordset
+    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,11 +1,12 @@
 require 'action_dispatch/routing/mapper'
 
+
 module ActionDispatch::Routing
   class Mapper
     # Internal helper to take extra_actions hash and convert to a consistent format.
     protected def _parse_extra_actions(extra_actions)
       return (extra_actions || {}).map do |k,v|
-        kwargs = {}
+        kwargs = {action: k}
         path = k
 
         # Convert structure to path/methods/kwargs.
@@ -71,6 +72,16 @@ module ActionDispatch::Routing
       return controller
     end
 
+    # Interal interface for routing extra actions.
+    protected def _route_extra_actions(actions, &block)
+      actions.each do |action_config|
+        action_config[:methods].each do |m|
+          public_send(m, action_config[:path], **action_config[:kwargs])
+        end
+        yield if block_given?
+      end
+    end
+
     # Internal core implementation of the `rest_resource(s)` router, both singular and plural.
     # @param default_singular [Boolean] the default plurality of the resource if the plurality is
     #   not otherwise defined by the controller
@@ -99,28 +110,20 @@ module ActionDispatch::Routing
       end
       resource_method = singular ? :resource : :resources
 
-      # call either `resource` or `resources`, passing appropriate modifiers
+      # Call either `resource` or `resources`, passing appropriate modifiers.
       skip_undefined = kwargs.delete(:skip_undefined) || true
       skip = controller_class.get_skip_actions(skip_undefined: skip_undefined)
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do
             actions = self._parse_extra_actions(controller_class.extra_member_actions)
-            actions.each do |action_config|
-              action_config[:methods].each do |m|
-                public_send(m, action_config[:path], **action_config[:kwargs])
-              end
-            end
+            _route_extra_actions(actions)
           end
         end
 
         collection do
           actions = self._parse_extra_actions(controller_class.extra_actions)
-          actions.each do |action_config|
-            action_config[:methods].each do |m|
-              public_send(m, action_config[:path], **action_config[:kwargs])
-            end
-          end
+          _route_extra_actions(actions)
         end
 
         yield if block_given?
@@ -144,6 +147,7 @@ module ActionDispatch::Routing
     # Route a controller without the default resourceful paths.
     def rest_route(name=nil, **kwargs, &block)
       controller = kwargs.delete(:controller) || name
+      route_root_to = kwargs.delete(:route_root_to)
       if controller.is_a?(Class)
         controller_class = controller
       else
@@ -156,42 +160,27 @@ module ActionDispatch::Routing
       # Route actions using the resourceful router, but skip all builtin actions.
       actions = self._parse_extra_actions(controller_class.extra_actions)
       public_send(:resource, name, only: [], **kwargs) do
-        actions.each do |action_config|
-          action_config[:methods].each do |m|
-            public_send(m, action_config[:path], **action_config[:kwargs])
-          end
-          yield if block_given?
+        # Route a root for this resource.
+        if route_root_to
+          get '', action: route_root_to
         end
+
+        _route_extra_actions(actions, &block)
       end
     end
 
     # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
-    # @param name [Symbol] the snake_case name of the controller
     def rest_root(name=nil, **kwargs, &block)
       # By default, use RootController#root.
       root_action = kwargs.delete(:action) || :root
       controller = kwargs.delete(:controller) || name || :root
 
-      # Route the root.
-      get name.to_s, controller: controller, action: root_action
-
-      # Route any additional actions.
-      controller_class = self._get_controller_class(controller, pluralize: false)
-      actions = self._parse_extra_actions(controller_class.extra_actions)
-      actions.each do |action_config|
-        # Add :action unless kwargs defines it.
-        unless action_config[:kwargs].key?(:action)
-          action_config[:kwargs][:action] = action_config[:path]
-        end
+      # Remove path if name is nil (routing to the root of current namespace).
+      unless name
+        kwargs[:path] = ''
+      end
 
-        action_config[:methods].each do |m|
-          public_send(
-            m,
-            File.join(name.to_s, action_config[:path].to_s),
-            controller: controller,
-            **action_config[:kwargs],
-          )
-        end
+      return rest_route(controller, route_root_to: root_action, **kwargs) do
         yield if block_given?
       end
     end

data/lib/rest_framework/serializers.rb

@@ -1,16 +1,17 @@
 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).
+# 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
@@ -21,12 +22,19 @@ class RESTFramework::NativeSerializer < 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::NativeSerializer < 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::NativeSerializer < 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.
@@ -113,6 +148,18 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   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.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-07 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