rest_framework 1.0.0.rc1 → 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,15 +339,15 @@ 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_schema_name
-      return @openapi_schema_name ||= self.name.chomp("Controller").gsub("::", ".")
+      @openapi_schema_name ||= self.name.chomp("Controller").gsub("::", ".")
     end
 
     def openapi_paths(_routes, tag)
@@ -358,7 +365,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
           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}"}
+              v[:schema] = { "$ref" => "#/components/schemas/#{schema_name}" }
             end
 
             # Add schema to successful response body content types.
@@ -368,7 +375,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
               response[:content]&.each do |t, v|
                 next if t == "text/html"
 
-                v[:schema] = {"$ref" => "#/components/schemas/#{schema_name}"}
+                v[:schema] = { "$ref" => "#/components/schemas/#{schema_name}" }
               end
             end
 
@@ -385,7 +392,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         end
       end
 
-      return paths
+      paths
     end
 
     def openapi_document(request, route_group_name, _routes)
@@ -396,7 +403,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       document[:components][:schemas] ||= {}
       document[:components][:schemas][self.openapi_schema_name] = self.openapi_schema
 
-      return document.merge(
+      document.merge(
         {
           "x-rrf-primary_key" => self.get_model.primary_key,
           "x-rrf-callbacks" => self._process_action_callbacks.as_json,
@@ -471,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.
@@ -520,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
 
@@ -534,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.
@@ -610,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
@@ -633,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
@@ -647,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
@@ -687,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
 
@@ -713,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
@@ -743,7 +750,7 @@ module RESTFramework::Mixins::ListModelMixin
       end
     end
 
-    return records
+    records
   end
 end
 
@@ -762,7 +769,7 @@ module RESTFramework::Mixins::CreateModelMixin
 
   # 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
 
@@ -776,7 +783,7 @@ module RESTFramework::Mixins::UpdateModelMixin
   def update!
     record = self.get_record
     record.update!(self.get_update_params)
-    return record
+    record
   end
 end
 
@@ -789,7 +796,7 @@ module RESTFramework::Mixins::DestroyModelMixin
 
   # 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.
@@ -114,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
@@ -123,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
@@ -154,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)
@@ -184,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
@@ -201,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
@@ -211,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.

data/lib/rest_framework/serializers/native_serializer.rb

@@ -7,7 +7,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
   class_attribute :action_config
 
   # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
-  def initialize(object=nil, *args, many: nil, model: nil, **kwargs)
+  def initialize(object = nil, *args, many: nil, model: nil, **kwargs)
     super(object, *args, **kwargs)
 
     if many.nil?
@@ -28,7 +28,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
 
   # Get controller action, if possible.
   def get_action
-    return @controller&.action_name&.to_sym
+    @controller&.action_name&.to_sym
   end
 
   # Get a locally defined native serializer configuration, if one is defined.
@@ -47,7 +47,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     return self.singular_config if @many == false && self.singular_config
 
     # Lastly, try returning the default config, or singular/plural config in that order.
-    return self.config || self.singular_config || self.plural_config
+    self.config || self.singular_config || self.plural_config
   end
 
   # Get a native serializer configuration from the controller.
@@ -60,7 +60,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       controller_serializer = @controller.class.native_serializer_singular_config
     end
 
-    return controller_serializer || @controller.class.native_serializer_config
+    controller_serializer || @controller.class.native_serializer_config
   end
 
   # Filter a single subconfig for specific keys. By default, keys from `fields` are removed from the
@@ -99,7 +99,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       subcfg = subcfg.to_sym
 
       if add
-        subcfg = subcfg.in?(fields) ? fields : [subcfg, *fields]
+        subcfg = subcfg.in?(fields) ? fields : [ subcfg, *fields ]
       elsif only
         subcfg = subcfg.in?(fields) ? subcfg : []
       else
@@ -107,7 +107,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       end
     end
 
-    return subcfg
+    subcfg
   end
 
   # Filter out configuration properties based on the :except/:only query parameters.
@@ -153,7 +153,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       end
     end
 
-    return cfg
+    cfg
   end
 
   # Get the associations limit from the controller.
@@ -174,7 +174,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       end
     end
 
-    return @_get_associations_limit = limit
+    @_get_associations_limit = limit
   end
 
   # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
@@ -210,7 +210,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
             sub_methods << sf
           end
         end
-        sub_config = {only: sub_columns, methods: sub_methods}
+        sub_config = { only: sub_columns, methods: sub_methods }
 
         # Apply certain rules regarding collection associations.
         if ref.collection?
@@ -257,7 +257,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
         # ActiveStorage Integration: Define attachment serializer method.
         if ref.macro == :has_one_attached
           serializer_methods[f] = f
-          includes_map[f] = {"#{f}_attachment": :blob}
+          includes_map[f] = { "#{f}_attachment": :blob }
           self.define_singleton_method(f) do |record|
             attached = record.send(f)
             next attached.attachment ? {
@@ -268,7 +268,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           end
         elsif ref.macro == :has_many_attached
           serializer_methods[f] = f
-          includes_map[f] = {"#{f}_attachments": :blob}
+          includes_map[f] = { "#{f}_attachments": :blob }
           self.define_singleton_method(f) do |record|
             # Iterating the collection yields attachment objects.
             next record.send(f).map { |a|
@@ -288,7 +288,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       end
     end
 
-    return {
+    {
       only: columns,
       include: includes,
       methods: methods,
@@ -317,24 +317,24 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     end
 
     # By default, pass an empty configuration, using the default Rails serializer.
-    return {}
+    {}
   end
 
   # Get a configuration passable to `serializable_hash` for the object, filtered if required.
   def get_serializer_config
-    return self.filter_from_request(self.get_raw_serializer_config)
+    self.filter_from_request(self.get_raw_serializer_config)
   end
 
   # Serialize a single record and merge results of `serializer_methods`.
   def _serialize(record, config, 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
+      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, k| [k.to_sym, self.send(m, record)] }.to_h,
+    record.serializable_hash(config).merge(
+      serializer_methods&.map { |m, k| [ k.to_sym, self.send(m, record) ] }.to_h,
     )
   end
 
@@ -352,29 +352,29 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       return @object.map { |r| self._serialize(r, config, serializer_methods) }
     end
 
-    return self._serialize(@object, config, serializer_methods)
+    self._serialize(@object, config, serializer_methods)
   end
 
   # Allow a serializer instance to be used as a hash directly in a nested serializer config.
   def [](key)
     @_nested_config ||= self.get_serializer_config
-    return @_nested_config[key]
+    @_nested_config[key]
   end
 
   def []=(key, value)
     @_nested_config ||= self.get_serializer_config
-    return @_nested_config[key] = value
+    @_nested_config[key] = value
   end
 
   # Allow a serializer class to be used as a hash directly in a nested serializer config.
   def self.[](key)
     @_nested_config ||= self.new.get_serializer_config
-    return @_nested_config[key]
+    @_nested_config[key]
   end
 
   def self.[]=(key, value)
     @_nested_config ||= self.new.get_serializer_config
-    return @_nested_config[key] = value
+    @_nested_config[key] = value
   end
 end