rest_framework 0.7.7 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 829e2b04366870f6c4a7cad1c0bfdaf62c56c7085bdb52d028e1ec87c46b12ee
-  data.tar.gz: 739f019c64bdd79e9af321b3ccb8cd4db8c0ab13c8e7e01b116b78e9fe1a529a
+  metadata.gz: f6a9bc78fae632a2c86426c523fbce432cb85904ea661219032d6e4352ab16ea
+  data.tar.gz: f202cd11931c54fada9e8dd1e3af1dd9344b2a883dd5cb00ebf45708afdd365c
 SHA512:
-  metadata.gz: 64c8bf0286fbef571f76aeeb0679041f0844fccc3ae06aea1f1e09256ebbc973e073ffc47bca6cafa1b7ff4d72e955cfe44145dfe48aa0ba7ed56cbb089eed9c
-  data.tar.gz: 85d773111e1c1923b79181593ed963c8b5566dcb2ff35a71fa542809bf90616de7c8ff005d11d9acfd5ce78fcaa99096e4b5490beda9126712c5b6cbc588aa11
+  metadata.gz: 8759e8295bb59715cd8aab800bd6a158a17422bee4adea2fc5d77c8517d44a92b6ff4a771a2c10a021162f5c582b4853a9d1ebd2bb5cc4e29468f3a6b061460b
+  data.tar.gz: 46e0b4693c1166e774f00a25f0f9378f2702e0449f87b2e808ea16d395b1df98ae5e564fff198daf53b6d3e0ba3352a12232a2a7f6962a74ea578b0f9a77c09d

data/VERSION

@@ -1 +1 @@
-0.7.7
+0.7.9

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

@@ -126,15 +126,22 @@
                     Routes
                   </a>
                 </li>
-                <% raw_form_routes = @route_groups.values[0].select { |r|
+                <% @_rrf_form_routes = @route_groups.values[0].select { |r|
                   r[:matches_params] && r[:verb].in?(["POST", "PUT", "PATCH"])
                 } %>
-                <% unless raw_form_routes.empty? %>
+                <% unless @_rrf_form_routes.empty? %>
                   <li class="nav-item">
                     <a class="nav-link" href="#tab-raw-form" data-bs-toggle="tab" role="tab">
                       Raw Form
                     </a>
                   </li>
+                  <% if RESTFramework.features[:html_forms] %>
+                    <li class="nav-item">
+                      <a class="nav-link" href="#tab-raw-form" data-bs-toggle="tab" role="tab">
+                        HTML Form
+                      </a>
+                    </li>
+                  <% end %>
                 <% end %>
               </ul>
             </div>
@@ -142,10 +149,15 @@
               <div class="tab-pane fade show active" id="tab-routes" role="tab">
                 <%= render partial: 'rest_framework/routes' %>
               </div>
-              <% unless raw_form_routes.empty? %>
+              <% unless @_rrf_form_routes.empty? %>
                 <div class="tab-pane fade" id="tab-raw-form" role="tab">
-                  <%= render partial: 'rest_framework/raw_form', locals: {raw_form_routes: raw_form_routes} %>
+                  <%= render partial: 'rest_framework/raw_form' %>
                 </div>
+                <% if RESTFramework.features[:html_forms] %>
+                  <div class="tab-pane fade" id="tab-raw-form" role="tab">
+                    <%= render partial: 'rest_framework/html_form' %>
+                  </div>
+                <% end %>
               <% end %>
             </div>
           </div>

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

@@ -0,0 +1,10 @@
+<div class="mb-2">
+  <label class="form-label w-100">Route
+    <select class="form-control" id="rawFormRoute">
+      <% @_rrf_form_routes.each do |route| %>
+        <% path = @route_props[:with_path_args].call(route[:route]) %>
+        <option value="<%= route[:verb] %>:<%= path %>"><%= route[:verb] %> <%= route[:relative_path] %></option>
+      <% end %>
+    </select>
+  </label>
+</div>

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

@@ -73,8 +73,8 @@ code {
 // What to do when document loads.
 document.addEventListener("DOMContentLoaded", (event) => {
   // Pretty-print JSON.
-  [...document.getElementsByClassName("language-json")].forEach((element, index) => {
-    element.innerHTML = neatJSON(JSON.parse(element.innerText), {
+  [...document.getElementsByClassName("language-json")].forEach((el, index) => {
+    el.innerHTML = neatJSON(JSON.parse(el.innerText), {
       wrap: 80,
       afterComma: 1,
       afterColon: 1,
@@ -84,15 +84,25 @@ document.addEventListener("DOMContentLoaded", (event) => {
   // Then highlight it.
   hljs.highlightAll();
 
+  // Replace all text nodes with anchor tag links.
+  [...document.querySelectorAll(".rrf-copy code")].forEach((el, index) => {
+    el.innerHTML = rrfLinkify(el.innerHTML)
+  });
+
   // Insert copy link and callback to copy contents of `<code>` element.
-  [...document.getElementsByClassName("rrf-copy")].forEach((element, index) => {
-    element.insertAdjacentHTML(
+  [...document.querySelectorAll("rrf-copy")].forEach((el, index) => {
+    el.insertAdjacentHTML(
       "afterbegin",
       "<a class=\"rrf-copy-link\" onclick=\"return rrfCopyToClipboard(this)\" href=\"#\">Copy to Clipboard</a>",
     )
-  })
+  });
 })
 
+// Convert plain-text links to anchor tag links.
+function rrfLinkify(text) {
+  return text.replace(/(https?:\/\/[^\s<>"]+)/g, "<a href=\"$1\" target=\"_blank\">$1</a>")
+}
+
 // Replace the document when doing form submission (mainly to support PUT/PATCH/DELETE).
 function rrfReplaceDocument(content) {
   // Replace the document with provided content.

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

@@ -0,0 +1,7 @@
+<div style="max-width: 60em; margin: auto">
+  <%= render partial: "rest_framework/form_routes" %>
+
+  <%= form_for @ do |f| %>
+    <%= f.file_field :picture %>
+  <% end %>
+</div>

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

@@ -1,14 +1,5 @@
 <div style="max-width: 60em; margin: auto">
-  <div class="mb-2">
-    <label class="form-label w-100">Route
-      <select class="form-control" id="rawFormRoute">
-        <% raw_form_routes.each do |route| %>
-          <% path = @route_props[:with_path_args].call(route[:route]) %>
-          <option value="<%= route[:verb] %>:<%= path %>"><%= route[:verb] %> <%= route[:relative_path] %></option>
-        <% end %>
-      </select>
-    </label>
-  </div>
+  <%= render partial: "rest_framework/form_routes" %>
 
   <div class="mb-2">
     <label class="form-label w-100">Media Type

data/lib/rest_framework/controller_mixins/base.rb

@@ -11,7 +11,6 @@ module RESTFramework::BaseControllerMixin
     exclude_body_fields: [
       :created_at, :created_by, :created_by_id, :updated_at, :updated_by, :updated_by_id
     ].freeze,
-    accept_generic_params_as_body_params: false,
     extra_actions: nil,
     extra_member_actions: nil,
     filter_backends: nil,
@@ -171,6 +170,10 @@ module RESTFramework::BaseControllerMixin
     # Handle some common exceptions.
     unless RESTFramework.config.disable_rescue_from
       base.rescue_from(
+        ActionController::ParameterMissing,
+        ActionController::UnpermittedParameters,
+        ActiveRecord::AssociationTypeMismatch,
+        ActiveRecord::NotNullViolation,
         ActiveRecord::RecordNotFound,
         ActiveRecord::RecordInvalid,
         ActiveRecord::RecordNotSaved,

data/lib/rest_framework/controller_mixins/models.rb

@@ -15,6 +15,11 @@ module RESTFramework::BaseModelControllerMixin
     field_config: nil,
     action_fields: nil,
 
+    # Options for what should be included/excluded from default fields.
+    exclude_associations: false,
+    include_active_storage: false,
+    include_action_text: false,
+
     # Attributes for finding records.
     find_by_fields: nil,
     find_by_query_param: "find_by",
@@ -29,6 +34,9 @@ module RESTFramework::BaseModelControllerMixin
     native_serializer_plural_config: nil,
     native_serializer_only_query_param: "only",
     native_serializer_except_query_param: "except",
+    native_serializer_associations_limit: nil,
+    native_serializer_associations_limit_query_param: "associations_limit",
+    native_serializer_include_associations_count: false,
 
     # Attributes for default model filtering, ordering, and searching.
     filterset_fields: nil,
@@ -39,15 +47,16 @@ module RESTFramework::BaseModelControllerMixin
     search_query_param: "search",
     search_ilike: false,
 
+    # Options for association assignment.
+    permit_id_assignment: true,
+    permit_nested_attributes_assignment: true,
+
     # Option for `recordset.create` vs `Model.create` behavior.
     create_from_recordset: true,
 
     # Control if filtering is done before find.
     filter_recordset_before_find: true,
 
-    # Option to exclude associations from default fields.
-    exclude_associations: false,
-
     # Control if bulk operations are done in a transaction and rolled back on error, or if all bulk
     # operations are attempted and errors simply returned in the response.
     bulk_transactional: false,
@@ -91,19 +100,26 @@ module RESTFramework::BaseModelControllerMixin
       return self.get_model.human_attribute_name(s, default: super)
     end
 
-    # Get fields without any action context. Always fallback to columns at the class level.
-    def get_fields
-      if self.fields.is_a?(Hash)
+    # Get the available fields. Returning `nil` indicates that anything should be accepted. If
+    # `fallback` is true, then we should fallback to this controller's model columns, or an empty
+    # array.
+    def get_fields(input_fields: nil, fallback: true)
+      input_fields ||= self.fields if fallback
+
+      # If fields is a hash, then parse it.
+      if input_fields.is_a?(Hash)
         return RESTFramework::Utils.parse_fields_hash(
-          self.fields, self.get_model, exclude_associations: self.exclude_associations
+          input_fields, self.get_model, exclude_associations: self.exclude_associations
         )
+      elsif !input_fields && fallback
+        # Otherwise, if fields is nil and fallback is true, then fallback to columns.
+        model = self.get_model
+        return model ? RESTFramework::Utils.fields_for(
+          model, exclude_associations: self.exclude_associations
+        ) : []
       end
 
-      return self.fields || (
-        self.get_model ? RESTFramework::Utils.fields_for(
-          self.get_model, exclude_associations: self.exclude_associations
-        ) : []
-      )
+      return input_fields
     end
 
     # Get a field's config, including defaults.
@@ -112,8 +128,12 @@ module RESTFramework::BaseModelControllerMixin
 
       # Default sub-fields if field is an association.
       if ref = self.get_model.reflections[f]
-        model = ref.klass
-        columns = model.columns_hash
+        if ref.polymorphic?
+          columns = {}
+        else
+          model = ref.klass
+          columns = model.columns_hash
+        end
         config[:sub_fields] ||= RESTFramework::Utils.sub_fields_for(ref)
 
         # Serialize very basic metadata about sub-fields.
@@ -193,18 +213,37 @@ module RESTFramework::BaseModelControllerMixin
         # Get association metadata.
         if ref = reflections[f]
           metadata[:kind] = "association"
+
+          # Determine if we render id/ids fields.
+          if self.permit_id_assignment
+            if ref.collection?
+              metadata[:id_field] = "#{f.singularize}_ids"
+            else
+              metadata[:id_field] = "#{f}_id"
+            end
+          end
+
+          # Determine if we render nested attributes options.
+          if self.permit_nested_attributes_assignment
+            if nested_opts = model.nested_attributes_options[f.to_sym].presence
+              nested_opts[:field] = "#{f}_attributes"
+              metadata[:nested_attributes_options] = nested_opts
+            end
+          end
+
           begin
             pk = ref.active_record_primary_key
           rescue ActiveRecord::UnknownPrimaryKey
           end
           metadata[:association] = {
             macro: ref.macro,
+            collection: ref.collection?,
             class_name: ref.class_name,
             foreign_key: ref.foreign_key,
             primary_key: pk,
             polymorphic: ref.polymorphic?,
             table_name: ref.table_name,
-            options: ref.options.presence,
+            options: ref.options.as_json.presence,
           }.compact
         end
 
@@ -327,26 +366,10 @@ module RESTFramework::BaseModelControllerMixin
     return (action_config[action] if action) || self.class.send(generic_config_key)
   end
 
-  # Get a list of fields for the current action. Returning `nil` indicates that anything should be
-  # accepted unless `fallback` is true, in which case we should fallback to this controller's model
-  # columns, or en empty array.
+  # Get a list of fields, taking into account the current action.
   def get_fields(fallback: false)
-    fields = _get_specific_action_config(:action_fields, :fields)
-
-    # If fields is a hash, then parse it.
-    if fields.is_a?(Hash)
-      return RESTFramework::Utils.parse_fields_hash(
-        fields, self.class.get_model, exclude_associations: self.class.exclude_associations
-      )
-    elsif !fields && fallback
-      # Otherwise, if fields is nil and fallback is true, then fallback to columns.
-      model = self.class.get_model
-      return model ? RESTFramework::Utils.fields_for(
-        model, exclude_associations: self.class.exclude_associations
-      ) : []
-    end
-
-    return fields
+    fields = self._get_specific_action_config(:action_fields, :fields)
+    return self.class.get_fields(input_fields: fields, fallback: fallback)
   end
 
   # Pass fields to get dynamic metadata based on which fields are available.
@@ -363,10 +386,36 @@ module RESTFramework::BaseModelControllerMixin
   # Get a list of parameters allowed for the current action. By default we do not fallback to
   # columns so arbitrary fields can be submitted if no fields are defined.
   def get_allowed_parameters
-    return _get_specific_action_config(
+    return @allowed_parameters if defined?(@allowed_parameters)
+
+    @allowed_parameters = self._get_specific_action_config(
       :allowed_action_parameters,
       :allowed_parameters,
-    ) || self.get_fields
+    )
+    return @allowed_parameters if @allowed_parameters
+    return @allowed_parameters = nil unless fields = self.get_fields
+
+    # For fields, automatically add `_id`/`_ids` and `_attributes` variations for associations.
+    return @allowed_parameters = fields.map { |f|
+      f = f.to_s
+      next f unless ref = self.class.get_model.reflections[f]
+
+      variations = [f]
+
+      if self.class.permit_id_assignment
+        if ref.collection?
+          variations << "#{f.singularize}_ids"
+        else
+          variations << "#{f}_id"
+        end
+      end
+
+      if self.class.permit_nested_attributes_assignment
+        variations << "#{f}_attributes"
+      end
+
+      next variations
+    }.flatten
   end
 
   # Get the configured serializer class, or `NativeSerializer` as a default.
@@ -381,34 +430,25 @@ module RESTFramework::BaseModelControllerMixin
     ]
   end
 
-  # Filter the request body for keys in current action's allowed_parameters/fields config.
+  # Use strong parameters to filter the request body using the configured allowed parameters.
   def get_body_params(data: nil)
     data ||= request.request_parameters
 
     # Filter the request body and map to strings. Return all params if we cannot resolve a list of
     # allowed parameters or fields.
-    allowed_params = self.get_allowed_parameters&.map(&:to_s)
-    body_params = if allowed_params
-      data.select { |p| allowed_params.include?(p) }
+    body_params = if allowed_parameters = self.get_allowed_parameters
+      data = ActionController::Parameters.new(data)
+      data.permit(*allowed_parameters)
     else
       data
     end
 
-    # Add query params in place of missing body params, if configured.
-    if self.class.accept_generic_params_as_body_params && allowed_params
-      (allowed_params - body_params.keys).each do |k|
-        if value = params[k].presence
-          body_params[k] = value
-        end
-      end
-    end
-
     # Filter primary key if configured.
     if self.class.filter_pk_from_request_body
       body_params.delete(self.class.get_model&.primary_key)
     end
 
-    # Filter fields in exclude_body_fields.
+    # Filter fields in `exclude_body_fields`.
     (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
 
     return body_params

data/lib/rest_framework/routers.rb

@@ -157,7 +157,7 @@ module ActionDispatch::Routing
       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, as: "")
         end
 
         collection do

data/lib/rest_framework/serializers.rb

@@ -192,6 +192,83 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     return cfg
   end
 
+  # Get the associations limit from the controller.
+  def _get_associations_limit
+    return @_get_associations_limit if defined?(@_get_associations_limit)
+
+    limit = @controller.class.native_serializer_associations_limit
+
+    # Extract the limit from the query parameters if it's set.
+    if query_param = @controller.class.native_serializer_associations_limit_query_param
+      if @controller.request.query_parameters.key?(query_param)
+        query_limit = @controller.request.query_parameters[query_param].to_i
+        if query_limit > 0
+          limit = query_limit
+        else
+          limit = nil
+        end
+      end
+    end
+
+    return @_get_associations_limit = limit
+  end
+
+  # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
+  def _get_controller_serializer_config(fields)
+    columns = []
+    includes = {}
+    methods = []
+    serializer_methods = {}
+    fields.each do |f|
+      if f.in?(@model.column_names)
+        columns << f
+      elsif ref = @model.reflections[f]
+        sub_columns = []
+        sub_methods = []
+        @controller.class.get_field_config(f)[:sub_fields].each do |sf|
+          if !ref.polymorphic? && sf.in?(ref.klass.column_names)
+            sub_columns << sf
+          else
+            sub_methods << sf
+          end
+        end
+        sub_config = {only: sub_columns, methods: sub_methods}
+
+        # Apply certain rules regarding collection associations.
+        if ref.collection?
+          # If we need to limit the number of serialized association records, then dynamically add a
+          # serializer method to do so.
+          if limit = self._get_associations_limit
+            method_name = "__rrf_limit_method_#{f}"
+            serializer_methods[method_name] = f
+            self.define_singleton_method(method_name) do |record|
+              next record.send(f).limit(limit).as_json(**sub_config)
+            end
+          else
+            includes[f] = sub_config
+          end
+
+          # If we need to include the association count, then add it here.
+          if @controller.class.native_serializer_include_associations_count
+            method_name = "__rrf_count_method_#{f}"
+            serializer_methods[method_name] = "#{f}.count"
+            self.define_singleton_method(method_name) do |record|
+              next record.send(f).count
+            end
+          end
+        else
+          includes[f] = sub_config
+        end
+      elsif @model.method_defined?(f)
+        methods << f
+      end
+    end
+
+    return {
+      only: columns, include: includes, methods: methods, serializer_methods: serializer_methods
+    }
+  end
+
   # Get the raw serializer config. Use `deep_dup` on any class mutables (array, hash, etc) to avoid
   # mutating class state.
   def _get_raw_serializer_config
@@ -206,40 +283,11 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     end
 
     # If the config wasn't determined, build a serializer config from controller fields.
-    if fields = @controller&.get_fields(fallback: true)
-      fields = fields.deep_dup
-
-      columns = []
-      includes = {}
-      methods = []
-      if @model
-        fields.each do |f|
-          if f.in?(@model.column_names)
-            columns << f
-          elsif @model.reflections.key?(f)
-            sub_columns = []
-            sub_methods = []
-            @controller.class.get_field_config(f)[:sub_fields].each do |sf|
-              sub_model = @model.reflections[f].klass
-              if sf.in?(sub_model.column_names)
-                sub_columns << sf
-              elsif sub_model.method_defined?(sf)
-                sub_methods << sf
-              end
-            end
-            includes[f] = {only: sub_columns, methods: sub_methods}
-          elsif @model.method_defined?(f)
-            methods << f
-          end
-        end
-      else
-        columns = fields
-      end
-
-      return {only: columns, include: includes, methods: methods}
+    if @model && fields = @controller&.get_fields(fallback: true)
+      return self._get_controller_serializer_config(fields.deep_dup)
     end
 
-    # By default, pass an empty configuration, allowing the serialization of all columns.
+    # By default, pass an empty configuration, using the default Rails serializer.
     return {}
   end
 
@@ -250,14 +298,14 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
 
   # Serialize a single record and merge results of `serializer_methods`.
   def _serialize(record, config, serializer_methods)
-    # Ensure serializer_methods is either falsy, or an array.
-    if serializer_methods && !serializer_methods.respond_to?(:to_ary)
-      serializer_methods = [serializer_methods]
+    # Ensure serializer_methods is either falsy, or a hash.
+    if serializer_methods && !serializer_methods.is_a?(Hash)
+      serializer_methods = [serializer_methods].flatten.map { |m| [m, m] }.to_h
     end
 
     # Merge serialized record with any serializer method results.
     return record.serializable_hash(config).merge(
-      serializer_methods&.map { |m| [m.to_sym, self.send(m, record)] }.to_h,
+      serializer_methods&.map { |m, k| [k.to_sym, self.send(m, record)] }.to_h,
     )
   end
 

data/lib/rest_framework/utils.rb

@@ -1,6 +1,6 @@
 module RESTFramework::Utils
   HTTP_METHOD_ORDERING = %w(GET POST PUT PATCH DELETE OPTIONS HEAD)
-  LABEL_FIELDS = %w(name label login title email username)
+  LABEL_FIELDS = %w(name label login title email username url)
 
   # Convert `extra_actions` hash to a consistent format: `{path:, methods:, kwargs:}`, and
   # additional metadata fields.
@@ -79,6 +79,7 @@ module RESTFramework::Utils
   def self.get_routes(application_routes, request, current_route: nil)
     current_route ||= self.get_request_route(application_routes, request)
     current_path = current_route.path.spec.to_s.gsub("(.:format)", "")
+    current_path = "" if current_path == "/"
     current_levels = current_path.count("/")
     current_comparable_path = %r{^#{Regexp.quote(self.comparable_path(current_path))}(/|$)}
 
@@ -112,7 +113,7 @@ module RESTFramework::Utils
         verb: r.verb,
         path: path,
         # Starts at the number of levels in current path, and removes the `(.:format)` at the end.
-        relative_path: path.split("/")[current_levels..]&.join("/"),
+        relative_path: path.split("/")[current_levels..]&.join("/").presence || "/",
         controller: r.defaults[:controller].presence,
         action: r.defaults[:action].presence,
         matches_path: matches_path,
@@ -125,8 +126,8 @@ module RESTFramework::Utils
       # by the path, and finally by the HTTP verb.
       [r[:_levels], r[:_path], HTTP_METHOD_ORDERING.index(r[:verb]) || 99]
     }.group_by { |r| r[:controller] }.sort_by { |c, _r|
-      # Sort the controller groups by current controller first, then depth, then alphanumerically.
-      [request.params[:controller] == c ? 0 : 1, c.count("/"), c]
+      # Sort the controller groups by current controller first, then alphanumerically.
+      [request.params[:controller] == c ? 0 : 1, c]
     }.to_h
   end
 
@@ -168,8 +169,14 @@ module RESTFramework::Utils
     return model.column_names.reject { |c|
       c.in?(foreign_keys)
     } + model.reflections.map { |association, ref|
-      if ref.macro.in?([:has_many, :has_and_belongs_to_many]) &&
-          RESTFramework.config.large_reverse_association_tables&.include?(ref.table_name)
+      # Exclude certain associations (by default, active storage and action text associations).
+      if ref.class_name.in?(RESTFramework.config.exclude_association_classes)
+        next nil
+      end
+
+      if ref.collection? && RESTFramework.config.large_reverse_association_tables&.include?(
+        ref.table_name,
+      )
         next nil
       end
 
@@ -179,9 +186,7 @@ module RESTFramework::Utils
 
   # Get the sub-fields that may be serialized and filtered/ordered for a reflection.
   def self.sub_fields_for(ref)
-    model = ref.klass
-
-    if model
+    if !ref.polymorphic? && model = ref.klass
       sub_fields = [model.primary_key].flatten.compact
 
       # Preferrably find a database column to use as label.

data/lib/rest_framework.rb

@@ -21,6 +21,12 @@ module RESTFramework
   # Global configuration should be kept minimal, as controller-level configurations allows multiple
   # APIs to be defined to behave differently.
   class Config
+    DEFAULT_EXCLUDE_ASSOCIATION_CLASSES = %w(
+      ActionText::RichText
+      ActiveStorage::Attachment
+      ActiveStorage::Blob
+    ).freeze
+
     # Do not run `rrf_finalize` on controllers automatically using a `TracePoint` hook. This is a
     # performance option and must be global because we have to determine this before any
     # controller-specific configuration is set. If this is set to `true`, then you must manually
@@ -44,8 +50,12 @@ module RESTFramework
     # Option to disable `rescue_from` on the controller mixins.
     attr_accessor :disable_rescue_from
 
+    # Options to exclude certain classes from being added by default as association fields.
+    attr_accessor :exclude_association_classes
+
     def initialize
       self.show_backtrace = Rails.env.development?
+      self.exclude_association_classes = DEFAULT_EXCLUDE_ASSOCIATION_CLASSES
     end
   end
 
@@ -56,6 +66,12 @@ module RESTFramework
   def self.configure
     yield(self.config)
   end
+
+  def self.features
+    return @features ||= {
+      html_forms: false,
+    }
+  end
 end
 
 require_relative "rest_framework/controller_mixins"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.7.9
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2023-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -35,7 +35,9 @@ files:
 - README.md
 - VERSION
 - app/views/layouts/rest_framework.html.erb
+- app/views/rest_framework/_form_routes.html.erb
 - app/views/rest_framework/_head.html.erb
+- app/views/rest_framework/_html_form.html.erb
 - app/views/rest_framework/_raw_form.html.erb
 - app/views/rest_framework/_route.html.erb
 - app/views/rest_framework/_routes.html.erb