rest_framework 0.0.16 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 825e7e7ac0e9c8ae57250288a54dc3ef6510665ce3d4fee23245c559aa8e8233
-  data.tar.gz: 2211c303d14708ef94a4cb35d6e3b25bf78b3b08645f2990ca5448354d8dd64e
+  metadata.gz: 3af970dedaa74cde70348a09e74b190878e4a429a4db0318b093c581f810a349
+  data.tar.gz: 5ccd0cf76d51d9d5d3035eee80e73e1234b13c974d04bbd4e80a48bc5b82d714
 SHA512:
-  metadata.gz: 0ee2cf406f2b8d77d9ea63650b080d037a759143e0a3e19846585d493a386a4647db0fe59188aa0fd887257a18087aaca82b80d99dee962af1dfdb7eca66a07c
-  data.tar.gz: 6248caea5ad7f5a37a55f7da6aae55c70dc284b9f04d046fc6149a13dff4ae34410106c97f54274f59a8353c79fe97073b7dcba51d65d9c94eb0f9cff1a205ac
+  metadata.gz: a5841e302bdf9f2ae56748c2c81e94338a9c77c0dde248218d48733ff9bda28dc4a42e9cb5b21c339abf596490bb6de21e18a1f43bb8ef80802ce8d8db4d925e
+  data.tar.gz: 0b395e37ac08c45e3bf8d3940dde55fba063cb43b3e8125e4c9a55dbf6dc15e985c1fa72e51a042e4563194b0f4fa5f33dd3fa5e96de456eaf9448a27b7f76ad

data/README.md

@@ -2,16 +2,22 @@
 
 [![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)
 
-Rails REST Framework helps you build awesome Web APIs in Ruby on Rails.
+A framework for DRY RESTful APIs in Ruby on Rails.
 
 **The Problem**: Building controllers for APIs usually involves writing a lot of redundant CRUD
-logic, and routing them can be obnoxious.
+logic, and routing them can be obnoxious. Building and maintaining features like ordering,
+filtering, and pagination can be tedious.
 
-**The Solution**: This gem handles the common logic so you can focus on the parts of your API which
-make it unique.
+**The Solution**: This framework implements browsable API responses, CRUD actions for your models,
+and features like ordering/filtering/pagination, so you can focus on building awesome APIs.
 
-To see detailed documentation, visit https://rails-rest-framework.com.
+Website/Guide: [https://rails-rest-framework.com](https://rails-rest-framework.com)
+
+Source: [https://github.com/gregschmit/rails-rest-framework](https://github.com/gregschmit/rails-rest-framework)
+
+YARD Docs: [https://rubydoc.info/gems/rest_framework](https://rubydoc.info/gems/rest_framework)
 
 ## Installation
 
@@ -73,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
 
@@ -110,11 +116,12 @@ end
 After you clone the repository, cd'ing into the directory should create a new gemset if you are
 using RVM. Then run `bundle install` to install the appropriate gems.
 
-To run the full test suite:
+To run the test suite:
 
 ```shell
 $ rake test
 ```
 
 To interact with the test app, `cd test` and operate it via the normal Rails interfaces. Ensure you
-run `rake db:schema:load` before running `rails server` or `rails console`.
+run `rake db:schema:load` before running `rails server` or `rails console`. You can also load the
+test fixtures with `rake db:fixtures:load`.

data/lib/rest_framework.rb

@@ -1,10 +1,13 @@
 module RESTFramework
 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.0.16
+0.2.1

data/lib/rest_framework/controller_mixins.rb

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

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,201 +1,189 @@
+require_relative '../errors'
 require_relative '../serializers'
 
-module RESTFramework
 
-  # 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`
-  # is defined.
-  module BaseControllerMixin
-    # Default action for API root.
-    def root
-      api_response({message: "This is the root of your awesome API!"})
-    end
+# 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`
+# is defined.
+module RESTFramework::BaseControllerMixin
+  # Default action for API root.
+  def root
+    api_response({message: "This is the root of your awesome API!"})
+  end
 
-    module ClassMethods
-      def get_skip_actions(skip_undefined: true)
-        # first, skip explicitly skipped actions
-        skip = self.skip_actions || []
+  module ClassMethods
+    # Helper to get the actions that should be skipped.
+    def get_skip_actions(skip_undefined: true)
+      # First, skip explicitly skipped actions.
+      skip = self.skip_actions || []
 
-        # now add methods which don't exist, since we don't want to route those
-        if skip_undefined
-          [:index, :new, :create, :show, :edit, :update, :destroy].each do |a|
-            skip << a unless self.method_defined?(a)
-          end
+      # Now add methods which don't exist, since we don't want to route those.
+      if skip_undefined
+        [:index, :new, :create, :show, :edit, :update, :destroy].each do |a|
+          skip << a unless self.method_defined?(a)
         end
-
-        return skip
       end
-    end
 
-    def self.included(base)
-      if base.is_a? Class
-        base.extend ClassMethods
-
-        # Add class attributes (with defaults) unless they already exist.
-        {
-          extra_actions: nil,
-          extra_member_actions: nil,
-          filter_backends: nil,
-          native_serializer_config: nil,
-          native_serializer_action_config: nil,
-          paginator_class: nil,
-          page_size: nil,
-          page_query_param: 'page',
-          page_size_query_param: 'page_size',
-          max_page_size: nil,
-          serializer_class: nil,
-          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`.
-            base.send(:"#{a}=", default)
-          end
-        end
+      return skip
+    end
+  end
 
-        # Alias `extra_actions` to `extra_collection_actions`.
-        unless base.respond_to?(:extra_collection_actions)
-          base.alias_method(:extra_collection_actions, :extra_actions)
-          base.alias_method(:extra_collection_actions=, :extra_actions=)
+  def self.included(base)
+    if base.is_a? Class
+      base.extend ClassMethods
+
+      # 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,
+        paginator_class: nil,
+        page_size: 20,
+        page_query_param: 'page',
+        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`.
+          base.send(:"#{a}=", default)
         end
-
-        # skip csrf since this is an API
-        base.skip_before_action(:verify_authenticity_token) rescue nil
-
-        # 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)
-        base.rescue_from(ActiveRecord::RecordNotDestroyed, with: :record_not_destroyed)
       end
-    end
-
-    protected
 
-    # Helper to get filtering backends with a sane default.
-    def get_filter_backends
-      if self.class.filter_backends
-        return self.class.filter_backends
+      # Alias `extra_actions` to `extra_collection_actions`.
+      unless base.respond_to?(:extra_collection_actions)
+        base.alias_method(:extra_collection_actions, :extra_actions)
+        base.alias_method(:extra_collection_actions=, :extra_actions=)
       end
 
-      # By default, return nil.
-      return nil
+      # Skip csrf since this is an API.
+      base.skip_before_action(:verify_authenticity_token) rescue nil
+
+      # 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)
+      base.rescue_from(ActiveRecord::RecordNotDestroyed, with: :record_not_destroyed)
     end
+  end
 
-    # Filter the recordset over all configured filter backends.
-    def get_filtered_data(data)
-      (self.get_filter_backends || []).each do |filter_class|
-        filter = filter_class.new(controller: self)
-        data = filter.get_filtered_data(data)
-      end
+  protected
 
-      return data
-    end
+  # Helper to get filtering backends with a sane default.
+  # @return [RESTFramework::BaseFilter]
+  def get_filter_backends
+    return self.class.filter_backends || []
+  end
 
-    # Helper to get the configured serializer class, or `NativeModelSerializer` as a default.
-    def get_serializer_class
-      return self.class.serializer_class || NativeModelSerializer
+  # Helper to filter an arbitrary data set over all configured filter backends.
+  def get_filtered_data(data)
+    self.get_filter_backends.each do |filter_class|
+      filter = filter_class.new(controller: self)
+      data = filter.get_filtered_data(data)
     end
 
-    # Get a native serializer config for the current action.
-    def get_native_serializer_config
-      action_serializer_config = self.class.native_serializer_action_config || {}
-      action = self.action_name.to_sym
+    return data
+  end
 
-      # 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
+  # Helper to get the configured serializer class.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class
+  end
 
-      return (action_serializer_config[action] if action) || self.class.native_serializer_config
-    end
+  def record_invalid(e)
+    return api_response(
+      {message: "Record invalid.", exception: e, errors: e.record.errors}, status: 400
+    )
+  end
 
-    def record_invalid(e)
-      return api_response(
-        {message: "Record invalid.", exception: e, errors: e.record.errors}, status: 400
-      )
-    end
+  def record_not_found(e)
+    return api_response({message: "Record not found.", exception: e}, status: 404)
+  end
 
-    def record_not_found(e)
-      return api_response({message: "Record not found.", exception: e}, status: 404)
-    end
+  def record_not_saved(e)
+    return api_response({message: "Record not saved.", exception: e}, status: 406)
+  end
 
-    def record_not_saved(e)
-      return api_response({message: "Record not saved.", exception: e}, status: 406)
-    end
+  def record_not_destroyed(e)
+    return api_response({message: "Record not destroyed.", exception: e}, status: 406)
+  end
 
-    def record_not_destroyed(e)
-      return api_response({message: "Record not destroyed.", exception: e}, status: 406)
+  # Helper for showing routes under a controller action, used for the browsable API.
+  def _get_routes
+    begin
+      formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet
+    rescue NameError
+      formatter = ActionDispatch::Routing::ConsoleFormatter
     end
+    return ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes).format(
+      formatter.new
+    ).lines.drop(1).map { |r| r.split.last(3) }.map { |r|
+      {verb: r[0], path: r[1], action: r[2]}
+    }.select { |r| r[:path].start_with?(request.path) }
+  end
 
-    # Helper for showing routes under a controller action, used for the browsable API.
-    def _get_routes
-      begin
-        formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet
-      rescue NameError
-        formatter = ActionDispatch::Routing::ConsoleFormatter
-      end
-      return ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes).format(
-        formatter.new
-      ).lines.drop(1).map { |r| r.split.last(3) }.map { |r|
-        {verb: r[0], path: r[1], action: r[2]}
-      }.select { |r| r[:path].start_with?(request.path) }
+  # 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, **kwargs)
+    html_kwargs ||= {}
+    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
 
-    # Helper alias for `respond_to`/`render`. `payload` should be already serialized to Ruby
-    # primitives.
-    def api_response(payload, html_kwargs: nil, json_kwargs: nil, xml_kwargs: nil, **kwargs)
-      html_kwargs ||= {}
-      json_kwargs ||= {}
-      xml_kwargs ||= {}
-
-      # allow blank (no-content) responses
-      @blank = kwargs[:blank]
-
-      respond_to do |format|
-        if @blank
-          format.json {head :no_content}
-          format.xml {head :no_content}
+    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
+      else
+        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
+        if payload == ''
+          @json_payload = '' if self.serialize_to_json
+          @xml_payload = '' if self.serialize_to_xml
         else
-          if payload.respond_to?(:to_json)
-            format.json {
-              kwargs = kwargs.merge(json_kwargs)
-              render(json: payload, layout: false, **kwargs)
-            }
-          end
-          if payload.respond_to?(:to_xml)
-            format.xml {
-              kwargs = kwargs.merge(xml_kwargs)
-              render(xml: payload, layout: false, **kwargs)
-            }
-          end
+          @json_payload = payload.to_json if self.serialize_to_json
+          @xml_payload = payload.to_xml if self.serialize_to_xml
         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)
-          end
-          @template_logo_text ||= "Rails REST Framework"
-          @title ||= self.controller_name.camelize
-          @routes ||= self._get_routes
-          kwargs = kwargs.merge(html_kwargs)
-          begin
-            render(**kwargs)
-          rescue ActionView::MissingTemplate  # fallback to rest_framework layout/view
-            kwargs[:layout] = "rest_framework"
-            kwargs[:template] = "rest_framework/default"
-            render(**kwargs)
-          end
-        }
-      end
+        @template_logo_text ||= "Rails REST Framework"
+        @title ||= self.controller_name.camelize
+        @routes ||= self._get_routes
+        hkwargs = kwargs.merge(html_kwargs)
+        begin
+          render(**hkwargs)
+        rescue ActionView::MissingTemplate  # fallback to rest_framework layout/view
+          hkwargs[:layout] = "rest_framework"
+          hkwargs[:template] = "rest_framework/default"
+          render(**hkwargs)
+        end
+      }
     end
   end
-
 end

data/lib/rest_framework/controller_mixins/models.rb

@@ -1,221 +1,267 @@
 require_relative 'base'
 require_relative '../filters'
 
-module RESTFramework
-
-  module BaseModelControllerMixin
-    include BaseControllerMixin
-    def self.included(base)
-      if base.is_a? Class
-        BaseControllerMixin.included(base)
-
-        # Add class attributes (with defaults) unless they already exist.
-        {
-          # Core attributes related to models.
-          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 default model filtering (and ordering).
-          filterset_fields: nil,
-          ordering_fields: nil,
-          ordering_query_param: 'ordering',
-
-          # Other misc attributes.
-          disable_creation_from_recordset: nil,  # 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`.
-            base.send(:"#{a}=", default)
-          end
+
+# 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
+      RESTFramework::BaseControllerMixin.included(base)
+
+      # Add class attributes (with defaults) unless they already exist.
+      {
+        # Core attributes related to models.
+        model: nil,
+        recordset: 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_singular_config: nil,
+        native_serializer_plural_config: nil,
+
+        # Attributes for default model filtering (and ordering).
+        filterset_fields: nil,
+        ordering_fields: nil,
+        ordering_query_param: 'ordering',
+
+        # Other misc attributes.
+        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`.
+          base.send(:"#{a}=", default)
         end
       end
     end
+  end
 
-    protected
+  protected
 
-    # 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
+  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
 
-      # index action should use :list allowed parameters if :index is not provided
-      action = :list if action == :index && !allowed_action_parameters.key?(:index)
+    # Index action should use :list serializer if :index is not provided.
+    action = :list if action == :index && !action_config.key?(:index)
 
-      return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
-    end
-
-    # Get the list of filtering backends to use.
-    def get_filter_backends
-      backends = super
-      return backends if backends
+    return (action_config[action] if action) || self.class.send(generic_config_key)
+  end
 
-      # By default, return the standard model filter backend.
-      return [RESTFramework::ModelFilter, RESTFramework::ModelOrderingFilter]
-    end
+  # Get a list of parameters allowed for the current action.
+  def get_allowed_parameters
+    return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)&.map(&:to_s)
+  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
+  # 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
 
-      # index action should use :list fields if :index is not provided
-      action = :list if action == :index && !action_fields.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
+  end
 
-      return (action_fields[action] if action) || self.class.fields || []
-    end
+  # Get the list of filtering backends to use.
+  # @return [RESTFramework::BaseFilter]
+  def get_filter_backends
+    return self.class.filter_backends || [
+      RESTFramework::ModelFilter, RESTFramework::ModelOrderingFilter
+    ]
+  end
 
-    # Filter the request body for keys in current action's allowed_parameters/fields config.
-    def _get_parameter_values_from_request_body
+  # 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
-      return @_get_parameter_values_from_request_body ||= (request.request_parameters.select { |p|
-        fields.include?(p.to_sym) || fields.include?(p.to_s)
-      })
-    end
-    alias :get_create_params :_get_parameter_values_from_request_body
-    alias :get_update_params :_get_parameter_values_from_request_body
-
-    # Get a record by `id` or return a single record if recordset is filtered down to a single
-    # record.
-    def get_record
-      records = self.get_filtered_data(self.get_recordset)
-      if params['id']  # direct lookup
-        return records.find(params['id'])
-      elsif records.length == 1
-        return records[0]
-      end
-      return nil
-    end
 
-    # Internal interface for get_model, protecting against infinite recursion with get_recordset.
-    def _get_model(from_internal_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
+      # 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
-      begin
-        return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
-      rescue NameError
+
+      # Filter primary key if configured.
+      if self.class.filter_pk_from_request_body
+        body_params.delete(self.get_model&.primary_key)
       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
+      # Filter fields in exclude_body_fields.
+      (self.class.exclude_body_fields || []).each do |f|
+        body_params.delete(f.to_s)
       end
-      return nil
-    end
 
-    # Get the model for this controller.
-    def get_model
-      return _get_model
+      body_params
     end
+  end
+  alias :get_create_params :get_body_params
+  alias :get_update_params :get_body_params
 
-    # Get the set of records this controller has access to.
-    def get_recordset
-      return _get_recordset
+  # Get a record by the primary key from the (non-filtered) recordset.
+  def get_record
+    if pk = params[self.get_model.primary_key]
+      return self.get_recordset.find(pk)
     end
+    return nil
   end
 
-  module ListModelMixin
-    def index
-      @records = self.get_filtered_data(self.get_recordset)
+  # 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
 
-      # 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)
-      else
-        data = self.get_serializer_class.new(object: @records, controller: self).serialize
+    # 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
 
-      return api_response(data)
+    # 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
 
-  module ShowModelMixin
-    def show
-      @record = self.get_record
-      serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
-      return api_response(serialized_record)
+  # 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
+
+    # 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
 
-  module CreateModelMixin
-    def create
-      if self.get_recordset.respond_to?(:create!) && !self.disable_creation_from_recordset
-        # Create with any properties inherited from the recordset (like associations).
-        @record = self.get_recordset.create!(self.get_create_params)
-      else
-        # 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)
+
+# Mixin for listing records.
+module RESTFramework::ListModelMixin
+  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)
+    else
+      data = self.get_serializer_class.new(object: @records, controller: self).serialize
     end
+
+    return api_response(data)
   end
+end
 
-  module UpdateModelMixin
-    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)
-    end
+
+# Mixin for showing records.
+module RESTFramework::ShowModelMixin
+  def show
+    @record = self.get_record
+    serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
+    return api_response(serialized_record)
   end
+end
+
 
-  module DestroyModelMixin
-    def destroy
-      @record = self.get_record
-      @record.destroy!
-      api_response(nil)
+# Mixin for creating records.
+module RESTFramework::CreateModelMixin
+  def create
+    if self.get_recordset.respond_to?(:create!) && !self.disable_creation_from_recordset
+      # Create with any properties inherited from the recordset (like associations).
+      @record = self.get_recordset.create!(self.get_create_params)
+    else
+      # 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)
   end
+end
 
-  module ReadOnlyModelControllerMixin
-    include BaseModelControllerMixin
-    def self.included(base)
-      if base.is_a? Class
-        BaseModelControllerMixin.included(base)
-      end
-    end
 
-    include ListModelMixin
-    include ShowModelMixin
+# Mixin for updating records.
+module RESTFramework::UpdateModelMixin
+  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)
+  end
+end
+
+
+# Mixin for destroying records.
+module RESTFramework::DestroyModelMixin
+  def destroy
+    @record = self.get_record
+    @record.destroy!
+    api_response('')
   end
+end
 
-  module ModelControllerMixin
-    include BaseModelControllerMixin
-    def self.included(base)
-      if base.is_a? Class
-        BaseModelControllerMixin.included(base)
-      end
+
+# Mixin that includes show/list mixins.
+module RESTFramework::ReadOnlyModelControllerMixin
+  include RESTFramework::BaseModelControllerMixin
+
+  def self.included(base)
+    if base.is_a? Class
+      RESTFramework::BaseModelControllerMixin.included(base)
     end
+  end
+
+  include RESTFramework::ListModelMixin
+  include RESTFramework::ShowModelMixin
+end
 
-    include ListModelMixin
-    include ShowModelMixin
-    include CreateModelMixin
-    include UpdateModelMixin
-    include DestroyModelMixin
+
+# Mixin that includes all the CRUD mixins.
+module RESTFramework::ModelControllerMixin
+  include RESTFramework::BaseModelControllerMixin
+
+  def self.included(base)
+    if base.is_a? Class
+      RESTFramework::BaseModelControllerMixin.included(base)
+    end
   end
 
+  include RESTFramework::ListModelMixin
+  include RESTFramework::ShowModelMixin
+  include RESTFramework::CreateModelMixin
+  include RESTFramework::UpdateModelMixin
+  include RESTFramework::DestroyModelMixin
 end