rest_framework 0.0.6 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3e577365f00c98803ebf7f4548c10e5e0cde9208d47de71ac5d5193d0e0c776
-  data.tar.gz: b0527bc192535edcd85a91587e11df09c30dff460701c826fe6574ec487bc003
+  metadata.gz: 8c3691667e86ee77e9d15a1732d0013687a2e63a062a4ff01d1c6d8cc66f45fc
+  data.tar.gz: 6bcab926c283feb9a0643a06eab750f941882e5b56b294c59794f64a966883bb
 SHA512:
-  metadata.gz: 805f9fe5d4fcd15f5e360459af7246e52392115f3cf6ab3fe51a2128f16c4092e10ac0797767769992416818cdf5dc429790e128ad7a889119cdb134d739ea61
-  data.tar.gz: d0079b9e2cb005938d95aa83cccc3971849183be3209e2c08a2ebae5c357d6c9c571663cd496f68c4a5f8855ea2b804a46fbfcb73d839693b41ce781563599c0
+  metadata.gz: 204e0b5ea7b46710968a6274791f9e0f676db34f4eaefa1cf831fe8f9e4ab1f076a24b0375ef0554e1c4b57db3d1787adeebc31c4201da40b504aded51ca097b
+  data.tar.gz: 7e46ed5bbe61832045207664d679ecf394aead2928cdd78a1b29873087b78130546fd80595fe443680d5c26eebfa8bf5f23246b56a9a4a83e801c7763c024c76

data/README.md

@@ -1,9 +1,9 @@
-# REST Framework
+# Rails REST Framework
 
 [![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)
 
-REST Framework helps you build awesome APIs in Ruby on Rails.
+Rails REST Framework helps you build awesome Web 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.
@@ -11,6 +11,8 @@ logic, and routing them can be obnoxious.
 **The Solution**: This gem handles the common logic so you can focus on the parts of your API which
 make it unique.
 
+To see detailed documentation, visit https://rails-rest-framework.com.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -21,13 +23,17 @@ gem 'rest_framework'
 
 And then execute:
 
-    $ bundle install
+```shell
+$ bundle install
+```
 
 Or install it yourself with:
 
-    $ gem install rest_framework
+```shell
+$ gem install rest_framework
+```
 
-## Usage
+## Quick Usage Tutorial
 
 ### Controller Mixins
 
@@ -35,10 +41,10 @@ To transform a controller into a RESTful controller, you can either include `Bas
 `ReadOnlyModelControllerMixin`, or `ModelControllerMixin`. `BaseControllerMixin` provides a `root`
 action and a simple interface for routing arbitrary additional actions:
 
-```
+```ruby
 class ApiController < ApplicationController
   include RESTFramework::BaseControllerMixin
-  @extra_actions = {test: [:get]}
+  self.extra_actions = {test: [:get]}
 
   def test
     render inline: "Test successful!"
@@ -46,24 +52,24 @@ class ApiController < ApplicationController
 end
 ```
 
-`ModelControllerMixin` assists with providing the standard CRUD for your controller.
+`ModelControllerMixin` assists with providing the standard model CRUD for your controller.
 
-```
+```ruby
 class Api::MoviesController < ApiController
   include RESTFramework::ModelControllerMixin
 
-  @recordset = Movie.where(enabled: true)  # by default, @recordset would include all movies
+  self.recordset = Movie.where(enabled: true)
 end
 ```
 
 `ReadOnlyModelControllerMixin` only enables list/show actions, but since we're naming this
 controller in a way that doesn't make the model obvious, we can set that explicitly:
 
-```
+```ruby
 class Api::ReadOnlyMoviesController < ApiController
   include RESTFramework::ReadOnlyModelControllerMixin
 
-  @model = Movie
+  self.model = Movie
 end
 ```
 
@@ -73,28 +79,28 @@ behavior dynamically per-request.
 ### Routing
 
 You can use Rails' `resource`/`resources` routers to route your API, however if you want
-`@extra_actions` / `@extra_member_actions` to be routed automatically, then you can use the
-`rest_resource` / `rest_resources` routers provided by this gem. You can also use `rest_root` to route
-the root of your API:
+`extra_actions` / `extra_member_actions` to be routed automatically, then you can use `rest_route`
+for non-resourceful controllers, or `rest_resource` / `rest_resources` resourceful routers. You can
+also use `rest_root` to route the root of your API:
 
-```
+```ruby
 Rails.application.routes.draw do
   rest_root :api  # will find `api_controller` and route the `root` action to '/api'
   namespace :api do
     rest_resources :movies
-    rest_resources :read_only_movies
+    rest_resources :users
   end
 end
 ```
 
 Or if you want the API root to be routed to `Api::RootController#root`:
 
-```
+```ruby
 Rails.application.routes.draw do
   namespace :api do
     rest_root  # will route `Api::RootController#root` to '/' in this namespace ('/api')
     rest_resources :movies
-    rest_resources :read_only_movies
+    rest_resources :users
   end
 end
 ```
@@ -106,15 +112,21 @@ using RVM. Then run `bundle install` to install the appropriate gems.
 
 To run the full test suite:
 
-    $ rake test
+```shell
+$ rake test
+```
 
 To run unit tests:
 
-    $ rake test:unit
+```shell
+$ rake test:unit
+```
 
 To run integration tests:
 
-    $ rake test:integration
+```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

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

@@ -11,7 +11,7 @@
       <nav class="navbar navbar-dark bg-dark">
         <div class="container">
           <span class="navbar-brand p-0">
-            <h1 class="text-light font-weight-light m-0 p-0" style="font-size: 1em"><%= @template_logo_text %></h1>
+            <h1 class="text-light font-weight-light m-0 p-0" style="font-size: 1em"><%= @template_logo_text || 'Rails REST Framework' %></h1>
           </span>
         </div>
       </nav>
@@ -19,13 +19,44 @@
     <div class="container py-3">
       <div class="container">
         <div class="row">
-          <h1><%= @title %></h1>
+          <h1><%= (@header_text if defined? @header_text) || @title %></h1>
         </div>
         <hr/>
-        <div class="row">
-          <h2>Payload</h2><br>
-          <div><pre><%= JSON.pretty_generate(JSON.parse(@serialized_payload)) %></pre></div>
-        </div>
+        <% if @json_payload || @xml_payload %>
+          <div class="row">
+            <h2>Payload</h2>
+            <div class="w-100">
+              <ul class="nav nav-tabs">
+                <% if @json_payload %>
+                  <li class="nav-item">
+                    <a class="nav-link active" href="#tab-json" data-toggle="tab" role="tab">
+                      JSON
+                    </a>
+                  </li>
+                <% end %>
+                <% if @xml_payload %>
+                  <li class="nav-item">
+                    <a class="nav-link" href="#tab-xml" data-toggle="tab" role="tab">
+                      XML
+                    </a>
+                  </li>
+                <% end %>
+              </ul>
+            </div>
+            <div class="tab-content w-100 pt-3">
+              <div class="tab-pane fade show active" id="tab-json" role="tab">
+                <% if @json_payload %>
+                  <div><pre><code class="language-json"><%= JSON.pretty_generate(JSON.parse(@json_payload)) unless @json_payload == '' %></code></pre></div>
+                <% end %>
+              </div>
+              <div class="tab-pane fade" id="tab-xml" role="tab">
+                <% if @xml_payload %>
+                  <div><pre><code class="language-xml"><%= @xml_payload %></code></pre></div>
+                <% end %>
+              </div>
+            </div>
+          </div>
+        <% end %>
         <% unless @routes.blank? %>
           <div class="row">
             <h2>Routes</h2>

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

@@ -3,17 +3,22 @@
 <%= csrf_meta_tags %>
 <%= csp_meta_tag rescue nil %>
 
-<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" integrity="sha384-JcKb8q3iqJ61gNV9KGb8thSsNjpSL0n8PARn9HuZOnIxN0hoP+VmmDGMN5t9UJ0Z" crossorigin="anonymous">
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.2.0/styles/vs.min.css" integrity="sha512-aWjgJTbdG4imzxTxistV5TVNffcYGtIQQm2NBNahV6LmX14Xq9WwZTL1wPjaSglUuVzYgwrq+0EuI4+vKvQHHw==" crossorigin="anonymous" />
 <style>
-h1,h2,h3,h4,h5,h6 { width: 100%; }
-h1 { font-size: 2rem; }
-h2 { font-size: 1.7rem; }
-h3 { font-size: 1.5rem; }
-h4 { font-size: 1.3rem; }
-h5 { font-size: 1.1rem; }
-h6 { font-size: 1rem; }
+  h1,h2,h3,h4,h5,h6 { width: 100%; font-weight: normal; }
+  h1 { font-size: 2rem; }
+  h2 { font-size: 1.7rem; }
+  h3 { font-size: 1.5rem; }
+  h4 { font-size: 1.3rem; }
+  h5 { font-size: 1.1rem; }
+  h6 { font-size: 1rem; }
 </style>
 
-<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
-<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+<script src="https://code.jquery.com/jquery-3.5.1.slim.min.js" integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj" crossorigin="anonymous"></script>
+<script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js" integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN" crossorigin="anonymous"></script>
+<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js" integrity="sha384-B4gt1jrGC7Jh4AgTPSdUtOBvfO8shuf57BaghqFfPlYxofvL8/KUEfYiJOMMV+rV" crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.2.0/highlight.min.js" integrity="sha512-TDKKr+IvoqZnPzc3l35hdjpHD0m+b2EC2SrLEgKDRWpxf2rFCxemkgvJ5kfU48ip+Y+m2XVKyOCD85ybtlZDmw==" crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.2.0/languages/json.min.js" integrity="sha512-FoN8JE+WWCdIGXAIT8KQXwpiavz0Mvjtfk7Rku3MDUNO0BDCiRMXAsSX+e+COFyZTcDb9HDgP+pM2RX12d4j+A==" crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/10.2.0/languages/xml.min.js" integrity="sha512-dICltIgnUP+QSJrnYGCV8943p3qSDgvcg2NU4W8IcOZP4tdrvxlXjbhIznhtVQEcXow0mOjLM0Q6/NvZsmUH4g==" crossorigin="anonymous"></script>
+<script>hljs.initHighlightingOnLoad();</script>

data/lib/rest_framework.rb

@@ -1,7 +1,7 @@
 module RESTFramework
 end
 
-require_relative "rest_framework/controllers"
+require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
 require_relative "rest_framework/routers"
 require_relative "rest_framework/version"

data/lib/rest_framework/VERSION_STAMP

@@ -1 +1 @@
-0.0.6
+0.0.12

data/lib/rest_framework/controller_mixins.rb

@@ -0,0 +1,2 @@
+require_relative 'controller_mixins/base'
+require_relative 'controller_mixins/models'

data/lib/rest_framework/controller_mixins/base.rb

@@ -0,0 +1,129 @@
+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
+
+    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
+
+        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,
+        ])
+        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
+
+    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
+
+    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[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 alias for `respond_to`/`render`. `payload` should be already serialized to Ruby
+    # primitives.
+    def api_response(payload=nil, 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
+        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
+    end
+  end
+
+end

data/lib/rest_framework/controller_mixins/models.rb

@@ -0,0 +1,222 @@
+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=)
+      end
+    end
+
+    protected
+
+    def get_serializer_class
+      return self.class.serializer_class || NativeModelSerializer
+    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
+
+      # index action should use :list fields if :index is not provided
+      action = :list if action == :index && !action_fields.key?(:index)
+
+      return (action_fields[action] if action) || self.class.fields || []
+    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
+
+      # index action should use :list serializer config if :index is not provided
+      action = :list if action == :index && !action_serializer_config.key?(:index)
+
+      return (action_serializer_config[action] if action) || self.class.native_serializer_config
+    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
+
+      # index action should use :list allowed parameters if :index is not provided
+      action = :list if action == :index && !allowed_action_parameters.key?(:index)
+
+      return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
+    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
+
+    # 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
+    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
+    end
+
+    # Internal interface for get_recordset, protecting against infinite recursion with get_model.
+    def _get_recordset(from_internal_get_model: false)
+      return @recordset if instance_variable_defined?(:@recordset) && @recordset
+      return self.class.recordset if self.class.recordset
+      unless from_internal_get_model  # prevent infinite recursion
+        model = self._get_model(from_internal_get_recordset: true)
+        return (@recordset = model.all) if model
+      end
+      return nil
+    end
+
+    # Get the model for this controller.
+    def get_model
+      return _get_model
+    end
+
+    # Get the set of records this controller has access to.
+    def get_recordset
+      return _get_recordset
+    end
+  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
+  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)
+    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
+  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
+  end
+
+  module DestroyModelMixin
+    def destroy
+      @record = self.get_record
+      @record.destroy!
+      api_response(nil)
+    end
+  end
+
+  module ReadOnlyModelControllerMixin
+    include BaseModelControllerMixin
+    def self.included(base)
+      if base.is_a? Class
+        BaseModelControllerMixin.included(base)
+      end
+    end
+
+    include ListModelMixin
+    include ShowModelMixin
+  end
+
+  module ModelControllerMixin
+    include BaseModelControllerMixin
+    def self.included(base)
+      if base.is_a? Class
+        BaseModelControllerMixin.included(base)
+      end
+    end
+
+    include ListModelMixin
+    include ShowModelMixin
+    include CreateModelMixin
+    include UpdateModelMixin
+    include DestroyModelMixin
+  end
+
+end

data/lib/rest_framework/routers.rb

@@ -1,4 +1,3 @@
-require 'rails'
 require 'action_dispatch/routing/mapper'
 
 module ActionDispatch::Routing
@@ -67,11 +66,11 @@ module ActionDispatch::Routing
 
       # call either `resource` or `resources`, passing appropriate modifiers
       skip_undefined = kwargs.delete(:skip_undefined) || true
-      skip = controller_class.skip_actions(skip_undefined: skip_undefined)
+      skip = controller_class.get_skip_actions(skip_undefined: skip_undefined)
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do
-            actions = controller_class.extra_member_actions
+            actions = controller_class.extra_member_actions || {}
             actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
             actions.each do |action, methods|
               methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
@@ -83,8 +82,9 @@ module ActionDispatch::Routing
         end
 
         collection do
-          actions = controller_class.extra_actions
+          actions = controller_class.extra_actions || {}
           actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
+          actions.reject! { |k,v| skip.include? k }
           actions.each do |action, methods|
             methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
             methods.each do |m|
@@ -111,6 +111,26 @@ module ActionDispatch::Routing
       end
     end
 
+    # Route a controller without the default resourceful paths.
+    def rest_route(path=nil, skip_undefined: true, **kwargs, &block)
+      controller = kwargs.delete(:controller) || path
+      path = path.to_s
+
+      # route actions
+      controller_class = self._get_controller_class(controller, pluralize: false)
+      skip = controller_class.get_skip_actions(skip_undefined: skip_undefined)
+      actions = controller_class.extra_actions || {}
+      actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
+      actions.reject! { |k,v| skip.include? k }
+      actions.each do |action, methods|
+        methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
+        methods.each do |m|
+          public_send(m, File.join(path, action.to_s), controller: controller, action: action)
+        end
+        yield if block_given?
+      end
+    end
+
     # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
     # @param label [Symbol] the snake_case name of the controller
     def rest_root(path=nil, **kwargs, &block)
@@ -124,7 +144,7 @@ module ActionDispatch::Routing
 
       # route any additional actions
       controller_class = self._get_controller_class(controller, pluralize: false)
-      controller_class.extra_actions.each do |action, methods|
+      (controller_class.extra_actions || {}).each do |action, methods|
         methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
         methods.each do |m|
           public_send(m, File.join(path, action.to_s), controller: controller, action: action)

data/lib/rest_framework/serializers.rb

@@ -0,0 +1,108 @@
+module RESTFramework
+  class BaseSerializer
+    attr_reader :errors
+
+    def initialize(object: nil, data: nil, controller: nil, **kwargs)
+      @object = object
+      @data = data
+      @controller = controller
+    end
+  end
+
+  # This serializer uses `.as_json` to serialize objects. Despite the name, `.as_json` is a Rails
+  # method which converts objects to Ruby primitives (with the top-level being either an array or a
+  # hash).
+  class NativeModelSerializer < BaseSerializer
+    class_attribute :config
+    class_attribute :singular_config
+    class_attribute :plural_config
+    class_attribute :action_config
+
+    def initialize(model: nil, many: nil, **kwargs)
+      super(**kwargs)
+      @many = many
+      @model = model || (@controller ? @controller.send(:get_model) : nil)
+    end
+
+    # Get controller action, if possible.
+    def get_action
+      return @controller&.action_name&.to_sym
+    end
+
+    # Get a locally defined configuration, if one is defined.
+    def get_local_serializer_config
+      action = self.get_action
+
+      if action && self.action_config
+        # index action should use :list serializer config if :index is not provided
+        action = :list if action == :index && !self.action_config.key?(:index)
+
+        return self.action_config[action] if self.action_config[action]
+      end
+
+      # no action_config, so try singular/plural config
+      return self.plural_config if @many && self.plural_config
+      return self.singular_config if !@many && self.singular_config
+
+      # lastly, try the default config
+      return self.config
+    end
+
+    # Get a configuration passable to `as_json` for the model.
+    def get_serializer_config
+      # return a locally defined serializer config if one is defined
+      local_config = self.get_local_serializer_config
+      return local_config if local_config
+
+      # return a serializer config if one is defined
+      serializer_config = @controller.send(:get_native_serializer_config)
+      return serializer_config if serializer_config
+
+      # otherwise, build a serializer config from fields
+      fields = @controller.send(:get_fields) if @controller
+      unless fields.blank?
+        columns, methods = fields.partition { |f| f.to_s.in?(@model.column_names) }
+        return {only: columns, methods: methods}
+      end
+
+      return {}
+    end
+
+    # Convert the object(s) to Ruby primitives.
+    def serialize
+      if @object
+        @many = @object.respond_to?(:each) if @many.nil?
+        return @object.as_json(self.get_serializer_config)
+      end
+      return nil
+    end
+
+    # Allow a serializer instance to be used as a hash directly in a nested serializer config.
+    def [](key)
+      unless instance_variable_defined?(:@_nested_config)
+        @_nested_config = self.get_serializer_config
+      end
+      return @_nested_config[key]
+    end
+    def []=(key, value)
+      unless instance_variable_defined?(:@_nested_config)
+        @_nested_config = self.get_serializer_config
+      end
+      return @_nested_config[key] = value
+    end
+
+    # Allow a serializer class to be used as a hash directly in a nested serializer config.
+    def self.[](key)
+      unless instance_variable_defined?(:@_nested_config)
+        @_nested_config = self.new.get_serializer_config
+      end
+      return @_nested_config[key]
+    end
+    def self.[]=(key, value)
+      unless instance_variable_defined?(:@_nested_config)
+        @_nested_config = self.new.get_serializer_config
+      end
+      return @_nested_config[key] = value
+    end
+  end
+end

data/lib/rest_framework/version.rb

@@ -8,10 +8,10 @@ module RESTFramework
 
       # First, attempt to get the version from git.
       begin
-        version = `git describe`.strip
+        version = `git describe 2>/dev/null`.strip
         raise "blank version" if version.nil? || version.match(/^\w*$/)
         # Check for local changes.
-        changes = `git status --porcelain`
+        changes = `git status --porcelain 2>/dev/null`
         version << '.localchanges' if changes.strip.length > 0
         return version
       rescue
@@ -21,7 +21,7 @@ module RESTFramework
       begin
         version = File.read(File.expand_path("VERSION_STAMP", __dir__))
         unless version.nil? || version.match(/^\w*$/)
-          return (@_version = version)  # cache VERSION_STAMP content in @_version
+          return (@_version = version)  # cache VERSION_STAMP content
         end
       rescue
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.12
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -39,11 +39,12 @@ files:
 - app/views/rest_framework/default.html.erb
 - lib/rest_framework.rb
 - lib/rest_framework/VERSION_STAMP
-- lib/rest_framework/controllers.rb
-- lib/rest_framework/controllers/base.rb
-- lib/rest_framework/controllers/models.rb
+- lib/rest_framework/controller_mixins.rb
+- lib/rest_framework/controller_mixins/base.rb
+- lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
 - lib/rest_framework/routers.rb
+- lib/rest_framework/serializers.rb
 - lib/rest_framework/version.rb
 homepage: https://github.com/gregschmit/rails-rest-framework
 licenses:

data/lib/rest_framework/controllers.rb

@@ -1,2 +0,0 @@
-require_relative 'controllers/base'
-require_relative 'controllers/models'

data/lib/rest_framework/controllers/base.rb

@@ -1,121 +0,0 @@
-module RESTFramework
-
-  # This module provides helpers for mixin `ClassMethods` submodules.
-  module ClassMethodHelpers
-    # This helper assists in providing reader interfaces for mixin properties.
-    def _restframework_attr_reader(property, default: nil)
-      method = <<~RUBY
-        def #{property}
-          return _restframework_try_class_level_variable_get(
-            #{property.inspect},
-            default: #{default.inspect},
-          )
-        end
-      RUBY
-      self.module_eval(method)
-    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 BaseControllerMixin
-    # Default action for API root.
-    def root
-      api_response({message: "This is the root of your awesome API!"})
-    end
-
-    protected
-
-    module ClassMethods
-      extend ClassMethodHelpers
-
-      # Interface for getting class-level instance/class variables. Note: we check if they are
-      # defined first rather than rescuing NameError to prevent uninitialized variable warnings.
-      private def _restframework_try_class_level_variable_get(name, default: nil)
-        instance_variable = "@#{name}"
-        if self.instance_variable_defined?(instance_variable)
-          v = self.instance_variable_get(instance_variable)
-          return v unless v.nil?
-        end
-        class_variable = "@@#{name}"
-        if self.class_variable_defined?(class_variable)
-          v = self.class_variable_get(class_variable)
-          return v unless v.nil?
-        end
-        return default
-      end
-
-      _restframework_attr_reader(:singleton_controller)
-      _restframework_attr_reader(:extra_actions, default: {})
-      _restframework_attr_reader(:template_logo_text, default: 'Rails REST Framework')
-
-      def skip_actions(skip_undefined: true)
-        # first, skip explicitly skipped actions
-        skip = _restframework_try_class_level_variable_get(:skip_actions, default: [])
-
-        # 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)
-      base.extend ClassMethods
-    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[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 alias for `respond_to`/`render`, and replace nil responses with blank ones.
-    def api_response(payload, html_kwargs: nil, json_kwargs: nil, **kwargs)
-      payload ||= ''  # replace nil with ''
-      html_kwargs ||= {}
-      json_kwargs ||= {}
-
-      # serialize
-      if self.respond_to?(:get_model_serializer_config, true)
-        serialized_payload = payload.to_json(self.get_model_serializer_config)
-      else
-        serialized_payload = payload.to_json
-      end
-
-      respond_to do |format|
-        format.html {
-          kwargs = kwargs.merge(html_kwargs)
-          @template_logo_text ||= self.class.template_logo_text
-          @title ||= self.controller_name.camelize
-          @routes ||= self._get_routes
-          @payload = payload
-          @serialized_payload = serialized_payload
-          begin
-            render(**kwargs)
-          rescue ActionView::MissingTemplate  # fallback to rest_framework default view
-            kwargs[:template] = "rest_framework/default"
-          end
-          render(**kwargs)
-        }
-        format.json {
-          kwargs = kwargs.merge(json_kwargs)
-          render(json: serialized_payload || '', **kwargs)
-        }
-      end
-    end
-  end
-
-end

data/lib/rest_framework/controllers/models.rb

@@ -1,223 +0,0 @@
-require_relative 'base'
-
-module RESTFramework
-
-  module BaseModelControllerMixin
-    include BaseControllerMixin
-
-    # By default (and for now), we will just use `as_json`, but we should consider supporting:
-    #   active_model_serializers (problem:
-    #     https://github.com/rails-api/active_model_serializers#whats-happening-to-ams)
-    #   fast_jsonapi (really good and fast serializers)
-    #@serializer
-    #@list_serializer
-    #@show_serializer
-    #@create_serializer
-    #@update_serializer
-
-    module ClassMethods
-      extend ClassMethodHelpers
-      include BaseControllerMixin::ClassMethods
-
-      _restframework_attr_reader(:model)
-      _restframework_attr_reader(:recordset)
-
-      _restframework_attr_reader(:fields)
-      _restframework_attr_reader(:list_fields)
-      _restframework_attr_reader(:show_fields)
-      _restframework_attr_reader(:create_fields)
-      _restframework_attr_reader(:update_fields)
-
-      _restframework_attr_reader(:extra_member_actions, default: {})
-
-      # For model-based mixins, `@extra_collection_actions` is synonymous with `@extra_actions`.
-      # @param skip_undefined [Boolean] whether we should skip routing undefined actions
-      def extra_actions(skip_undefined: true)
-        actions = (
-          _restframework_try_class_level_variable_get(:extra_collection_actions) ||
-          _restframework_try_class_level_variable_get(:extra_actions, default: {})
-        )
-        actions = actions.select { |a| self.method_defined?(a) } if skip_undefined
-        return actions
-      end
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    protected
-
-    # Get a list of fields for the current action.
-    def get_fields
-      return @fields if instance_variable_defined?(:@fields) && @fields
-
-      # index action should use list_fields
-      name = (action_name == 'index') ? 'list' : action_name
-
-      begin
-        @fields = self.class.send("#{name}_fields")
-      rescue NameError
-      end
-
-      return @fields ||= self.class.fields || []
-    end
-
-    # Get a configuration passable to `as_json` for the model.
-    def get_model_serializer_config
-      fields = self.get_fields
-      unless fields.blank?
-        columns, methods = fields.partition { |f| f.to_s.in?(self.get_model.column_names) }
-        return {only: columns, methods: methods}
-      end
-      return {}
-    end
-
-    # Filter the request body for keys allowed by the current action's field config.
-    def _get_field_values_from_request_body
-      return @_get_field_values_from_request_body ||= (request.request_parameters.select { |p|
-        self.get_fields.include?(p.to_sym) || self.get_fields.include?(p.to_s)
-      })
-    end
-    alias :get_create_params :_get_field_values_from_request_body
-    alias :get_update_params :_get_field_values_from_request_body
-
-    # Filter params for keys allowed by the current action's field config.
-    def _get_field_values_from_params
-      return @_get_field_values_from_params ||= params.permit(*self.get_fields)
-    end
-    alias :get_lookup_params :_get_field_values_from_params
-    alias :get_filter_params :_get_field_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)
-      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]
-      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
-    end
-
-    # Internal interface for get_recordset, protecting against infinite recursion with get_model.
-    def _get_recordset(from_internal_get_model: false)
-      return @recordset if instance_variable_defined?(:@recordset) && @recordset
-      return self.class.recordset if self.class.recordset
-      unless from_internal_get_model  # prevent infinite recursion
-        model = self._get_model(from_internal_get_recordset: true)
-        return (@recordset = model.all) if model
-      end
-      return nil
-    end
-
-    # Get the model for this controller.
-    def get_model
-      return _get_model
-    end
-
-    # Get the base set of records this controller has access to.
-    def get_recordset
-      return _get_recordset
-    end
-  end
-
-  module ListModelMixin
-    # TODO: pagination classes like Django
-    def index
-      @records = self.get_filtered_recordset
-      api_response(@records)
-    end
-  end
-
-  module ShowModelMixin
-    def show
-      @record = self.get_record
-      api_response(@record)
-    end
-  end
-
-  module CreateModelMixin
-    def create
-      begin
-        @record = self.get_model.create!(self.get_create_params)
-      rescue ActiveRecord::RecordInvalid => e
-        api_response(e.record.messages, status: 400)
-      end
-      api_response(@record)
-    end
-  end
-
-  module UpdateModelMixin
-    def update
-      @record = self.get_record
-      if @record
-        @record.attributes(self.get_update_params)
-        @record.save!
-        api_response(@record)
-      else
-        api_response({detail: "Record not found."}, status: 404)
-      end
-    end
-  end
-
-  module DestroyModelMixin
-    def destroy
-      @record = self.get_record
-      if @record
-        @record.destroy!
-        api_response('')
-      else
-        api_response({detail: "Method 'DELETE' not allowed."}, status: 405)
-      end
-    end
-  end
-
-  module ReadOnlyModelControllerMixin
-    include BaseModelControllerMixin
-    def self.included(base)
-      base.extend BaseModelControllerMixin::ClassMethods
-    end
-
-    include ListModelMixin
-    include ShowModelMixin
-  end
-
-  module ModelControllerMixin
-    include BaseModelControllerMixin
-    def self.included(base)
-      base.extend BaseModelControllerMixin::ClassMethods
-    end
-
-    include ListModelMixin
-    include ShowModelMixin
-    include CreateModelMixin
-    include UpdateModelMixin
-    include DestroyModelMixin
-  end
-
-end