rest_framework 0.0.13 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c74e7a6e690c22a72a04bb4fd30132b845ef108890c8140673300ca2c047f2a
-  data.tar.gz: 317f484c3bf46554b5664bc30d20c611e404c4893725c77a84372ebac8e7ca82
+  metadata.gz: 7cb7ba6d5e7861525dca18f908afa1f398f614af654223ac03de15f7014dafaa
+  data.tar.gz: 7938b5b0225e089f2cd3a168b80763ebcc63dd65655ae4c87b045e923477191a
 SHA512:
-  metadata.gz: 2e4dbb91f448068ab3115184518f75a633708e562268863b12f81838a2bcd3a5c344af9390e2238210a52e1070b1d2a2dd51f4b23bc2e51fdd1773e6c702b137
-  data.tar.gz: 21a18513bfc9682fd57e01d46f63b9172864bbbbd140c8d060c22e28df5896352c547b05fceda4914ac89da7d8c76e56469ace66f7987e30e85c6d24d66b2b35
+  metadata.gz: cb1583fe183387972e1537bc2b90ebe9b224381e46515ffd202f3ad86cb4a545f906264644fff537b5937f8e4f985f39eb3123c6d47e2e8e5c1be31b425aad54
+  data.tar.gz: 3a8b3a6e63a4ca03250d8e6697eda885abd6940f8b580f073ffa0c237a59a535d4997aa4591651c01cda61fd3f021508ed69d298a19512f783a9604b6dbcdd7c

data/README.md

@@ -3,15 +3,20 @@
 [![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)
 
-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
 
@@ -110,24 +115,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,11 @@
 module RESTFramework
 end
 
+
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
+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"

data/lib/rest_framework/VERSION_STAMP

@@ -1 +1 @@
-0.0.13
+0.1.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,129 +1,180 @@
-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 '../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
 
-    def self.included(base)
-      if base.is_a? Class
-        base.extend ClassMethods
-        base.class_attribute(*[
-          :singleton_controller,
-          :extra_actions,
-          :skip_actions,
-          :paginator_class,
-        ])
-        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)
+      # Add class attributes (with defaults) unless they already exist.
+      {
+        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,
+        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)
+  # Helper to get filtering backends with a sane default.
+  # @return [RESTFramework::BaseFilter]
+  def get_filter_backends
+    return self.class.filter_backends || []
+  end
+
+  # 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
 
-    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) }
+    return data
+  end
+
+  # Helper to get the configured serializer class.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class
+  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_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, json_kwargs: nil, xml_kwargs: nil, **kwargs)
+    html_kwargs ||= {}
+    json_kwargs ||= {}
+    xml_kwargs ||= {}
+
+    # allow blank (no-content) responses
+    @blank = kwargs[:blank]
 
-    # 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}
-        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
+    respond_to do |format|
+      if @blank
+        format.json {head :no_content}
+        format.xml {head :no_content}
+      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.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
+      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
+        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,222 +1,257 @@
 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,
-        ])
-        base.alias_method(:extra_collection_actions=, :extra_actions=)
+require_relative '../filters'
+
+
+# This module provides the core functionality for controllers based on models.
+module RESTFramework::BaseModelControllerMixin
+  include RESTFramework::BaseControllerMixin
+
+  def self.included(base)
+    if base.is_a? Class
+      RESTFramework::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 the default native serializer.
+        native_serializer_config: nil,
+        native_serializer_action_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: 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
       end
     end
+  end
+
+  protected
 
-    protected
+  # Get a native serializer config for the current action.
+  # @return [RESTFramework::NativeModelSerializer]
+  def get_native_serializer_config
+    action_serializer_config = self.class.native_serializer_action_config || {}
+    action = self.action_name.to_sym
 
-    def get_serializer_class
-      return self.class.serializer_class || NativeModelSerializer
+    # 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
 
-    # Get a list of fields for the current action.
-    def get_fields
-      action_fields = self.class.action_fields || {}
-      action = self.action_name.to_sym
+    return (action_serializer_config[action] if action) || self.class.native_serializer_config
+  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 `NativeModelSerializer` as a default.
+  # @return [RESTFramework::BaseSerializer]
+  def get_serializer_class
+    return self.class.serializer_class || RESTFramework::NativeModelSerializer
+  end
 
-      return (action_fields[action] if action) || self.class.fields || []
-    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
 
-    # 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
+    # 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 config if :index is not provided
-      action = :list if action == :index && !action_serializer_config.key?(:index)
+    return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
+  end
 
-      return (action_serializer_config[action] if action) || self.class.native_serializer_config
-    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
 
-    # 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
+  # Get a list of fields for the current action.
+  def get_fields
+    action_fields = self.class.action_fields || {}
+    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 fields if :index is not provided
+    action = :list if action == :index && !action_fields.key?(:index)
 
-      return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
-    end
+    return (action_fields[action] if action) || self.class.fields || []
+  end
 
-    # Filter the request body for keys in current action's allowed_parameters/fields config.
-    def _get_parameter_values_from_request_body
-      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)
-      }
-    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
+  # 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)
+    })
+  end
+  alias :get_create_params :get_body_params
+  alias :get_update_params :get_body_params
 
-    # 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]
-      end
-      return nil
+  # Get a record by the primary key from the filtered recordset.
+  def get_record
+    records = self.get_filtered_data(self.get_recordset)
+    if pk = params[self.model.primary_key]
+      return records.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)
-      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
-      end
-      begin
-        return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
-      rescue NameError
-      end
-      return nil
+  # 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
     end
-
-    # Internal interface for get_recordset, protecting against infinite recursion with get_model.
-    def _get_recordset(from_internal_get_model: false)
-      return @recordset if instance_variable_defined?(:@recordset) && @recordset
-      return self.class.recordset if self.class.recordset
-      unless from_internal_get_model  # prevent infinite recursion
-        model = self._get_model(from_internal_get_recordset: true)
-        return (@recordset = model.all) if model
-      end
-      return nil
+    begin
+      return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
+    rescue NameError
     end
+    return nil
+  end
 
-    # Get the model for this controller.
-    def get_model
-      return _get_model
+  # Internal interface for get_recordset, protecting against infinite recursion with get_model.
+  def _get_recordset(from_internal_get_model: false)
+    return @recordset if instance_variable_defined?(:@recordset) && @recordset
+    return self.class.recordset if self.class.recordset
+    unless from_internal_get_model  # prevent infinite recursion
+      model = self._get_model(from_internal_get_recordset: true)
+      return (@recordset = model.all) if model
     end
+    return nil
+  end
 
-    # Get the set of records this controller has access to.
-    def get_recordset
-      return _get_recordset
-    end
+  # Get the model for this controller.
+  def get_model
+    return _get_model
   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)
-    end
+  # Get the set of records this controller has access to.
+  def get_recordset
+    return _get_recordset
   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
-      @record = self.get_model.create!(self.get_create_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 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(nil)
   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