rest_framework 0.7.6 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edeb7963dbca0185ff384e628a185c83341e3154d6414c9d8f70a05115abd23a
-  data.tar.gz: 8d6bc94fea07e57c20625c8aa192ced88789e078bf3a4b29b71e6c80099f2436
+  metadata.gz: e5c7efedb6af2b7a589a2b3f7cedd600f9851bb4ba6be334465285f052e961ed
+  data.tar.gz: e14be403f25acf8e17ba54e324ec7b13e838a28b171e4866fcbb287b4f15a4dd
 SHA512:
-  metadata.gz: 68ecf8a8a045c3e217c597f86b46573dc80bb931e20be45af01b939079f8cf2dd27d68e8bebd8d458726b04b8b55fb2dd65a60bcf4c847c30feb1257f7cfb9ea
-  data.tar.gz: 388478f7c8f2c51a96740f25043aa7d188b5e59731478f4bca2ce6171fadc5ba1e201b12ee051859386ce151c1114b9b6f207dbe840e732dec652d9639323825
+  metadata.gz: 730bb926137c31d86215cb433c97ea2d5252c24d8b38f8ce78596296a30cfc3786a5b69664b927323dbf9598385ed9b5a79cb931821ee9dad9aa9e7c7d08e111
+  data.tar.gz: 12af341b9c75a9c63b9a48a5ca71aab3dcb521f03862a74acd595d732df1e55ee9d8f16eb34485ad8b640439c4ab28dde08db20f8e598c583c66df3a3a58d121

data/VERSION

@@ -1 +1 @@
-0.7.6
+0.7.8

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,

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.
@@ -389,26 +412,27 @@ module RESTFramework::BaseModelControllerMixin
     # 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) }
+      data.select { |p|
+        p.in?(allowed_params) || (
+          self.class.permit_id_assignment && (
+            p.chomp("_id").in?(allowed_params) || p.chomp("_ids").pluralize.in?(allowed_params)
+          )
+        ) || (
+          self.class.permit_nested_attributes_assignment &&
+            p.chomp("_attributes").in?(allowed_params)
+
+        )
+      }
     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
@@ -430,11 +454,23 @@ module RESTFramework::BaseModelControllerMixin
     return @recordset = nil
   end
 
+  # Get the recordset but with any associations included to avoid N+1 queries.
+  def get_recordset_with_includes
+    reflections = self.class.get_model.reflections.keys
+    associations = self.get_fields(fallback: true).select { |f| f.in?(reflections) }
+
+    if associations.any?
+      return self.get_recordset.includes(associations)
+    end
+
+    return self.get_recordset
+  end
+
   # Get the records this controller has access to *after* any filtering is applied.
   def get_records
     return @records if instance_variable_defined?(:@records)
 
-    return @records = self.get_filtered_data(self.get_recordset)
+    return @records = self.get_filtered_data(self.get_recordset_with_includes)
   end
 
   # Get a single record by primary key or another column, if allowed. The return value is cached and

data/lib/rest_framework/filters.rb

@@ -23,25 +23,18 @@ class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   def _get_filter_params
     # Map filterset fields to strings because query parameter keys are strings.
     fields = self._get_fields
-    @associations = []
 
     return @controller.request.query_parameters.select { |p, _|
       # Remove any trailing `__in` from the field name.
       field = p.chomp("__in")
 
-      # Remove any associations whose sub-fields are not filterable. Also populate `@associations`
-      # so the caller can include them.
+      # Remove any associations whose sub-fields are not filterable.
       if match = /(.*)\.(.*)/.match(field)
         field, sub_field = match[1..2]
         next false unless field.in?(fields)
 
         sub_fields = @controller.class.get_field_config(field)[:sub_fields]
-        if sub_field.in?(sub_fields)
-          @associations << field.to_sym
-          next true
-        end
-
-        next false
+        next sub_field.in?(sub_fields)
       end
 
       next field.in?(fields)
@@ -64,9 +57,6 @@ class RESTFramework::ModelFilter < RESTFramework::BaseFilter
   # Filter data according to the request query parameters.
   def get_filtered_data(data)
     if filter_params = self._get_filter_params.presence
-      # Include any associations.
-      data = data.includes(*@associations) unless @associations.empty?
-
       return data.where(**filter_params)
     end
 
@@ -88,8 +78,6 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
   def _get_ordering
     return nil if @controller.class.ordering_query_param.blank?
 
-    @associations = []
-
     # Ensure ordering_fields are strings since the split param will be strings.
     fields = self._get_fields
     order_string = @controller.params[@controller.class.ordering_query_param]
@@ -106,16 +94,6 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
         end
         next unless !fields || column.in?(fields)
 
-        # Populate any `@associations` so the caller can include them.
-        if match = /(.*)\.(.*)/.match(column)
-          association, sub_field = match[1..2]
-          @associations << association.to_sym
-
-          # Also, due to Rails weirdness, we need to convert the association name to the table name.
-          table_name = @controller.class.get_model.reflections[association].table_name
-          column = "#{table_name}.#{sub_field}"
-        end
-
         ordering[column] = direction
       end
       return ordering
@@ -130,9 +108,6 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
     reorder = !@controller.class.ordering_no_reorder
 
     if ordering && !ordering.empty?
-      # Include any associations.
-      data = data.includes(*@associations) unless @associations.empty?
-
       return data.send(reorder ? :reorder : :order, ordering)
     end
 

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.
@@ -168,8 +168,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 +185,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.6
+  version: 0.7.8
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2023-01-19 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