rest_framework 1.0.0.beta2 → 1.0.0

data/lib/rest_framework/mixins/model_controller_mixin.rb

@@ -5,13 +5,13 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     return value unless BASE64_REGEX.match?(value)
 
     _, content_type, payload = value.match(BASE64_REGEX).to_a
-    return {
+    {
       io: StringIO.new(Base64.decode64(payload)),
       content_type: content_type,
       filename: "file_#{field}#{Rack::Mime::MIME_TYPES.invert[content_type]}",
     }
   }
-  ACTIVESTORAGE_KEYS = [:io, :content_type, :filename, :identify, :key]
+  ACTIVESTORAGE_KEYS = [ :io, :content_type, :filename, :identify, :key ]
 
   include RESTFramework::BaseControllerMixin
 
@@ -74,7 +74,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
   }
 
   module ClassMethods
-    IGNORE_VALIDATORS_WITH_KEYS = [:if, :unless].freeze
+    IGNORE_VALIDATORS_WITH_KEYS = [ :if, :unless ].freeze
 
     def get_model
       return @model if @model
@@ -91,7 +91,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
 
     # Override to include ActiveRecord i18n-translated column names.
     def label_for(s)
-      return self.get_model.human_attribute_name(s, default: super)
+      self.get_model.human_attribute_name(s, default: super)
     end
 
     # Get the available fields. Fallback to this controller's model columns, or an empty array. This
@@ -121,7 +121,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         input_fields = input_fields.map(&:to_s)
       end
 
-      return input_fields
+      input_fields
     end
 
     # Get a full field configuration, including defaults and inferred values.
@@ -141,7 +141,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         .select { |n| n.to_s.start_with?("rich_text_") }
       attachment_reflections = model.attachment_reflections
 
-      return @field_configuration = self.get_fields.map { |f|
+      @field_configuration = self.get_fields.map { |f|
         cfg = field_config[f]&.dup || {}
         cfg[:label] ||= self.label_for(f)
 
@@ -218,7 +218,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
               v[:kind] = "method"
             end
 
-            next [sf, v]
+            next [ sf, v ]
           }.to_h.compact.presence
 
           # Determine if we render id/ids fields. Unfortunately, `has_one` does not provide this
@@ -231,7 +231,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           if self.permit_nested_attributes_assignment && (
             nested_opts = model.nested_attributes_options[f.to_sym].presence
           )
-            cfg[:nested_attributes_options] = {field: "#{f}_attributes", **nested_opts}
+            cfg[:nested_attributes_options] = { field: "#{f}_attributes", **nested_opts }
           end
 
           begin
@@ -283,7 +283,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           cfg[:validators][kind] << options
         end
 
-        next [f, cfg]
+        next [ f, cfg ]
       }.to_h.with_indifferent_access
     end
 
@@ -295,7 +295,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         required: field_configuration.select { |_, cfg| cfg[:required] }.keys,
         type: "object",
         properties: field_configuration.map { |f, cfg|
-          v = {title: cfg[:label]}
+          v = { title: cfg[:label] }
 
           if cfg[:kind] == "association"
             v[:type] = cfg[:reflection].collection? ? "array" : "object"
@@ -324,7 +324,14 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           v[:"x-rrf-kind"] = cfg[:kind] if cfg[:kind]
 
           if cfg[:reflection]
-            v[:"x-rrf-reflection"] = cfg[:reflection]
+            v[:"x-rrf-reflection"] = {
+              class_name: cfg[:reflection].class_name,
+              foreign_key: cfg[:reflection].foreign_key,
+              association_foreign_key: cfg[:reflection].association_foreign_key,
+              association_primary_key: cfg[:reflection].association_primary_key,
+              inverse_of: cfg[:reflection].inverse_of&.name,
+              join_table: cfg[:reflection].join_table,
+            }.compact
             v[:"x-rrf-association_pk"] = cfg[:association_pk]
             v[:"x-rrf-sub_fields"] = cfg[:sub_fields]
             v[:"x-rrf-sub_fields_metadata"] = cfg[:sub_fields_metadata]
@@ -332,39 +339,71 @@ module RESTFramework::Mixins::BaseModelControllerMixin
             v[:"x-rrf-nested_attributes_options"] = cfg[:nested_attributes_options]
           end
 
-          next [f, v]
+          next [ f, v ]
         }.to_h,
       }
 
-      return @openapi_schema
+      @openapi_schema
     end
 
-    def openapi_document(request, route_group_name, routes)
-      document = super
-      schema_name = routes[0][:controller].camelize.gsub("::", ".")
+    def openapi_schema_name
+      @openapi_schema_name ||= self.name.chomp("Controller").gsub("::", ".")
+    end
 
-      # Insert schema into the document.
-      document[:components] ||= {}
-      document[:components][:schemas] ||= {}
-      document[:components][:schemas][schema_name] = self.openapi_schema
+    def openapi_paths(_routes, tag)
+      paths = super
+      schema_name = self.openapi_schema_name
 
-      # Reference schema for specific actions with a `requestBody`.
-      document[:paths].each do |_path, actions|
-        actions.each do |_method, action|
+      # Reference the model schema for request body and successful default responses.
+      paths.each do |_path, actions|
+        actions.each do |method, action|
           next unless action.is_a?(Hash)
 
-          injectables = [action.dig(:requestBody, :content), *action[:responses].values.map { |r|
-            r[:content]
-          }].compact
-          injectables.each do |i|
-            i.each do |_, v|
-              v[:schema] = {"$ref" => "#/components/schemas/#{schema_name}"}
+          extra_action = action.dig("x-rrf-metadata", :extra_action)
+
+          # Adjustments for builtin actions:
+          if !extra_action && method != "options"  # rubocop:disable Style/Next
+            # Add schema to request body content types.
+            action.dig(:requestBody, :content)&.each do |_t, v|
+              v[:schema] = { "$ref" => "#/components/schemas/#{schema_name}" }
+            end
+
+            # Add schema to successful response body content types.
+            action[:responses].each do |status, response|
+              next unless status.to_s.start_with?("2")
+
+              response[:content]&.each do |t, v|
+                next if t == "text/html"
+
+                v[:schema] = { "$ref" => "#/components/schemas/#{schema_name}" }
+              end
+            end
+
+            # Translate 200->201 for the create action.
+            if action[:summary] == "Create"
+              action[:responses][201] = action[:responses].delete(200)
+            end
+
+            # Translate 200->204 for the destroy action.
+            if action[:summary] == "Destroy"
+              action[:responses][204] = action[:responses].delete(200)
             end
           end
         end
       end
 
-      return document.merge(
+      paths
+    end
+
+    def openapi_document(request, route_group_name, _routes)
+      document = super
+
+      # Insert schema into the document.
+      document[:components] ||= {}
+      document[:components][:schemas] ||= {}
+      document[:components][:schemas][self.openapi_schema_name] = self.openapi_schema
+
+      document.merge(
         {
           "x-rrf-primary_key" => self.get_model.primary_key,
           "x-rrf-callbacks" => self._process_action_callbacks.as_json,
@@ -382,9 +421,9 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           model = self.class.get_model
 
           if model.method(action).parameters.last&.first == :keyrest
-            render_api(model.send(action, **params))
+            render(api: model.send(action, **params))
           else
-            render_api(model.send(action))
+            render(api: model.send(action))
           end
         end
       end
@@ -398,9 +437,9 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           record = self.get_record
 
           if record.method(action).parameters.last&.first == :keyrest
-            render_api(record.send(action, **params))
+            render(api: record.send(action, **params))
           else
-            render_api(record.send(action))
+            render(api: record.send(action))
           end
         end
       end
@@ -439,7 +478,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
   end
 
   def get_fields
-    return self.class.get_fields(input_fields: self.class.fields)
+    self.class.get_fields(input_fields: self.class.fields)
   end
 
   # Get a hash of strong parameters for the current action.
@@ -488,7 +527,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         # TODO: Consider adjusting this based on `nested_attributes_options`.
         if self.class.permit_nested_attributes_assignment
           hash_variations["#{f}_attributes"] = (
-            config[:sub_fields] + ["_destroy"]
+            config[:sub_fields] + [ "_destroy" ]
           )
         end
 
@@ -502,11 +541,11 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     @_get_allowed_parameters += variations
     @_get_allowed_parameters << hash_variations
 
-    return @_get_allowed_parameters
+    @_get_allowed_parameters
   end
 
   def get_serializer_class
-    return super || RESTFramework::NativeSerializer
+    super || RESTFramework::NativeSerializer
   end
 
   # Use strong parameters to filter the request body.
@@ -578,8 +617,8 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     body_params = if allowed_params == true
       ActionController::Parameters.new(data).permit!
     elsif bulk_mode
-      pk = bulk_mode == :update ? [pk] : []
-      ActionController::Parameters.new(data).permit({_json: allowed_params + pk})
+      pk = bulk_mode == :update ? [ pk ] : []
+      ActionController::Parameters.new(data).permit({ _json: allowed_params + pk })
     else
       ActionController::Parameters.new(data).permit(*allowed_params)
     end
@@ -601,7 +640,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     # Filter fields in `exclude_body_fields`.
     (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
 
-    return body_params
+    body_params
   end
   alias_method :get_create_params, :get_body_params
   alias_method :get_update_params, :get_body_params
@@ -615,14 +654,14 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       return model.all
     end
 
-    return nil
+    nil
   end
 
   # Filter the recordset and return records this request has access to.
   def get_records
     data = self.get_recordset
 
-    return @records ||= self.class.filter_backends&.reduce(data) { |d, filter|
+    @records ||= self.class.filter_backends&.reduce(data) { |d, filter|
       filter.new(controller: self).filter_data(d)
     } || data
   end
@@ -655,9 +694,9 @@ module RESTFramework::Mixins::BaseModelControllerMixin
 
     # Return the record. Route key is always `:id` by Rails' convention.
     if is_pk
-      return @record = collection.find(request.path_parameters[:id])
+      @record = collection.find(request.path_parameters[:id])
     else
-      return @record = collection.find_by!(find_by_key => request.path_parameters[:id])
+      @record = collection.find_by!(find_by_key => request.path_parameters[:id])
     end
   end
 
@@ -681,8 +720,8 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     # the serializer directly. This would fail for active model serializers, but maybe we don't
     # care?
     s = RESTFramework::Utils.wrap_ams(self.get_serializer_class)
-    return records.map do |record|
-      s.new(record, controller: self).serialize.merge!({errors: record.errors.presence}.compact)
+    records.map do |record|
+      s.new(record, controller: self).serialize.merge!({ errors: record.errors.presence }.compact)
     end
   end
 end
@@ -690,7 +729,7 @@ end
 # Mixin for listing records.
 module RESTFramework::Mixins::ListModelMixin
   def index
-    render_api(self.get_index_records)
+    render(api: self.get_index_records)
   end
 
   # Get records with both filtering and pagination applied.
@@ -711,40 +750,40 @@ module RESTFramework::Mixins::ListModelMixin
       end
     end
 
-    return records
+    records
   end
 end
 
 # Mixin for showing records.
 module RESTFramework::Mixins::ShowModelMixin
   def show
-    render_api(self.get_record)
+    render(api: self.get_record)
   end
 end
 
 # Mixin for creating records.
 module RESTFramework::Mixins::CreateModelMixin
   def create
-    render_api(self.create!, status: :created)
+    render(api: self.create!, status: :created)
   end
 
   # Perform the `create!` call and return the created record.
   def create!
-    return self.get_create_from.create!(self.get_create_params)
+    self.get_create_from.create!(self.get_create_params)
   end
 end
 
 # Mixin for updating records.
 module RESTFramework::Mixins::UpdateModelMixin
   def update
-    render_api(self.update!)
+    render(api: self.update!)
   end
 
   # Perform the `update!` call and return the updated record.
   def update!
     record = self.get_record
     record.update!(self.get_update_params)
-    return record
+    record
   end
 end
 
@@ -752,12 +791,12 @@ end
 module RESTFramework::Mixins::DestroyModelMixin
   def destroy
     self.destroy!
-    render_api("")
+    render(api: "")
   end
 
   # Perform the `destroy!` call and return the destroyed (and frozen) record.
   def destroy!
-    return self.get_record.destroy!
+    self.get_record.destroy!
   end
 end
 

data/lib/rest_framework/paginators/page_number_paginator.rb

@@ -34,11 +34,11 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
     end
 
     # Ensure we return at least 1.
-    return [page_size, 1].max
+    [ page_size, 1 ].max
   end
 
   # Get the page and return it so the caller can serialize it.
-  def get_page(page_number=nil)
+  def get_page(page_number = nil)
     # If page number isn't provided, infer from the params or use 1 as a fallback value.
     unless page_number
       page_number = @controller&.params&.[](@controller.class.page_query_param&.to_sym)
@@ -55,7 +55,7 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
 
     # Get the data page and return it so the caller can serialize the data in the proper format.
     page_index = @page_number - 1
-    return @data.limit(@page_size).offset(page_index * @page_size)
+    @data.limit(@page_size).offset(page_index * @page_size)
   end
 
   # Wrap the serialized page with appropriate metadata.
@@ -63,13 +63,13 @@ class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators
     page_query_param = @controller.class.page_query_param
     base_params = @controller.params.to_unsafe_h
     next_url = if @page_number < @total_pages
-      @controller.url_for({**base_params, page_query_param => @page_number + 1})
+      @controller.url_for({ **base_params, page_query_param => @page_number + 1 })
     end
     previous_url = if @page_number > 1
-      @controller.url_for({**base_params, page_query_param => @page_number - 1})
+      @controller.url_for({ **base_params, page_query_param => @page_number - 1 })
     end
 
-    return {
+    {
       count: @count,
       page: @page_number,
       page_size: @page_size,

data/lib/rest_framework/routers.rb

@@ -43,7 +43,7 @@ module ActionDispatch::Routing
         end
       end
 
-      return controller
+      controller
     end
 
     # Interal interface for routing extra actions.
@@ -51,9 +51,16 @@ module ActionDispatch::Routing
       parsed_actions = RESTFramework::Utils.parse_extra_actions(actions)
 
       parsed_actions.each do |action, config|
-        [config[:methods]].flatten.each do |m|
-          public_send(m, config[:path], action: action, **(config[:kwargs] || {}))
+        config[:methods].each do |m|
+          public_send(m, config[:path], action: action, **config[:kwargs])
         end
+
+        # Record that this route is an extra action and any metadata associated with it.
+        metadata = config[:metadata]
+        key = "#{@scope[:path]}/#{config[:path]}"
+        RESTFramework::EXTRA_ACTION_ROUTES.add(key)
+        RESTFramework::ROUTE_METADATA[key] = metadata if metadata
+
         yield if block_given?
       end
     end
@@ -107,7 +114,7 @@ module ActionDispatch::Routing
           RESTFramework::RRF_BUILTIN_ACTIONS.each do |action, methods|
             next unless controller_class.method_defined?(action)
 
-            [methods].flatten.each do |m|
+            [ methods ].flatten.each do |m|
               public_send(m, "", action: action) if self.respond_to?(m)
             end
           end
@@ -116,7 +123,7 @@ module ActionDispatch::Routing
           RESTFramework::RRF_BUILTIN_BULK_ACTIONS.each do |action, methods|
             next unless controller_class.method_defined?(action)
 
-            [methods].flatten.each do |m|
+            [ methods ].flatten.each do |m|
               public_send(m, "", action: action) if self.respond_to?(m)
             end
           end
@@ -147,7 +154,7 @@ module ActionDispatch::Routing
     end
 
     # Route a controller without the default resourceful paths.
-    def rest_route(name=nil, **kwargs, &block)
+    def rest_route(name = nil, **kwargs, &block)
       controller = kwargs.delete(:controller) || name
       route_root_to = kwargs.delete(:route_root_to)
       if controller.is_a?(Class)
@@ -177,7 +184,7 @@ module ActionDispatch::Routing
           RESTFramework::RRF_BUILTIN_ACTIONS.each do |action, methods|
             next unless controller_class.method_defined?(action)
 
-            [methods].flatten.each do |m|
+            [ methods ].flatten.each do |m|
               public_send(m, "", action: action) if self.respond_to?(m)
             end
           end
@@ -194,7 +201,7 @@ module ActionDispatch::Routing
     end
 
     # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
-    def rest_root(name=nil, **kwargs, &block)
+    def rest_root(name = nil, **kwargs, &block)
       # By default, use RootController#root.
       root_action = kwargs.delete(:action) || :root
       controller = kwargs.delete(:controller) || name || :root
@@ -204,7 +211,7 @@ module ActionDispatch::Routing
         kwargs[:path] = ""
       end
 
-      return rest_route(controller, route_root_to: root_action, **kwargs) do
+      rest_route(controller, route_root_to: root_action, **kwargs) do
         yield if block_given?
       end
     end

data/lib/rest_framework/serializers/active_model_serializer_adapter_factory.rb

@@ -1,18 +1,20 @@
 # 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.
+# :nocov:
 class RESTFramework::Serializers::ActiveModelSerializerAdapterFactory
   def self.for(active_model_serializer)
-    return Class.new(active_model_serializer) do
+    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
+        self.serializable_hash
       end
     end
   end
 end
+# :nocov:
 
 # Alias for convenience.
 # rubocop:disable Layout/LineLength

data/lib/rest_framework/serializers/base_serializer.rb

@@ -4,7 +4,7 @@ class RESTFramework::Serializers::BaseSerializer
   attr_accessor :object
 
   # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
-  def initialize(object=nil, *args, controller: nil, **kwargs)
+  def initialize(object = nil, *args, controller: nil, **kwargs)
     @object = object
     @controller = controller
   end
@@ -16,24 +16,26 @@ class RESTFramework::Serializers::BaseSerializer
   end
 
   # Synonym for `serialize` for compatibility with `active_model_serializers`.
+  # :nocov:
   def serializable_hash(*args)
-    return self.serialize(*args)
+    self.serialize(*args)
   end
 
   # For compatibility with `active_model_serializers`.
   def self.cache_enabled?
-    return false
+    false
   end
 
   # For compatibility with `active_model_serializers`.
   def self.fragment_cache_enabled?
-    return false
+    false
   end
 
   # For compatibility with `active_model_serializers`.
   def associations(*args, **kwargs)
-    return []
+    []
   end
+  # :nocov:
 end
 
 # Alias for convenience.