rest_framework 0.3.7 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfa62b5fb49a4c30fabee7308e785d495f244b8aec21be6d5fc99bf0f2f8a3aa
-  data.tar.gz: 65e70b6fd5eb3b1d06d54da6044035f1ca418f440b666e81bc7fee7d89ff0e7b
+  metadata.gz: 9791b0cbb0a806afa00955abf151c7d04bd1820bdbe189f237badc9782f87d6b
+  data.tar.gz: 69e29341f8804fac7894c0065b0f5535d88b0e8d60577bc77677fe13d633f2d5
 SHA512:
-  metadata.gz: 2e92adef73b6fe78b9381480015c950b20e8a14e91a49f24b655e4f58a7ba1870e4d7d5b33a1983be514e50215a6c1a8e2197e1008faf4eae4b2da16072ddde0
-  data.tar.gz: 27bc294410be0d235db8fccd20bc48b013a9814a0ac3b26fc01f5f7f46905738f6a65dd3fcdf4d54946b70cdeb9eb11c60b33139b169bd83ff8d4cbad76aaf60
+  metadata.gz: f04bf8059e765db9e13a9729db43c2b26a914035063fe728e9ad0bcb1ab968bb8939a4d278e239a39f64b671d183bfdd7a2487248495cd7e5bd26b93ac49a103
+  data.tar.gz: '0908d43c8b2188e4dde5920a84eb621c0dea2dc170891e314d77d95b823a32af6681ae9a6028277f32282b88be03f8e95da55ec310f75e3c89ec8c3a09934f09'

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Gregory N. Schmit
+Copyright (c) 2022 Gregory N. Schmit
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/VERSION

@@ -1 +1 @@
-0.3.7
+0.5.0

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

@@ -29,14 +29,14 @@
               <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">
+                    <a class="nav-link active" href="#tab-json" data-bs-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">
+                    <a class="nav-link" href="#tab-xml" data-bs-toggle="tab" role="tab">
                       .xml
                     </a>
                   </li>
@@ -57,7 +57,7 @@
             </div>
           </div>
         <% end %>
-        <% unless @routes.blank? %>
+        <% unless @route_groups.blank? %>
           <div class="row">
             <h2>Routes</h2>
             <%= render partial: 'rest_framework/routes' %>

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

@@ -1,11 +1,12 @@
 <meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+<meta name="viewport" content="width=device-width, initial-scale=1">
 <%= csrf_meta_tags %>
 <%= csp_meta_tag rescue nil %>
 
-<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" />
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/css/bootstrap.min.css" integrity="sha384-F3w7mX95PdgyTmZZMECAngseQB83DfGTowi0iMjiWaeVhAn4FJkqJByhZMI3AhiU" 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>
+  /* Adjust headers to always take up their entire row, and tweak the sizing. */
   h1,h2,h3,h4,h5,h6 { width: 100%; font-weight: normal; }
   h1 { font-size: 2rem; }
   h2 { font-size: 1.7rem; }
@@ -13,11 +14,27 @@
   h4 { font-size: 1.3rem; }
   h5 { font-size: 1.1rem; }
   h6 { font-size: 1rem; }
+
+  /* Make route group expansion obvious to the user. */
+  .rrf-routes .rrf-route-group-header {
+    background-color: #f8f8f8;
+  }
+  .rrf-routes .rrf-route-group-header:hover {
+    background-color: #f0f0f0;
+  }
+  .rrf-routes .rrf-route-group-header td {
+    cursor: pointer;
+  }
+
+  /* Disable bootstrap's collapsing animation because in tables it causes delayed jerkiness. */
+  .rrf-routes .collapsing {
+    -webkit-transition: none;
+    transition: none;
+    display: none;
+  }
 </style>
 
-<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://cdn.jsdelivr.net/npm/bootstrap@5.1.1/dist/js/bootstrap.bundle.min.js" integrity="sha384-/bQdsTh/da6pkI1MST/rWKFNjaCP5gBSY4sEBT38Q/9RBh9AH40zEOg7Hlq2THRZ" 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>

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

@@ -0,0 +1,9 @@
+<tr>
+  <td><%= route[:path] %></td>
+  <td><%= route[:verb] %></td>
+  <% if route[:controller] && route[:action] %>
+    <td><%= route[:controller] %>#<%= route[:action] %></td>
+  <% else %>
+    <td><%= route[:route_app] %></td>
+  <% end %>
+</tr>

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

@@ -1,18 +1,28 @@
-<table class="table">
-  <thead>
-    <tr>
-      <th scope="col">Verb</th>
-      <th scope="col">Path</th>
-      <th scope="col">Action</th>
-    </tr>
-  </thead>
-  <tbody>
-    <% @routes.each do |r| %>
-    <tr>
-      <td><%= r[:verb] %></td>
-      <td><%= r[:path] %></td>
-      <td><%= r[:action] %></td>
-    </tr>
+<div class="table-responsive">
+  <table class="table table-responsive rrf-routes">
+    <thead>
+      <tr>
+        <th scope="col">Path</th>
+        <th scope="col">Verb</th>
+        <th scope="col">Controller#Action</th>
+      </tr>
+    </thead>
+    <%# Render first group of routes directly. %>
+    <tbody>
+      <% @route_groups.values[0].each do |route| %>
+        <%= render partial: "rest_framework/route", locals: {route: route} %>
+      <% end %>
+    </tbody>
+    <%# Render any other groups under dropdowns. %>
+    <% @route_groups.drop(1).each_with_index do |(name, route_group), index| %>
+      <tr data-bs-toggle="collapse" data-bs-target="#route-group-<%= index %>" class="rrf-route-group-header">
+        <td colspan="3" class="text-center user-select-none"><%= name %></td>
+      </tr>
+      <tbody id="route-group-<%= index %>" class="collapse">
+        <% route_group.each do |route| %>
+          <%= render partial: "rest_framework/route", locals: {route: route} %>
+        <% end %>
+      </tbody>
     <% end %>
-  </tbody>
-</table>
+  </table>
+</div>

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,6 +1,6 @@
-require_relative '../errors'
-require_relative '../serializers'
-
+require_relative "../errors"
+require_relative "../serializers"
+require_relative "../utils"
 
 # 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`
@@ -29,8 +29,8 @@ module RESTFramework::BaseControllerMixin
   end
 
   def self.included(base)
-    if base.is_a? Class
-      base.extend ClassMethods
+    if base.is_a?(Class)
+      base.extend(ClassMethods)
 
       # Add class attributes (with defaults) unless they already exist.
       {
@@ -42,8 +42,8 @@ module RESTFramework::BaseControllerMixin
         filter_backends: nil,
         paginator_class: nil,
         page_size: 20,
-        page_query_param: 'page',
-        page_size_query_param: 'page_size',
+        page_query_param: "page",
+        page_size_query_param: "page_size",
         max_page_size: nil,
         serializer_class: nil,
         serialize_to_json: true,
@@ -51,13 +51,13 @@ module RESTFramework::BaseControllerMixin
         singleton_controller: nil,
         skip_actions: nil,
       }.each do |a, default|
-        unless base.respond_to?(a)
-          base.class_attribute(a)
+        next if base.respond_to?(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
+        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
 
       # Alias `extra_actions` to `extra_collection_actions`.
@@ -67,7 +67,11 @@ module RESTFramework::BaseControllerMixin
       end
 
       # Skip csrf since this is an API.
-      base.skip_before_action(:verify_authenticity_token) rescue nil
+      begin
+        base.skip_before_action(:verify_authenticity_token)
+      rescue
+        nil
+      end
 
       # Handle some common exceptions.
       base.rescue_from(ActiveRecord::RecordNotFound, with: :record_not_found)
@@ -81,7 +85,14 @@ module RESTFramework::BaseControllerMixin
 
   # Helper to get the configured serializer class.
   def get_serializer_class
-    return self.class.serializer_class
+    return nil unless serializer_class = self.class.serializer_class
+
+    # Wrap it with an adapter if it's an active_model_serializer.
+    if defined?(ActiveModel::Serializer) && (serializer_class < ActiveModel::Serializer)
+      serializer_class = RESTFramework::ActiveModelSerializerAdapterFactory.for(serializer_class)
+    end
+
+    return serializer_class
   end
 
   # Helper to get filtering backends, defaulting to no backends.
@@ -100,9 +111,9 @@ module RESTFramework::BaseControllerMixin
   end
 
   def record_invalid(e)
-    return api_response({
-      message: "Record invalid.", exception: e, errors: e.record&.errors
-    }, status: 400)
+    return api_response(
+      {message: "Record invalid.", exception: e, errors: e.record&.errors}, status: 400
+    )
   end
 
   def record_not_found(e)
@@ -110,31 +121,15 @@ module RESTFramework::BaseControllerMixin
   end
 
   def record_not_saved(e)
-    return api_response({
-      message: "Record not saved.", exception: e, errors: e.record&.errors
-    }, status: 406)
+    return api_response(
+      {message: "Record not saved.", exception: e, errors: e.record&.errors}, status: 406
+    )
   end
 
   def record_not_destroyed(e)
-    return api_response({
-      message: "Record not destroyed.", exception: e, errors: e.record&.errors
-    }, 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
-      # :nocov:
-      formatter = ActionDispatch::Routing::ConsoleFormatter
-      # :nocov:
-    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 api_response(
+      {message: "Record not destroyed.", exception: e, errors: e.record&.errors}, status: 406
+    )
   end
 
   # Helper to render a browsable API for `html` format, along with basic `json`/`xml` formats, and
@@ -153,38 +148,38 @@ module RESTFramework::BaseControllerMixin
     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
+      if payload == ""
+        format.json { head(:no_content) } if self.class.serialize_to_json
+        format.xml { head(:no_content) } if self.class.serialize_to_xml
       else
         format.json {
           jkwargs = kwargs.merge(json_kwargs)
           render(json: payload, layout: false, **jkwargs)
-        } if self.serialize_to_json
+        } if self.class.serialize_to_json
         format.xml {
           xkwargs = kwargs.merge(xml_kwargs)
           render(xml: payload, layout: false, **xkwargs)
-        } if self.serialize_to_xml
+        } if self.class.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
+        if payload == ""
+          @json_payload = "" if self.class.serialize_to_json
+          @xml_payload = "" if self.class.serialize_to_xml
         else
-          @json_payload = payload.to_json if self.serialize_to_json
-          @xml_payload = payload.to_xml if self.serialize_to_xml
+          @json_payload = payload.to_json if self.class.serialize_to_json
+          @xml_payload = payload.to_xml if self.class.serialize_to_xml
         end
         @template_logo_text ||= "Rails REST Framework"
         @title ||= self.controller_name.camelize
-        @routes ||= self._get_routes
+        @route_groups ||= RESTFramework::Utils.get_routes(Rails.application.routes, request)
         hkwargs = kwargs.merge(html_kwargs)
         begin
           render(**hkwargs)
         rescue ActionView::MissingTemplate  # fallback to rest_framework layout
           hkwargs[:layout] = "rest_framework"
-          hkwargs[:html] = ''
+          hkwargs[:html] = ""
           render(**hkwargs)
         end
       }

data/lib/rest_framework/controller_mixins/models.rb

@@ -1,13 +1,12 @@
-require_relative 'base'
-require_relative '../filters'
-
+require_relative "base"
+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
+    if base.is_a?(Class)
       RESTFramework::BaseControllerMixin.included(base)
 
       # Add class attributes (with defaults) unless they already exist.
@@ -22,7 +21,7 @@ module RESTFramework::BaseModelControllerMixin
 
         # Attributes for finding records.
         find_by_fields: nil,
-        find_by_query_param: 'find_by',
+        find_by_query_param: "find_by",
 
         # Attributes for create/update parameters.
         allowed_parameters: nil,
@@ -32,27 +31,28 @@ module RESTFramework::BaseModelControllerMixin
         native_serializer_config: nil,
         native_serializer_singular_config: nil,
         native_serializer_plural_config: nil,
+        native_serializer_except_query_param: "except",
 
         # Attributes for default model filtering (and ordering).
         filterset_fields: nil,
         ordering_fields: nil,
-        ordering_query_param: 'ordering',
+        ordering_query_param: "ordering",
         ordering_no_reorder: false,
         search_fields: nil,
-        search_query_param: 'search',
+        search_query_param: "search",
         search_ilike: false,
 
         # Other misc attributes.
         create_from_recordset: true,  # Option for `recordset.create` vs `Model.create` behavior.
         filter_recordset_before_find: true,  # Option to control if filtering is done before find.
       }.each do |a, default|
-        unless base.respond_to?(a)
-          base.class_attribute(a)
+        next if base.respond_to?(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
+        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
@@ -105,7 +105,7 @@ module RESTFramework::BaseModelControllerMixin
 
   # Helper to get the configured serializer class, or `NativeSerializer` as a default.
   def get_serializer_class
-    return self.class.serializer_class || RESTFramework::NativeSerializer
+    return super || RESTFramework::NativeSerializer
   end
 
   # Helper to get filtering backends, defaulting to using `ModelFilter` and `ModelOrderingFilter`.
@@ -143,8 +143,8 @@ module RESTFramework::BaseModelControllerMixin
       body_params
     end
   end
-  alias :get_create_params :get_body_params
-  alias :get_update_params :get_body_params
+  alias_method :get_create_params, :get_body_params
+  alias_method :get_update_params, :get_body_params
 
   # Get the model for this controller.
   def get_model(from_get_recordset: false)
@@ -160,7 +160,7 @@ module RESTFramework::BaseModelControllerMixin
 
     # Try to determine model from controller name.
     begin
-      return (@model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize)
+      return @model = self.class.name.demodulize.match(/(.*)Controller/)[1].singularize.constantize
     rescue NameError
     end
 
@@ -196,48 +196,51 @@ module RESTFramework::BaseModelControllerMixin
       recordset = self.get_filtered_data(recordset)
     end
 
-    # Return the record.
-    if find_by_value = params[:id]  # Route key is always :id by Rails convention.
-      return self.get_recordset.find_by!(find_by_key => find_by_value)
-    end
-    return nil
+    # Return the record. Route key is always :id by Rails convention.
+    return recordset.find_by!(find_by_key => params[:id])
   end
 end
 
-
 # Mixin for listing records.
 module RESTFramework::ListModelMixin
   def index
+    api_response(self._index)
+  end
+
+  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)
+      serialized_page = self.get_serializer_class.new(page, controller: self).serialize
+      return paginator.get_paginated_response(serialized_page)
     else
-      data = self.get_serializer_class.new(object: @records, controller: self).serialize
+      return self.get_serializer_class.new(@records, controller: self).serialize
     end
-
-    return api_response(data)
   end
 end
 
-
 # Mixin for showing records.
 module RESTFramework::ShowModelMixin
   def show
+    api_response(self._show)
+  end
+
+  def _show
     @record = self.get_record
-    serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
-    return api_response(serialized_record)
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for creating records.
 module RESTFramework::CreateModelMixin
   def create
+    api_response(self._create)
+  end
+
+  def _create
     if self.get_recordset.respond_to?(:create!) && self.create_from_recordset
       # Create with any properties inherited from the recordset.
       @record = self.get_recordset.create!(self.get_create_params)
@@ -245,39 +248,43 @@ module RESTFramework::CreateModelMixin
       # 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)
+
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for updating records.
 module RESTFramework::UpdateModelMixin
   def update
+    api_response(self._update)
+  end
+
+  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)
+    return self.get_serializer_class.new(@record, controller: self).serialize
   end
 end
 
-
 # Mixin for destroying records.
 module RESTFramework::DestroyModelMixin
   def destroy
+    self._destroy
+    api_response("")
+  end
+
+  def _destroy
     @record = self.get_record
     @record.destroy!
-    api_response('')
   end
 end
 
-
 # Mixin that includes show/list mixins.
 module RESTFramework::ReadOnlyModelControllerMixin
   include RESTFramework::BaseModelControllerMixin
 
   def self.included(base)
-    if base.is_a? Class
+    if base.is_a?(Class)
       RESTFramework::BaseModelControllerMixin.included(base)
     end
   end
@@ -286,13 +293,12 @@ module RESTFramework::ReadOnlyModelControllerMixin
   include RESTFramework::ShowModelMixin
 end
 
-
 # Mixin that includes all the CRUD mixins.
 module RESTFramework::ModelControllerMixin
   include RESTFramework::BaseModelControllerMixin
 
   def self.included(base)
-    if base.is_a? Class
+    if base.is_a?(Class)
       RESTFramework::BaseModelControllerMixin.included(base)
     end
   end

data/lib/rest_framework/controller_mixins.rb

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

data/lib/rest_framework/errors.rb

@@ -2,10 +2,9 @@
 class RESTFramework::Error < StandardError
 end
 
-
 class RESTFramework::NilPassedToAPIResponseError < RESTFramework::Error
   def message
-    return <<~MSG.split("\n").join(' ')
+    return <<~MSG.split("\n").join(" ")
       Payload of `nil` was passed to `api_response`; this is unsupported. If you want a blank
       response, pass `''` (an empty string) as the payload. If this was the result of a `find_by`
       (or similar Active Record method) not finding a record, you should use the bang version (e.g.,

data/lib/rest_framework/filters.rb

@@ -8,7 +8,6 @@ class RESTFramework::BaseFilter
   end
 end
 
-
 # A simple filtering backend that supports filtering a recordset based on fields defined on the
 # controller class.
 class RESTFramework::ModelFilter < RESTFramework::BaseFilter
@@ -31,19 +30,19 @@ class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   end
 end
 
-
 # A filter backend which handles ordering of the recordset.
 class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   # Convert ordering string to an ordering configuration.
   def _get_ordering
     return nil if @controller.class.ordering_query_param.blank?
+
     ordering_fields = @controller.send(:get_ordering_fields)
     order_string = @controller.params[@controller.class.ordering_query_param]
 
     unless order_string.blank?
       ordering = {}
-      order_string.split(',').each do |field|
-        if field[0] == '-'
+      order_string.split(",").each do |field|
+        if field[0] == "-"
           column = field[1..-1]
           direction = :desc
         else
@@ -63,7 +62,7 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   # Order data according to the request query parameters.
   def get_filtered_data(data)
     ordering = self._get_ordering
-    reorder = !@controller.send(:ordering_no_reorder)
+    reorder = !@controller.class.ordering_no_reorder
 
     if ordering && !ordering.empty?
       return data.send(reorder ? :reorder : :order, _get_ordering)
@@ -73,19 +72,21 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   end
 end
 
-
 # Multi-field text searching on models.
 class RESTFramework::ModelSearchFilter < RESTFramework::BaseFilter
   # Filter data according to the request query parameters.
   def get_filtered_data(data)
     fields = @controller.send(:get_search_fields)
-    search = @controller.request.query_parameters[@controller.send(:search_query_param)]
+    search = @controller.request.query_parameters[@controller.class.search_query_param]
 
     # Ensure we use array conditions to prevent SQL injection.
     unless search.blank?
-      return data.where(fields.map { |f|
-        "CAST(#{f} AS CHAR) #{@controller.send(:search_ilike) ? "ILIKE" : "LIKE"} ?"
-      }.join(' OR '), *(["%#{search}%"] * fields.length))
+      return data.where(
+        fields.map { |f|
+          "CAST(#{f} AS CHAR) #{@controller.class.search_ilike ? "ILIKE" : "LIKE"} ?"
+        }.join(" OR "),
+        *(["%#{search}%"] * fields.length),
+      )
     end
 
     return data

data/lib/rest_framework/generators/controller_generator.rb

@@ -1,7 +1,6 @@
-require 'rails/generators'
+require "rails/generators"
 
-
-# Some projects don't have the inflection "REST" as an acronym, so this is a helper class to prevent
+# Most projects don't have the inflection "REST" as an acronym, so this is a helper class to prevent
 # this generator from being namespaced under `r_e_s_t_framework`.
 # :nocov:
 class RESTFrameworkCustomGeneratorControllerNamespace < String
@@ -11,18 +10,17 @@ class RESTFrameworkCustomGeneratorControllerNamespace < String
 end
 # :nocov:
 
-
 class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
-  PATH_REGEX = /^\/*([a-z0-9_\/]*[a-z0-9_])(?:[\.a-z\/]*)$/
+  PATH_REGEX = %r{^[a-z0-9][a-z0-9_/]+$}
 
   desc <<~END
-  Description:
+    Description:
       Generates a new REST Framework controller.
 
       Specify the controller as a path, including the module, if needed, like:
       'parent_module/controller_name'.
 
-  Example:
+    Example:
       `rails generate rest_framework:controller user_api/groups`
 
       Generates a controller at `app/controllers/user_api/groups_controller.rb` named
@@ -31,10 +29,7 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
 
   argument :path, type: :string
   class_option(
-    :parent_class,
-    type: :string,
-    default: 'ApplicationController',
-    desc: "Inheritance parent",
+    :parent_class, type: :string, default: "ApplicationController", desc: "Inheritance parent"
   )
   class_option(
     :include_base,
@@ -50,11 +45,13 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
   end
 
   def create_rest_controller_file
-    unless (path_match = PATH_REGEX.match(self.path))
-      raise StandardError.new("Path isn't correct.")
+    unless PATH_REGEX.match?(self.path)
+      raise StandardError, "Path isn't valid."
     end
 
-    cleaned_path = path_match[1]
+    # Remove '_controller' from end of path, if it exists.
+    cleaned_path = self.path.delete_suffix("_controller")
+
     content = <<~END
       class #{cleaned_path.camelize}Controller < #{options[:parent_class]}
         include RESTFramework::#{
@@ -62,6 +59,6 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
         }
       end
     END
-    create_file("app/controllers/#{path}_controller.rb", content)
+    create_file("app/controllers/#{cleaned_path}_controller.rb", content)
   end
 end

data/lib/rest_framework/generators.rb

@@ -1,5 +1,4 @@
 module RESTFramework::Generators
 end
 
-
-require_relative 'generators/controller_generator'
+require_relative "generators/controller_generator"

data/lib/rest_framework/paginators.rb

@@ -15,7 +15,6 @@ class RESTFramework::BasePaginator
   end
 end
 
-
 # A simple paginator based on page numbers.
 #
 # Example: http://example.com/api/users/?page=3&page_size=50
@@ -26,7 +25,7 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
     @page_size = self._page_size
 
     @total_pages = @count / @page_size
-    @total_pages += 1 if (@count % @page_size != 0)
+    @total_pages += 1 if @count % @page_size != 0
   end
 
   def _page_size
@@ -60,7 +59,7 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
   # Get the page and return it so the caller can serialize it.
   def get_page(page_number=nil)
     # If page number isn't provided, infer from the params or use 1 as a fallback value.
-    if !page_number
+    unless page_number
       page_number = @controller&.params&.[](self._page_query_param)
       if page_number.blank?
         page_number = 1
@@ -90,7 +89,6 @@ class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
   end
 end
 
-
 # TODO: implement this
 # class RESTFramework::CountOffsetPaginator
 # end

data/lib/rest_framework/routers.rb

@@ -1,46 +1,11 @@
-require 'action_dispatch/routing/mapper'
-
+require "action_dispatch/routing/mapper"
+require_relative "utils"
 
 module ActionDispatch::Routing
   class Mapper
-    # Internal helper to take extra_actions hash and convert to a consistent format.
-    protected def _parse_extra_actions(extra_actions)
-      return (extra_actions || {}).map do |k,v|
-        kwargs = {action: k}
-        path = k
-
-        # Convert structure to path/methods/kwargs.
-        if v.is_a?(Hash)  # allow kwargs
-          v = v.symbolize_keys
-
-          # Ensure methods is an array.
-          if v[:methods].is_a?(String) || v[:methods].is_a?(Symbol)
-            methods = [v.delete(:methods)]
-          else
-            methods = v.delete(:methods)
-          end
-
-          # Override path if it's provided.
-          if v.key?(:path)
-            path = v.delete(:path)
-          end
-
-          # Pass any further kwargs to the underlying Rails interface.
-          kwargs = kwargs.merge(v)
-        elsif v.is_a?(Symbol) || v.is_a?(String)
-          methods = [v]
-        else
-          methods = v
-        end
-
-        # Return a hash with keys: :path, :methods, :kwargs.
-        {path: path, methods: methods, kwargs: kwargs}
-      end
-    end
-
     # Internal interface to get the controller class from the name and current scope.
     protected def _get_controller_class(name, pluralize: true, fallback_reverse_pluralization: true)
-      # get class name
+      # Get class name.
       name = name.to_s.camelize  # camelize to leave plural names plural
       name = name.pluralize if pluralize
       if name == name.pluralize
@@ -51,14 +16,14 @@ module ActionDispatch::Routing
       name += "Controller"
       name_reverse += "Controller"
 
-      # get scope for the class
+      # Get scope for the class.
       if @scope[:module]
         mod = @scope[:module].to_s.classify.constantize
       else
         mod = Object
       end
 
-      # convert class name to class
+      # Convert class name to class.
       begin
         controller = mod.const_get(name)
       rescue NameError
@@ -92,13 +57,13 @@ module ActionDispatch::Routing
       if controller.is_a?(Class)
         controller_class = controller
       else
-        controller_class = _get_controller_class(controller, pluralize: !default_singular)
+        controller_class = self._get_controller_class(controller, pluralize: !default_singular)
       end
 
       # Set controller if it's not explicitly set.
       kwargs[:controller] = name unless kwargs[:controller]
 
-      # determine plural/singular resource
+      # Determine plural/singular resource.
       force_singular = kwargs.delete(:force_singular)
       force_plural = kwargs.delete(:force_plural)
       if force_singular
@@ -118,14 +83,16 @@ module ActionDispatch::Routing
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do
-            actions = self._parse_extra_actions(controller_class.extra_member_actions)
-            _route_extra_actions(actions)
+            actions = RESTFramework::Utils.parse_extra_actions(
+              controller_class.extra_member_actions,
+            )
+            self._route_extra_actions(actions)
           end
         end
 
         collection do
-          actions = self._parse_extra_actions(controller_class.extra_actions)
-          _route_extra_actions(actions)
+          actions = RESTFramework::Utils.parse_extra_actions(controller_class.extra_actions)
+          self._route_extra_actions(actions)
         end
 
         yield if block_given?
@@ -160,14 +127,14 @@ module ActionDispatch::Routing
       kwargs[:controller] = name unless kwargs[:controller]
 
       # Route actions using the resourceful router, but skip all builtin actions.
-      actions = self._parse_extra_actions(controller_class.extra_actions)
+      actions = RESTFramework::Utils.parse_extra_actions(controller_class.extra_actions)
       public_send(:resource, name, only: [], **kwargs) do
         # Route a root for this resource.
         if route_root_to
-          get '', action: route_root_to
+          get("", action: route_root_to)
         end
 
-        _route_extra_actions(actions, &block)
+        self._route_extra_actions(actions, &block)
       end
     end
 
@@ -179,13 +146,12 @@ module ActionDispatch::Routing
 
       # Remove path if name is nil (routing to the root of current namespace).
       unless name
-        kwargs[:path] = ''
+        kwargs[:path] = ""
       end
 
       return rest_route(controller, route_root_to: root_action, **kwargs) do
         yield if block_given?
       end
     end
-
   end
 end

data/lib/rest_framework/serializers.rb

@@ -1,14 +1,23 @@
+# The base serializer defines the interface for all REST Framework serializers.
 class RESTFramework::BaseSerializer
-  def initialize(object: nil, controller: nil, **kwargs)
+  attr_accessor :object
+
+  def initialize(object=nil, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
 
-  def serialize
+  # The primary interface for extracting a native Ruby types. This works both for records and
+  # collections.
+  def serialize(**kwargs)
     raise NotImplementedError
   end
-end
 
+  # Synonym for `serializable_hash` or compatibility with ActiveModelSerializers.
+  def serializable_hash(**kwargs)
+    return self.serialize(**kwargs)
+  end
+end
 
 # This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
 # top-level being either an array or a hash).
@@ -18,8 +27,8 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
   class_attribute :plural_config
   class_attribute :action_config
 
-  def initialize(many: nil, model: nil, **kwargs)
-    super(**kwargs)
+  def initialize(object=nil, many: nil, model: nil, **kwargs)
+    super(object, **kwargs)
 
     if many.nil?
       # Determine if we are dealing with many objects or just one.
@@ -31,9 +40,9 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     # Determine model either explicitly, or by inspecting @object or @controller.
     @model = model
     @model ||= @object.class if @object.is_a?(ActiveRecord::Base)
-    @model ||= @object[0].class if (
+    @model ||= @object[0].class if
       @many && @object.is_a?(Enumerable) && @object.is_a?(ActiveRecord::Base)
-    )
+
     @model ||= @controller.send(:get_model) if @controller
   end
 
@@ -66,23 +75,66 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return nil unless @controller
 
     if @many == true
-      controller_serializer = @controller.try(:native_serializer_plural_config)
+      controller_serializer = @controller.class.try(:native_serializer_plural_config)
     elsif @many == false
-      controller_serializer = @controller.try(:native_serializer_singular_config)
+      controller_serializer = @controller.class.try(:native_serializer_singular_config)
     end
 
-    return controller_serializer || @controller.try(:native_serializer_config)
+    return controller_serializer || @controller.class.try(:native_serializer_config)
   end
 
-  # Get a configuration passable to `serializable_hash` for the object.
-  def get_serializer_config
+  # Helper to filter (mutate) a single subconfig for specific keys.
+  def self.filter_subconfig(subconfig, except, additive: false)
+    return subconfig unless subconfig
+
+    if subconfig.is_a?(Array)
+      subconfig = subconfig.map(&:to_sym)
+      if additive
+        # Only add fields which are not already included.
+        subconfig += except - subconfig
+      else
+        subconfig -= except
+      end
+    elsif subconfig.is_a?(Hash)
+      subconfig.symbolize_keys!
+      subconfig.reject! { |k, _v| k.in?(except) }
+    end
+
+    return subconfig
+  end
+
+  # Helper to filter out configuration properties based on the :except query parameter.
+  def filter_except(config)
+    return config unless @controller
+
+    except_query_param = @controller.class.try(:native_serializer_except_query_param)
+    if except = @controller.request.query_parameters[except_query_param]
+      except = except.split(",").map(&:strip).map(&:to_sym)
+
+      unless except.empty?
+        # Duplicate the config to avoid mutating class state.
+        config = config.deep_dup
+
+        # Filter `only`, `except` (additive), `include`, and `methods`.
+        self.class.filter_subconfig(config[:only], except)
+        self.class.filter_subconfig(config[:except], except, additive: true)
+        self.class.filter_subconfig(config[:include], except)
+        self.class.filter_subconfig(config[:methods], except)
+      end
+    end
+
+    return config
+  end
+
+  # Get the raw serializer config.
+  def _get_raw_serializer_config
     # Return a locally defined serializer config if one is defined.
     if local_config = self.get_local_native_serializer_config
       return local_config
     end
 
     # Return a serializer config if one is defined on the controller.
-    if serializer_config = get_controller_native_serializer_config
+    if serializer_config = self.get_controller_native_serializer_config
       return serializer_config
     end
 
@@ -103,13 +155,16 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return {}
   end
 
-  # Convert the object (record or recordset) to Ruby primitives.
-  def serialize
-    raise "No object available to serialize!" unless @object
+  # Get a configuration passable to `serializable_hash` for the object, filtered if required.
+  def get_serializer_config
+    return filter_except(self._get_raw_serializer_config)
+  end
 
-    if @object.is_a?(Enumerable)
+  def serialize(**kwargs)
+    if @object.respond_to?(:to_ary)
       return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
     end
+
     return @object.serializable_hash(self.get_serializer_config)
   end
 
@@ -118,6 +173,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     @_nested_config ||= self.get_serializer_config
     return @_nested_config[key]
   end
+
   def []=(key, value)
     @_nested_config ||= self.get_serializer_config
     return @_nested_config[key] = value
@@ -128,20 +184,20 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     @_nested_config ||= self.new.get_serializer_config
     return @_nested_config[key]
   end
+
   def self.[]=(key, value)
     @_nested_config ||= self.new.get_serializer_config
     return @_nested_config[key] = value
   end
 end
 
-
 # :nocov:
 # Alias NativeModelSerializer -> NativeSerializer.
 class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
   def initialize(**kwargs)
     super
     ActiveSupport::Deprecation.warn(
-      <<~MSG.split("\n").join(' ')
+      <<~MSG.split("\n").join(" "),
         RESTFramework::NativeModelSerializer is deprecated and will be removed in future versions of
         REST Framework; you should use RESTFramework::NativeSerializer instead.
       MSG
@@ -149,3 +205,19 @@ class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
   end
 end
 # :nocov:
+
+# This is a helper factory to wrap an ActiveModelSerializer to provide a `serialize` method which
+# accepts both collections and individual records. Use `.for` to build adapters.
+class RESTFramework::ActiveModelSerializerAdapterFactory
+  def self.for(active_model_serializer)
+    return Class.new(active_model_serializer) do
+      def serialize
+        if self.object.respond_to?(:to_ary)
+          return self.object.map { |r| self.class.superclass.new(r).serializable_hash }
+        end
+
+        return self.serializable_hash
+      end
+    end
+  end
+end

data/lib/rest_framework/utils.rb

@@ -0,0 +1,64 @@
+module RESTFramework::Utils
+  # Helper to take extra_actions hash and convert to a consistent format:
+  # `{paths:, methods:, kwargs:}`.
+  def self.parse_extra_actions(extra_actions)
+    return (extra_actions || {}).map do |k, v|
+      kwargs = {action: k}
+      path = k
+
+      # Convert structure to path/methods/kwargs.
+      if v.is_a?(Hash)  # allow kwargs
+        v = v.symbolize_keys
+
+        # Ensure methods is an array.
+        if v[:methods].is_a?(String) || v[:methods].is_a?(Symbol)
+          methods = [v.delete(:methods)]
+        else
+          methods = v.delete(:methods)
+        end
+
+        # Override path if it's provided.
+        if v.key?(:path)
+          path = v.delete(:path)
+        end
+
+        # Pass any further kwargs to the underlying Rails interface.
+        kwargs = kwargs.merge(v)
+      elsif v.is_a?(Symbol) || v.is_a?(String)
+        methods = [v]
+      else
+        methods = v
+      end
+
+      # Return a hash with keys: :path, :methods, :kwargs.
+      {path: path, methods: methods, kwargs: kwargs}
+    end
+  end
+
+  # Helper to get the current route pattern, stripped of the `(:format)` segment.
+  def self.get_route_pattern(application_routes, request)
+    application_routes.router.recognize(request) do |route, _, _|
+      return route.path.spec.to_s.gsub(/\(\.:format\)$/, "")
+    end
+  end
+
+  # Helper for showing routes under a controller action, used for the browsable API.
+  def self.get_routes(application_routes, request)
+    current_pattern = self.get_route_pattern(application_routes, request)
+    current_subdomain = request.subdomain.presence
+
+    # Return routes that match our current route subdomain/pattern, grouped by controller.
+    return application_routes.routes.map { |r|
+      {
+        verb: r.verb,
+        path: r.path.spec.to_s,
+        action: r.defaults[:action].presence,
+        controller: r.defaults[:controller].presence,
+        subdomain: r.defaults[:subdomain].presence,
+        route_app: r.app&.app&.inspect&.presence,
+      }
+    }.select { |r|
+      r[:subdomain] == current_subdomain && r[:path].start_with?(current_pattern)
+    }.group_by { |r| r[:controller] }
+  end
+end

data/lib/rest_framework/version.rb

@@ -18,7 +18,7 @@ module RESTFramework
       end
 
       # No VERSION file, so version is unknown.
-      return 'unknown'
+      return "unknown"
     end
 
     def self.stamp_version
@@ -30,5 +30,5 @@ module RESTFramework
     end
   end
 
-  VERSION = Version.get_version()
+  VERSION = Version.get_version
 end

data/lib/rest_framework.rb

@@ -1,7 +1,6 @@
 module RESTFramework
 end
 
-
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
 require_relative "rest_framework/errors"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.5.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-25 00:00:00.000000000 Z
+date: 2022-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -36,6 +36,7 @@ files:
 - VERSION
 - app/views/layouts/rest_framework.html.erb
 - app/views/rest_framework/_head.html.erb
+- app/views/rest_framework/_route.html.erb
 - app/views/rest_framework/_routes.html.erb
 - lib/rest_framework.rb
 - lib/rest_framework/controller_mixins.rb
@@ -49,6 +50,7 @@ files:
 - lib/rest_framework/paginators.rb
 - lib/rest_framework/routers.rb
 - lib/rest_framework/serializers.rb
+- lib/rest_framework/utils.rb
 - lib/rest_framework/version.rb
 homepage: https://rails-rest-framework.com
 licenses:
@@ -72,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: A framework for DRY RESTful APIs in Ruby on Rails.