rest_framework 0.9.16 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59084182eeedcec7d3f1a1a913a99e55a6139bb394e4c712744c5d80778db800
-  data.tar.gz: 552ea8a39833dc6a3ec4c689f120ba549af0db49a3fafa29d63cd4cb17d85a85
+  metadata.gz: 34653421f170160fbdd29c3119c728ba5fe7591fd969f9d50d2e20d18cecf8bb
+  data.tar.gz: ed35098916c941a897087d9b455f69e86f5f53b1e81442e22aa135c81877c45c
 SHA512:
-  metadata.gz: cffd1cde2cbf956d46344018c137b723397118f3aa4ea16c2d9abf5c9d9694c8a78d8f706f96e28c637ec4f58d692553da372a832a0bd44cc58154134b733d33
-  data.tar.gz: 1eea97e45fc0f4c47edbdb04a8de05fe6e383e259ea1d3ff48196b6601aeb87341aa6750f8eb4411dd0e16934452c5a02b2d26877a9ec8382ae538312f305603
+  metadata.gz: b02af4cc8f15d804a8ece266a3678a5a0ae328cf505aa64478f4239392a2ccc1ddbcbdde333fc8d80c9ba8fbb59d2a057c8fed6150fe0758f068c7c3dca3670c
+  data.tar.gz: 33d87fa722fa5d0a23ccfd81ea6d5705cc37b49bb9b88ab62f504c76255429c77d0c75b2d83a8f86c3752c6fc7c9a60f3fa9078daebfca5461929d052f43d45f

data/README.md

@@ -75,7 +75,7 @@ class Api::RootController < ApiController
   self.extra_actions = {test: :get}
 
   def root
-    return api_response(
+    render_api(
       {
         message: "Welcome to the API.",
         how_to_authenticate: <<~END.lines.map(&:strip).join(" "),
@@ -88,7 +88,7 @@ class Api::RootController < ApiController
   end
 
   def test
-    return api_response({message: "Hello, world!"})
+    render_api({message: "Hello, world!"})
   end
 end
 ```
@@ -105,7 +105,7 @@ class Api::MoviesController < ApiController
   def first
     # Always use the bang method, since the framework will rescue `RecordNotFound` and return a
     # sensible error response.
-    return api_response(self.get_records.first!)
+    render_api(self.get_records.first!)
   end
 
   def get_recordset

data/VERSION

@@ -1 +1 @@
-0.9.16
+0.11.0

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

@@ -3,7 +3,7 @@
     <label class="form-label w-100">Route
       <select class="form-control form-control-sm" id="htmlFormRoute">
         <% @_rrf_form_routes_html.each do |route| %>
-          <% path = @route_props[:with_path_args].call(route[:route]) %>
+          <% path = route[:path_with_params] %>
           <option value="<%= route[:verb] %>:<%= path %>"><%= route[:verb] %> <%= route[:relative_path] %></option>
         <% end %>
       </select>
@@ -21,16 +21,16 @@
     <% controller.get_fields.map(&:to_s).each do |f| %>
       <%
         # Don't provide form fields for associations or primary keys.
-        metadata = controller.class.fields_metadata[f]
-        next if !metadata || metadata[:kind] == "association" || metadata[:read_only]
+        cfg = controller.class.field_configuration[f]
+        next if !cfg || cfg[:kind] == "association" || cfg[:readonly]
       %>
       <div class="mb-2">
-        <% if metadata[:kind] == "rich_text" %>
+        <% if cfg[:kind] == "rich_text" %>
           <label class="form-label w-100"><%= controller.class.label_for(f) %></label>
           <%= form.rich_text_area f %>
-        <% elsif metadata[:kind] == "attachment" %>
+        <% elsif cfg[:kind] == "attachment" %>
           <label class="form-label w-100"><%= controller.class.label_for(f) %>
-            <%= form.file_field f, multiple: metadata.dig(:attachment, :macro) == :has_many_attached %>
+            <%= form.file_field f, multiple: cfg[:attachment_type] == :has_many_attached %>
           </label>
         <% else %>
           <label class="form-label w-100"><%= controller.class.label_for(f) %>

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

@@ -3,7 +3,7 @@
     <label class="form-label w-100">Route
       <select class="form-control form-control-sm" id="rawFormRoute">
         <% @_rrf_form_routes_raw.each do |route| %>
-          <% path = @route_props[:with_path_args].call(route[:route]) %>
+          <% path = route[:path_with_params] %>
           <option
             value="<%= route[:verb] %>:<%= path %>"
             data-supports-files="<%= !route[:action].in?(["update_all", "destroy", "destroy_all"]) ? "true" : "" %>"

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

@@ -1,7 +1,7 @@
 <tr>
   <td>
     <% if route[:verb] == "GET" && route[:matches_params] %>
-      <%= link_to route[:relative_path], @route_props[:with_path_args].call(route[:route]) %>
+      <%= link_to route[:relative_path], route[:path_with_params] %>
     <% else %>
       <%= route[:relative_path] %>
     <% end %>

data/lib/rest_framework/errors/{nil_passed_to_api_response_error.rb → nil_passed_to_render_api_error.rb}

@@ -1,7 +1,7 @@
-class RESTFramework::Errors::NilPassedToAPIResponseError < RESTFramework::Errors::BaseError
+class RESTFramework::Errors::NilPassedToRenderAPIError < RESTFramework::Errors::BaseError
   def message
     return <<~MSG.split("\n").join(" ")
-      Payload of `nil` was passed to `api_response`; this is unsupported. If you want a blank
+      Payload of `nil` was passed to `render_api`; 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.,
       `find_by!`) to raise `ActiveRecord::RecordNotFound`, which the REST controller will catch and
@@ -11,4 +11,4 @@ class RESTFramework::Errors::NilPassedToAPIResponseError < RESTFramework::Errors
 end
 
 # Alias for convenience.
-RESTFramework::NilPassedToAPIResponseError = RESTFramework::Errors::NilPassedToAPIResponseError
+RESTFramework::NilPassedToRenderAPIError = RESTFramework::Errors::NilPassedToRenderAPIError

data/lib/rest_framework/errors.rb

@@ -3,5 +3,5 @@ end
 
 require_relative "errors/base_error"
 
-require_relative "errors/nil_passed_to_api_response_error"
+require_relative "errors/nil_passed_to_render_api_error"
 require_relative "errors/unknown_model_error"

data/lib/rest_framework/filters/ordering_filter.rb

@@ -2,16 +2,16 @@
 class RESTFramework::Filters::OrderingFilter < RESTFramework::Filters::BaseFilter
   # Get a list of ordering fields for the current action.
   def _get_fields
-    return @controller.ordering_fields&.map(&:to_s) || @controller.get_fields
+    return @controller.class.ordering_fields&.map(&:to_s) || @controller.get_fields
   end
 
   # Convert ordering string to an ordering configuration.
   def _get_ordering
-    return nil if @controller.ordering_query_param.blank?
+    return nil unless param = @controller.class.ordering_query_param.presence
 
     # Ensure ordering_fields are strings since the split param will be strings.
     fields = self._get_fields
-    order_string = @controller.params[@controller.ordering_query_param]
+    order_string = @controller.params[param]
 
     if order_string.present?
       ordering = {}.with_indifferent_access
@@ -40,7 +40,7 @@ class RESTFramework::Filters::OrderingFilter < RESTFramework::Filters::BaseFilte
   # Order data according to the request query parameters.
   def filter_data(data)
     ordering = self._get_ordering
-    reorder = !@controller.ordering_no_reorder
+    reorder = !@controller.class.ordering_no_reorder
 
     if ordering && !ordering.empty?
       return data.send(reorder ? :reorder : :order, ordering)
@@ -52,6 +52,3 @@ end
 
 # Alias for convenience.
 RESTFramework::OrderingFilter = RESTFramework::Filters::OrderingFilter
-
-# TODO: Compatibility; remove in 1.0.
-RESTFramework::ModelOrderingFilter = RESTFramework::Filters::OrderingFilter

data/lib/rest_framework/filters/query_filter.rb

@@ -22,7 +22,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
         field, sub_field = match[1..2]
         next false unless field.in?(fields)
 
-        sub_fields = @controller.class.field_config_for(field)[:sub_fields] || []
+        sub_fields = @controller.class.field_configuration[field][:sub_fields] || []
         if sub_field.in?(sub_fields)
           includes << field.to_sym
           next true
@@ -66,6 +66,3 @@ end
 
 # Alias for convenience.
 RESTFramework::QueryFilter = RESTFramework::Filters::QueryFilter
-
-# TODO: Compatibility; remove in 1.0.
-RESTFramework::ModelQueryFilter = RESTFramework::Filters::QueryFilter

data/lib/rest_framework/filters/ransack_filter.rb

@@ -2,13 +2,13 @@
 class RESTFramework::Filters::RansackFilter < RESTFramework::Filters::BaseFilter
   # Filter data according to the request query parameters.
   def filter_data(data)
-    q = @controller.request.query_parameters[@controller.ransack_query_param]
+    q = @controller.request.query_parameters[@controller.class.ransack_query_param]
 
     if q.present?
-      distinct = @controller.ransack_distinct
+      distinct = @controller.class.ransack_distinct
 
       # Determine if `distinct` is determined by query param.
-      if distinct_query_param = @controller.ransack_distinct_query_param
+      if distinct_query_param = @controller.class.ransack_distinct_query_param
         if distinct_query = @controller.request.query_parameters[distinct_query_param].presence
           distinct_from_query = ActiveRecord::Type::Boolean.new.cast(distinct_query)
           unless distinct_from_query.nil?
@@ -17,7 +17,7 @@ class RESTFramework::Filters::RansackFilter < RESTFramework::Filters::BaseFilter
         end
       end
 
-      return data.ransack(q, @controller.ransack_options || {}).result(distinct: distinct)
+      return data.ransack(q, @controller.class.ransack_options || {}).result(distinct: distinct)
     end
 
     return data

data/lib/rest_framework/filters/search_filter.rb

@@ -1,7 +1,7 @@
 class RESTFramework::Filters::SearchFilter < RESTFramework::Filters::BaseFilter
   # Get a list of search fields for the current action.
   def _get_fields
-    if search_fields = @controller.search_fields
+    if search_fields = @controller.class.search_fields
       return search_fields&.map(&:to_s)
     end
 
@@ -13,7 +13,7 @@ class RESTFramework::Filters::SearchFilter < RESTFramework::Filters::BaseFilter
 
   # Filter data according to the request query parameters.
   def filter_data(data)
-    search = @controller.request.query_parameters[@controller.search_query_param]
+    search = @controller.request.query_parameters[@controller.class.search_query_param]
 
     if search.present?
       if fields = self._get_fields.presence
@@ -28,7 +28,7 @@ class RESTFramework::Filters::SearchFilter < RESTFramework::Filters::BaseFilter
         # Ensure we pass user input as arguments to prevent SQL injection.
         return data.where(
           fields.map { |f|
-            "CAST(#{f} AS #{data_type}) #{@controller.search_ilike ? "ILIKE" : "LIKE"} ?"
+            "CAST(#{f} AS #{data_type}) #{@controller.class.search_ilike ? "ILIKE" : "LIKE"} ?"
           }.join(" OR "),
           *(["%#{search}%"] * fields.length),
         )
@@ -41,6 +41,3 @@ end
 
 # Alias for convenience.
 RESTFramework::SearchFilter = RESTFramework::Filters::SearchFilter
-
-# TODO: Compatibility; remove in 1.0.
-RESTFramework::ModelSearchFilter = RESTFramework::Filters::SearchFilter

data/lib/rest_framework/mixins/base_controller_mixin.rb

@@ -10,6 +10,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     # Options related to metadata and display.
     title: nil,
     description: nil,
+    version: nil,
     inflect_acronyms: ["ID", "IDs", "REST", "API", "APIs"].freeze,
 
     # Options related to serialization.
@@ -17,8 +18,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     serializer_class: nil,
     serialize_to_json: true,
     serialize_to_xml: true,
-  }
-  RRF_BASE_INSTANCE_CONFIG = {
+
     # Options related to pagination.
     paginator_class: nil,
     page_size: 20,
@@ -29,6 +29,10 @@ module RESTFramework::Mixins::BaseControllerMixin
     # Option to disable serializer adapters by default, mainly introduced because Active Model
     # Serializers will do things like serialize `[]` into `{"":[]}`.
     disable_adapters_by_default: true,
+
+    # Custom integrations (reduces serializer performance due to method calls).
+    enable_action_text: false,
+    enable_active_storage: false,
   }
 
   # Default action for API root.
@@ -54,78 +58,11 @@ module RESTFramework::Mixins::BaseControllerMixin
       )
     end
 
-    # Collect actions (including extra actions) metadata for this controller.
-    def actions_metadata
-      actions = {}
-
-      # Start with builtin actions.
-      RESTFramework::BUILTIN_ACTIONS.merge(
-        RESTFramework::RRF_BUILTIN_ACTIONS,
-      ).each do |action, methods|
-        next unless self.method_defined?(action)
-
-        actions[action] = {
-          path: "", methods: methods, type: :builtin, metadata: {label: self.label_for(action)}
-        }
-      end
-
-      # Add builtin bulk actions.
-      RESTFramework::RRF_BUILTIN_BULK_ACTIONS.each do |action, methods|
-        next unless self.method_defined?(action)
-
-        actions[action] = {
-          path: "", methods: methods, type: :builtin, metadata: {label: self.label_for(action)}
-        }
-      end
-
-      # Add extra actions.
-      if extra_actions = self.try(:extra_actions)
-        actions.merge!(RESTFramework::Utils.parse_extra_actions(extra_actions, controller: self))
-      end
-
-      return actions
-    end
-
-    # Collect member actions (including extra member actions) metadata for this controller.
-    def member_actions_metadata
-      actions = {}
-
-      # Start with builtin actions.
-      RESTFramework::BUILTIN_MEMBER_ACTIONS.each do |action, methods|
-        next unless self.method_defined?(action)
-
-        actions[action] = {
-          path: "", methods: methods, type: :builtin, metadata: {label: self.label_for(action)}
-        }
-      end
-
-      # Add extra actions.
-      if extra_actions = self.try(:extra_member_actions)
-        actions.merge!(RESTFramework::Utils.parse_extra_actions(extra_actions, controller: self))
-      end
-
-      return actions
-    end
-
-    def options_metadata
-      return {
-        title: self.get_title,
-        description: self.description,
-        renders: [
-          "text/html",
-          self.serialize_to_json ? "application/json" : nil,
-          self.serialize_to_xml ? "application/xml" : nil,
-        ].compact,
-        actions: self.actions_metadata,
-        member_actions: self.member_actions_metadata,
-      }.compact
-    end
-
     # Define any behavior to execute at the end of controller definition.
     # :nocov:
     def rrf_finalize
       if RESTFramework.config.freeze_config
-        (self::RRF_BASE_CONFIG.keys + self::RRF_BASE_INSTANCE_CONFIG.keys).each { |k|
+        self::RRF_BASE_CONFIG.keys.each { |k|
           v = self.send(k)
           v.freeze if v.is_a?(Hash) || v.is_a?(Array)
         }
@@ -142,17 +79,13 @@ module RESTFramework::Mixins::BaseControllerMixin
     # By default, the layout should be set to `rest_framework`.
     base.layout("rest_framework")
 
-    # Add class attributes (with defaults) unless they already exist.
+    # Add class attributes unless they already exist.
     RRF_BASE_CONFIG.each do |a, default|
       next if base.respond_to?(a)
 
+      # Don't leak class attributes to the instance to avoid conflicting with action methods.
       base.class_attribute(a, default: default, instance_accessor: false)
     end
-    RRF_BASE_INSTANCE_CONFIG.each do |a, default|
-      next if base.respond_to?(a)
-
-      base.class_attribute(a, default: default)
-    end
 
     # Alias `extra_actions` to `extra_collection_actions`.
     unless base.respond_to?(:extra_collection_actions)
@@ -200,26 +133,17 @@ module RESTFramework::Mixins::BaseControllerMixin
     end
   end
 
-  def serializer_class
-    # TODO: Compatibility; remove in 1.0.
-    if klass = self.try(:get_serializer_class)
-      return klass
-    end
-
+  def get_serializer_class
     return self.class.serializer_class
   end
 
   # Serialize the given data using the `serializer_class`.
   def serialize(data, **kwargs)
-    return RESTFramework::Utils.wrap_ams(self.serializer_class).new(
+    return RESTFramework::Utils.wrap_ams(self.get_serializer_class).new(
       data, controller: self, **kwargs
     ).serialize
   end
 
-  def options_metadata
-    return self.class.options_metadata
-  end
-
   def rrf_error_handler(e)
     status = case e
     when ActiveRecord::RecordNotFound
@@ -228,7 +152,7 @@ module RESTFramework::Mixins::BaseControllerMixin
       400
     end
 
-    return api_response(
+    render_api(
       {
         message: e.message,
         errors: e.try(:record).try(:errors),
@@ -238,19 +162,23 @@ module RESTFramework::Mixins::BaseControllerMixin
     )
   end
 
+  def route_groups
+    return @route_groups ||= RESTFramework::Utils.get_routes(Rails.application.routes, request)
+  end
+
   # Render a browsable API for `html` format, along with basic `json`/`xml` formats, and with
   # support or passing custom `kwargs` to the underlying `render` calls.
-  def api_response(payload, **kwargs)
+  def render_api(payload, **kwargs)
     html_kwargs = kwargs.delete(:html_kwargs) || {}
     json_kwargs = kwargs.delete(:json_kwargs) || {}
     xml_kwargs = kwargs.delete(:xml_kwargs) || {}
 
     # Raise helpful error if payload is nil. Usually this happens when a record is not found (e.g.,
-    # when passing something like `User.find_by(id: some_id)` to `api_response`). The caller should
+    # when passing something like `User.find_by(id: some_id)` to `render_api`). The caller should
     # actually be calling `find_by!` to raise ActiveRecord::RecordNotFound and allowing the REST
     # framework to catch this error and return an appropriate error response.
     if payload.nil?
-      raise RESTFramework::NilPassedToAPIResponseError
+      raise RESTFramework::NilPassedToRenderAPIError
     end
 
     # If `payload` is an `ActiveRecord::Relation` or `ActiveRecord::Base`, then serialize it.
@@ -259,7 +187,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     end
 
     # Do not use any adapters by default, if configured.
-    if self.disable_adapters_by_default && !kwargs.key?(:adapter)
+    if self.class.disable_adapters_by_default && !kwargs.key?(:adapter)
       kwargs[:adapter] = nil
     end
 
@@ -291,9 +219,7 @@ module RESTFramework::Mixins::BaseControllerMixin
           end
           @title ||= self.class.get_title
           @description ||= self.class.description
-          @route_props, @route_groups = RESTFramework::Utils.get_routes(
-            Rails.application.routes, request
-          )
+          self.route_groups
           begin
             render(**kwargs.merge(html_kwargs))
           rescue ActionView::MissingTemplate
@@ -314,10 +240,80 @@ module RESTFramework::Mixins::BaseControllerMixin
   end
 
   # TODO: Might make this the default render method in the future.
-  alias_method :render_api, :api_response
+  alias_method :api_response, :render_api
+
+  def openapi_metadata
+    response_content_types = [
+      "text/html",
+      self.class.serialize_to_json ? "application/json" : nil,
+      self.class.serialize_to_xml ? "application/xml" : nil,
+    ].compact
+    request_content_types = [
+      "application/json",
+      "application/xml",
+      "application/x-www-form-urlencoded",
+      "multipart/form-data",
+    ].compact
+    routes = self.route_groups.values[0]
+    server = request.base_url + request.original_fullpath.gsub(/\?.*/, "")
+
+    return {
+      openapi: "3.1.1",
+      info: {
+        title: self.class.get_title,
+        description: self.class.description,
+        version: self.class.version.to_s,
+      }.compact,
+      servers: [{url: server}],
+      paths: routes.group_by { |r| r[:concat_path] }.map { |concat_path, routes|
+        [
+          concat_path.gsub(/:([0-9A-Za-z_-]+)/, "{\\1}"),
+          routes.map { |route|
+            metadata = route[:route].defaults[:metadata] || {}
+            summary = metadata[:label].presence || self.class.label_for(route[:action])
+            description = metadata[:description].presence
+            remaining_metadata = metadata.except(:label, :description).presence
+
+            [
+              route[:verb].downcase,
+              {
+                summary: summary,
+                description: description,
+                responses: {
+                  200 => {
+                    content: response_content_types.map { |ct|
+                      [ct, {}]
+                    }.to_h,
+                    description: "",
+                  },
+                },
+                requestBody: route[:verb].in?(["GET", "DELETE", "OPTIONS", "TRACE"]) ? nil : {
+                  content: request_content_types.map { |ct|
+                    [ct, {}]
+                  }.to_h,
+                },
+                "x-rrf-metadata": remaining_metadata,
+              }.compact,
+            ]
+          }.to_h.merge(
+            {
+              parameters: routes.first[:route].required_parts.map { |p|
+                {
+                  name: p,
+                  in: "path",
+                  required: true,
+                  schema: {type: "integer"},
+                }
+              },
+            },
+          ),
+        ]
+      }.to_h,
+    }.compact
+  end
 
   def options
-    return api_response(self.options_metadata)
+    render_api(self.openapi_metadata)
   end
 end
 

data/lib/rest_framework/mixins/bulk_model_controller_mixin.rb

@@ -4,17 +4,17 @@ require_relative "model_controller_mixin"
 # the existing `create` action to support bulk creation.
 module RESTFramework::Mixins::BulkCreateModelMixin
   # While bulk update/destroy are obvious because they create new router endpoints, bulk create
-  # overloads the existing collection `POST` endpoint, so we add a special key to the options
+  # overloads the existing collection `POST` endpoint, so we add a special key to the OpenAPI
   # metadata to indicate bulk create is supported.
-  def options_metadata
-    return super.merge({bulk_create: true})
+  def openapi_metadata
+    return super.merge({"x-rrf-bulk-create": true})
   end
 
   def create
     if params[:_json].is_a?(Array)
       records = self.create_all!
       serialized_records = self.bulk_serialize(records)
-      return api_response(serialized_records)
+      return render_api(serialized_records)
     end
 
     return super
@@ -36,7 +36,7 @@ module RESTFramework::Mixins::BulkUpdateModelMixin
   def update_all
     records = self.update_all!
     serialized_records = self.bulk_serialize(records)
-    return api_response(serialized_records)
+    render_api(serialized_records)
   end
 
   # Perform the `update` call and return the collection of (possibly) updated records.
@@ -62,10 +62,10 @@ module RESTFramework::Mixins::BulkDestroyModelMixin
     if params[:_json].is_a?(Array)
       records = self.destroy_all!
       serialized_records = self.bulk_serialize(records)
-      return api_response(serialized_records)
+      return render_api(serialized_records)
     end
 
-    return api_response(
+    render_api(
       {message: "Bulk destroy requires an array of primary keys as input."},
       status: 400,
     )