rest_framework 0.0.15 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70c2eb85612656cf6f1b3d34b97deb06ad01aa07459012b4254e543fc0bd5507
-  data.tar.gz: 76f44db8c396cfe5bb539faebb6f6031276d7133327b733cab4a645922176d95
+  metadata.gz: 8ef7499f4d1e10af1f2520d3b9847dc7f711bd1c7f4377efe21bd5b60c0dd9a7
+  data.tar.gz: b15a9b0abee58e315fdc3a1157ca04d7051630821d3ed2ca691564966b5fefca
 SHA512:
-  metadata.gz: 246bd5c3972c212c1d6fcf600da1c894fe05acaeda8596d432b6b360e265520b3e54f3b4842998c26868464c29bd79f3c164f51104145163c0a63ba9e94f06fb
-  data.tar.gz: 52af9985b986a167f70cd8def492a3ff2c7d61bafd48e120f49934cc3827f76a1e6dbc5c02651df6bba7fdd622be058f945534415d6cb74e3537c56f9c18c0e2
+  metadata.gz: fb586a083989a67f206d5b5d6c14eb546949569e384d3b44c870de5f49f610b5848d53da87e01234542705304dd7d49bcf6f0037f0b89331c7fa2a1b084422ce
+  data.tar.gz: fe4c960cda0d2a9ba43cb7d5b1cfa84963802800829323c26b350841bbd34290e68cbbc4f14a3138a1cb95a28aafff76b2d9a78a41772950e00ad80159c8f2f3

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,24 +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 run unit tests:
-
-```shell
-$ rake test:unit
-```
-
-To run integration tests:
-
-```shell
-$ rake test:integration
-```
-
-To interact with the integration app, you can `cd test/integration` and operate it via the normal
-Rails interfaces. Ensure you run `rake db:schema:load` before running `rails server` or
-`rails console`.
+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`. You can also load the
+test fixtures with `rake db:fixtures:load`.

data/app/views/layouts/rest_framework.html.erb

@@ -30,14 +30,14 @@
                 <% if @json_payload %>
                   <li class="nav-item">
                     <a class="nav-link active" href="#tab-json" data-toggle="tab" role="tab">
-                      JSON
+                      .json
                     </a>
                   </li>
                 <% end %>
                 <% if @xml_payload %>
                   <li class="nav-item">
                     <a class="nav-link" href="#tab-xml" data-toggle="tab" role="tab">
-                      XML
+                      .xml
                     </a>
                   </li>
                 <% end %>

data/lib/rest_framework.rb

@@ -1,7 +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.15
+0.2.0

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,134 +1,189 @@
-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
+require_relative '../errors'
+require_relative '../serializers'
 
-    module ClassMethods
-      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
-        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
 
-        return skip
+  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
       end
+
+      return skip
     end
+  end
 
-    def self.included(base)
-      if base.is_a? Class
-        base.extend ClassMethods
-        base.class_attribute(*[
-          :singleton_controller,
-          :extra_actions,
-          :skip_actions,
-          :paginator_class,
-        ])
-
-        # 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)
+  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
       end
-    end
 
-    protected
+      # 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
 
-    def record_invalid(e)
-      return api_response(
-        {message: "Record invalid.", exception: e, errors: e.record.errors}, status: 400
-      )
-    end
+      # Skip csrf since this is an API.
+      base.skip_before_action(:verify_authenticity_token) rescue nil
 
-    def record_not_found(e)
-      return api_response({message: "Record not found.", exception: e}, status: 404)
+      # 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
 
-    def record_not_saved(e)
-      return api_response({message: "Record not saved.", exception: e}, status: 406)
-    end
+  protected
 
-    def record_not_destroyed(e)
-      return api_response({message: "Record not destroyed.", exception: e}, status: 406)
-    end
+  # Helper to get filtering backends with a sane default.
+  # @return [RESTFramework::BaseFilter]
+  def get_filter_backends
+    return self.class.filter_backends || []
+  end
 
-    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 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
 
-    # 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 ||= {}
+    return data
+  end
 
-      # allow blank (no-content) responses
-      @blank = kwargs[:blank]
+  # Helper to get the configured serializer class.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class
+  end
 
-      respond_to do |format|
-        if @blank
-          format.json {head :no_content}
-          format.xml {head :no_content}
+  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_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
+
+  # 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 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
+
+    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"
-          end
-          render(**kwargs)
-        }
-      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,229 +1,267 @@
 require_relative 'base'
-require_relative '../serializers'
-
-module RESTFramework
-
-  module BaseModelControllerMixin
-    include BaseControllerMixin
-    def self.included(base)
-      if base.is_a? Class
-        BaseControllerMixin.included(base)
-        base.class_attribute(*[
-          :model,
-          :recordset,
-          :fields,
-          :action_fields,
-          :native_serializer_config,
-          :native_serializer_action_config,
-          :filterset_fields,
-          :allowed_parameters,
-          :allowed_action_parameters,
-          :serializer_class,
-          :extra_member_actions,
-          :disable_creation_from_recordset,
-        ])
-        base.alias_method(:extra_collection_actions=, :extra_actions=)
-      end
-    end
+require_relative '../filters'
 
-    protected
 
-    def get_serializer_class
-      return self.class.serializer_class || NativeModelSerializer
-    end
+# This module provides the core functionality for controllers based on models.
+module RESTFramework::BaseModelControllerMixin
+  include RESTFramework::BaseControllerMixin
 
-    # Get a list of fields for the current action.
-    def get_fields
-      action_fields = self.class.action_fields || {}
-      action = self.action_name.to_sym
+  def self.included(base)
+    if base.is_a? Class
+      RESTFramework::BaseControllerMixin.included(base)
 
-      # index action should use :list fields if :index is not provided
-      action = :list if action == :index && !action_fields.key?(:index)
+      # Add class attributes (with defaults) unless they already exist.
+      {
+        # Core attributes related to models.
+        model: nil,
+        recordset: nil,
 
-      return (action_fields[action] if action) || self.class.fields || []
-    end
+        # Attributes for configuring record fields.
+        fields: nil,
+        action_fields: nil,
 
-    # 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
+        # Attributes for create/update parameters.
+        allowed_parameters: nil,
+        allowed_action_parameters: nil,
 
-      # index action should use :list serializer config if :index is not provided
-      action = :list if action == :index && !action_serializer_config.key?(:index)
+        # Attributes for the default native serializer.
+        native_serializer_config: nil,
+        native_serializer_singular_config: nil,
+        native_serializer_plural_config: nil,
 
-      return (action_serializer_config[action] if action) || self.class.native_serializer_config
+        # 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
 
-    # 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
+  protected
 
-      # index action should use :list allowed parameters if :index is not provided
-      action = :list if action == :index && !allowed_action_parameters.key?(:index)
+  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 (allowed_action_parameters[action] if action) || self.class.allowed_parameters
-    end
+    # Index action should use :list serializer if :index is not provided.
+    action = :list if action == :index && !action_config.key?(:index)
+
+    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
+    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
+    return (
+      _get_specific_action_config(:action_fields, :fields)&.map(&:to_s) ||
+      self.get_model&.column_names ||
+      []
+    )
+  end
 
-    # Filter the request body for keys in current action's allowed_parameters/fields config.
-    def _get_parameter_values_from_request_body
+  # 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.
+  # @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_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
-
-    # Filter params for keys allowed by the current action's filterset_fields/fields config.
-    def _get_filterset_values_from_params
-      fields = self.filterset_fields || self.get_fields
-      return @_get_filterset_values_from_params ||= request.query_parameters.select { |p|
-        fields.include?(p.to_sym) || fields.include?(p.to_s)
+
+      # Filter the request body.
+      body_params = request.request_parameters.select { |p|
+        fields.include?(p)
       }
-    end
-    alias :get_lookup_params :_get_filterset_values_from_params
-    alias :get_filter_params :_get_filterset_values_from_params
-
-    # Get the recordset, filtered by the filter params.
-    def get_filtered_recordset
-      filter_params = self.get_filter_params
-      unless filter_params.blank?
-        return self.get_recordset.where(**self.get_filter_params.to_hash.symbolize_keys)
-      end
-      return self.get_recordset
-    end
 
-    # 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_recordset
-      if params['id']  # direct lookup
-        return records.find(params['id'])
-      elsif records.length == 1
-        return records[0]
+      # 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
-      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 primary key if configured.
+      if self.class.filter_pk_from_request_body
+        body_params.delete(self.get_model&.primary_key)
       end
-      begin
-        return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
-      rescue NameError
+
+      # Filter fields in exclude_body_fields.
+      (self.class.exclude_body_fields || []).each do |f|
+        body_params.delete(f.to_s)
       end
-      return nil
+
+      body_params
     end
+  end
+  alias :get_create_params :get_body_params
+  alias :get_update_params :get_body_params
 
-    # 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
+  # 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
+
+  # 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
 
-    # Get the model for this controller.
-    def get_model
-      return _get_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
 
-    # Get the set of records this controller has access to.
-    def get_recordset
-      return _get_recordset
+    # 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 ListModelMixin
-    # TODO: pagination classes like Django
-    def index
-      @records = self.get_filtered_recordset
-      @serialized_records = self.get_serializer_class.new(
-        object: @records, controller: self
-      ).serialize
-      return api_response(@serialized_records)
+  # 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 ShowModelMixin
-    def show
-      @record = self.get_record
-      @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 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
+
+# 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 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)
+# 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 DestroyModelMixin
-    def destroy
-      @record = self.get_record
-      @record.destroy!
-      api_response(nil)
-    end
+
+# 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
 
-  module ReadOnlyModelControllerMixin
-    include BaseModelControllerMixin
-    def self.included(base)
-      if base.is_a? Class
-        BaseModelControllerMixin.included(base)
-      end
-    end
 
-    include ListModelMixin
-    include ShowModelMixin
+# 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