rest_framework 1.0.0.rc1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12d9337d2e8abbdde98e25233fc2cd9d1b3596b0f65a8a5b3210eee5d5a571bd
-  data.tar.gz: e77d714a217b1ecc6ab24cdab384d7ce82d2680775e15e701fa4f1c2b2e8d88d
+  metadata.gz: 90b0053684520db23e669f2badfea90f4bc138106f79cfece16e17fc4ef449f0
+  data.tar.gz: 03a2d6ec4d1178fca154641ca6522df27592fa2b32b7024de76ceec827d23a8f
 SHA512:
-  metadata.gz: 93d22bc0db33b0b99876bcf193b8f72bf7d12072a46c34d82e735c11223cb711329c685bda323f2cb4e7383c490f298f2225efa674ced397a275bd59597177dc
-  data.tar.gz: 7d0f5375e43bb4c696f566c851875f00587175d5429a20b9e502350b46dc7d09a4398fedd3ddf91d9b02e3b0e8e262beb8198d5fbe8a267f1c02b5ec73b82a59
+  metadata.gz: bb23fb3f071a17bbc1aaf2f8c5b8571e47a46a8faeeeb43f851dc64d60d422b7a12ba924200e5ec4124b5b75fe06f868a8ee623c97345753f7d1dc3d5244c16d
+  data.tar.gz: 2828fe0ca8cf5415c781f09da370dc1e92e5408b21e0d77650151aa1d9234e0a31e1e4fb8db2737166acdeba4166b79f42659086fdbd0dcf6bd80150cfb73f11

data/README.md

@@ -152,5 +152,9 @@ After you clone the repository, cd'ing into the directory should create a new ge
 using RVM. Then run `bin/setup` to install the appropriate gems and set things up.
 
 The top-level `bin/rails` proxies all Rails commands to the test project, so you can operate it via
-the usual commands (e.g., `rails test`, `rails server` and `rails console`). For development, use
-`foreman start` to run the web server and the job queue.
+the usual commands (e.g., `rails test`, `rails console`). For development, use `bin/dev` to run the
+web server and the job queue, which serves the test app and coverage/brakeman reports:
+
+- Test App: [http://127.0.0.1:3000](http://127.0.0.1:3000)
+- API: [http://127.0.0.1:3000/api](http://127.0.0.1:3000/api)
+- Reports: [http://127.0.0.1:3000/reports](http://127.0.0.1:3000/reports)

data/VERSION

@@ -1 +1 @@
-1.0.0.rc1
+1.0.0

data/lib/rest_framework/errors/nil_passed_to_render_api_error.rb

@@ -1,6 +1,6 @@
 class RESTFramework::Errors::NilPassedToRenderAPIError < RESTFramework::Errors::BaseError
   def message
-    return <<~MSG.split("\n").join(" ")
+    <<~MSG.split("\n").join(" ")
       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.,

data/lib/rest_framework/errors/unknown_model_error.rb

@@ -5,7 +5,7 @@ class RESTFramework::Errors::UnknownModelError < RESTFramework::Errors::BaseErro
   end
 
   def message
-    return <<~MSG.split("\n").join(" ")
+    <<~MSG.split("\n").join(" ")
       The model class for `#{@controller_class}` could not be determined. Any controller that
       includes `RESTFramework::BaseModelControllerMixin` (directly or indirectly) must either set
       the `model` attribute on the controller, or the model must be deducible from the controller

data/lib/rest_framework/filters/ordering_filter.rb

@@ -2,7 +2,7 @@
 class RESTFramework::Filters::OrderingFilter < RESTFramework::Filters::BaseFilter
   # Get a list of ordering fields for the current action.
   def _get_fields
-    return @controller.class.ordering_fields&.map(&:to_s) || @controller.get_fields
+    @controller.class.ordering_fields&.map(&:to_s) || @controller.get_fields
   end
 
   # Convert ordering string to an ordering configuration.
@@ -34,7 +34,7 @@ class RESTFramework::Filters::OrderingFilter < RESTFramework::Filters::BaseFilte
       return ordering
     end
 
-    return nil
+    nil
   end
 
   # Order data according to the request query parameters.
@@ -46,7 +46,7 @@ class RESTFramework::Filters::OrderingFilter < RESTFramework::Filters::BaseFilte
       return data.send(reorder ? :reorder : :order, ordering)
     end
 
-    return data
+    data
   end
 end
 

data/lib/rest_framework/filters/query_filter.rb

@@ -13,18 +13,18 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
     true: true,
     false: false,
     null: nil,
-    lt: ->(f, v) { {f => ...v} },
+    lt: ->(f, v) { { f => ...v } },
     # `gt` must negate `lte` because Rails doesn't support `>` with endless ranges.
-    gt: ->(f, v) { Not.new({f => ..v}) },
-    lte: ->(f, v) { {f => ..v} },
-    gte: ->(f, v) { {f => v..} },
-    not: ->(f, v) { Not.new({f => v}) },
-    cont: ->(f, v) { ["#{f} LIKE ?", "%#{ActiveRecord::Base.sanitize_sql_like(v)}%"] },
+    gt: ->(f, v) { Not.new({ f => ..v }) },
+    lte: ->(f, v) { { f => ..v } },
+    gte: ->(f, v) { { f => v.. } },
+    not: ->(f, v) { Not.new({ f => v }) },
+    cont: ->(f, v) { [ "#{f} LIKE ?", "%#{ActiveRecord::Base.sanitize_sql_like(v)}%" ] },
     in: ->(f, v) {
       if v.is_a?(Array)
-        {f => v.map { |v| v == "null" ? nil : v }}
+        { f => v.map { |v| v == "null" ? nil : v } }
       elsif v.is_a?(String)
-        {f => v.split(",").map { |v| v == "null" ? nil : v }}
+        { f => v.split(",").map { |v| v == "null" ? nil : v } }
       end
     },
   }.freeze
@@ -33,7 +33,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
   # Get a list of filter fields for the current action.
   def _get_fields
     # Always return a list of strings; `@controller.get_fields` already does this.
-    return @controller.class.filter_fields&.map(&:to_s) || @controller.get_fields
+    @controller.class.filter_fields&.map(&:to_s) || @controller.get_fields
   end
 
   # Helper to find a variation of a field using a predicate. For example, there could be a field
@@ -62,7 +62,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
     base_query = @controller.request.query_parameters.map { |field, v|
       # First, if field is a simple filterable field, return early.
       if field.in?(fields)
-        next [field, v]
+        next [ field, v ]
       end
 
       # First, try to parse a simple predicate and check if it is filterable.
@@ -81,7 +81,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
           sub_fields = @controller.class.field_configuration[root_field][:sub_fields] || []
           if sub_field.in?(sub_fields)
             includes << root_field.to_sym
-            next [field, v]
+            next [ field, v ]
           elsif pred_sub_field && pred_sub_field.in?(sub_fields)
             includes << root_field.to_sym
             field = pred_field
@@ -99,13 +99,12 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
       if cfg.is_a?(Proc)
         pred_queries << cfg.call(field, v)
       else
-        pred_queries << {field => cfg}
+        pred_queries << { field => cfg }
       end
 
       next nil
     }.compact.to_h.symbolize_keys
 
-    puts "GNS: #{base_query.inspect} #{pred_queries.inspect} #{includes.inspect}"
     return base_query, pred_queries, includes
   end
 
@@ -129,7 +128,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
       end
     end
 
-    return data
+    data
   end
 end
 

data/lib/rest_framework/filters/ransack_filter.rb

@@ -20,7 +20,7 @@ class RESTFramework::Filters::RansackFilter < RESTFramework::Filters::BaseFilter
       return data.ransack(q, @controller.class.ransack_options || {}).result(distinct: distinct)
     end
 
-    return data
+    data
   end
 end
 

data/lib/rest_framework/filters/search_filter.rb

@@ -6,7 +6,7 @@ class RESTFramework::Filters::SearchFilter < RESTFramework::Filters::BaseFilter
     end
 
     columns = @controller.class.get_model.column_names
-    return @controller.get_fields.select { |f|
+    @controller.get_fields.select { |f|
       f.in?(RESTFramework.config.search_columns) && f.in?(columns)
     }
   end
@@ -30,12 +30,12 @@ class RESTFramework::Filters::SearchFilter < RESTFramework::Filters::BaseFilter
           fields.map { |f|
             "CAST(#{f} AS #{data_type}) #{@controller.class.search_ilike ? "ILIKE" : "LIKE"} ?"
           }.join(" OR "),
-          *(["%#{search}%"] * fields.length),
+          *([ "%#{search}%" ] * fields.length),
         )
       end
     end
 
-    return data
+    data
   end
 end
 

data/lib/rest_framework/generators/controller_generator.rb

@@ -5,7 +5,7 @@ require "rails/generators"
 # :nocov:
 class RESTFrameworkCustomGeneratorControllerNamespace < String
   def camelize
-    return "RESTFramework"
+    "RESTFramework"
   end
 end
 # :nocov:
@@ -41,7 +41,7 @@ class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
   # Some projects may not have the inflection "REST" as an acronym, which changes this generator to
   # be namespaced in `r_e_s_t_framework`, which is weird.
   def self.namespace
-    return RESTFrameworkCustomGeneratorControllerNamespace.new("rest_framework:controller")
+    RESTFrameworkCustomGeneratorControllerNamespace.new("rest_framework:controller")
   end
 
   def create_rest_controller_file

data/lib/rest_framework/mixins/base_controller_mixin.rb

@@ -11,7 +11,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     title: nil,
     description: nil,
     version: nil,
-    inflect_acronyms: ["ID", "IDs", "REST", "API", "APIs"].freeze,
+    inflect_acronyms: [ "ID", "IDs", "REST", "API", "APIs" ].freeze,
     openapi_include_children: false,
 
     # Options related to serialization.
@@ -38,14 +38,14 @@ module RESTFramework::Mixins::BaseControllerMixin
 
   # Default action for API root.
   def root
-    render(api: {message: "This is the API root."})
+    render(api: { message: "This is the API root." })
   end
 
   module ClassMethods
     # By default, this is the name of the controller class, titleized and with any custom inflection
     # acronyms applied.
     def get_title
-      return self.title || RESTFramework::Utils.inflect(
+      self.title || RESTFramework::Utils.inflect(
         self.name.demodulize.chomp("Controller").titleize(keep_id_suffix: true),
         self.inflect_acronyms,
       )
@@ -53,10 +53,7 @@ module RESTFramework::Mixins::BaseControllerMixin
 
     # Get a label from a field/column name, titleized and inflected.
     def label_for(s)
-      return RESTFramework::Utils.inflect(
-        s.to_s.titleize(keep_id_suffix: true),
-        self.inflect_acronyms,
-      )
+      RESTFramework::Utils.inflect(s.to_s.titleize(keep_id_suffix: true), self.inflect_acronyms)
     end
 
     # Define any behavior to execute at the end of controller definition.
@@ -72,7 +69,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     # :nocov:
 
     def openapi_response_content_types
-      return @openapi_response_content_types ||= [
+      @openapi_response_content_types ||= [
         "text/html",
         self.serialize_to_json ? "application/json" : nil,
         self.serialize_to_xml ? "application/xml" : nil,
@@ -80,7 +77,7 @@ module RESTFramework::Mixins::BaseControllerMixin
     end
 
     def openapi_request_content_types
-      return @openapi_request_content_types ||= [
+      @openapi_request_content_types ||= [
         "application/json",
         "application/x-www-form-urlencoded",
         "multipart/form-data",
@@ -91,7 +88,7 @@ module RESTFramework::Mixins::BaseControllerMixin
       resp_cts = self.openapi_response_content_types
       req_cts = self.openapi_request_content_types
 
-      return routes.group_by { |r| r[:concat_path] }.map { |concat_path, routes|
+      routes.group_by { |r| r[:concat_path] }.map { |concat_path, routes|
         [
           concat_path.gsub(/:([0-9A-Za-z_-]+)/, "{\\1}"),
           routes.map { |route|
@@ -99,28 +96,24 @@ module RESTFramework::Mixins::BaseControllerMixin
             summary = metadata.delete(:label).presence || self.label_for(route[:action])
             description = metadata.delete(:description).presence
             extra_action = RESTFramework::EXTRA_ACTION_ROUTES.include?(route[:path])
-            error_response = {"$ref" => "#/components/responses/BadRequest"}
-            not_found_response = {"$ref" => "#/components/responses/NotFound"}
-            spec = {tags: [tag], summary: summary, description: description}.compact
+            error_response = { "$ref" => "#/components/responses/BadRequest" }
+            not_found_response = { "$ref" => "#/components/responses/NotFound" }
+            spec = { tags: [ tag ], summary: summary, description: description }.compact
 
             # All routes should have a successful response.
             spec[:responses] = {
-              200 => {content: resp_cts.map { |ct| [ct, {}] }.to_h, description: "Success"},
+              200 => { content: resp_cts.map { |ct| [ ct, {} ] }.to_h, description: "Success" },
             }
 
             # Builtin POST, PUT, PATCH, and DELETE should have a 400 and 404 response.
-            if route[:verb].in?(["POST", "PUT", "PATCH", "DELETE"]) && !extra_action
+            if route[:verb].in?([ "POST", "PUT", "PATCH", "DELETE" ]) && !extra_action
               spec[:responses][400] = error_response
               spec[:responses][404] = not_found_response
             end
 
             # All POST, PUT, PATCH should have a request body.
-            if route[:verb].in?(["POST", "PUT", "PATCH"])
-              spec[:requestBody] ||= {
-                content: req_cts.map { |ct|
-                  [ct, {}]
-                }.to_h,
-              }
+            if route[:verb].in?([ "POST", "PUT", "PATCH" ])
+              spec[:requestBody] ||= { content: req_cts.map { |ct| [ ct, {} ] }.to_h }
             end
 
             # Add remaining metadata as an extension.
@@ -134,7 +127,7 @@ module RESTFramework::Mixins::BaseControllerMixin
                   name: p,
                   in: "path",
                   required: true,
-                  schema: {type: "integer"},
+                  schema: { type: "integer" },
                 }
               },
             },
@@ -146,23 +139,25 @@ module RESTFramework::Mixins::BaseControllerMixin
     def openapi_document(request, route_group_name, routes)
       server = request.base_url + request.original_fullpath.gsub(/\?.*/, "")
 
-      return {
+      {
         openapi: "3.1.1",
         info: {
           title: self.get_title,
           description: self.description,
           version: self.version.to_s,
         }.compact,
-        servers: [{url: server}],
+        servers: [ { url: server } ],
         paths: self.openapi_paths(routes, route_group_name),
-        tags: [{name: route_group_name, description: self.description}.compact],
+        tags: [ { name: route_group_name, description: self.description }.compact ],
         components: {
           schemas: {
             "Error" => {
               type: "object",
-              required: ["message"],
+              required: [ "message" ],
               properties: {
-                message: {type: "string"}, errors: {type: "object"}, exception: {type: "string"}
+                message: { type: "string" },
+                errors: { type: "object" },
+                exception: { type: "string" },
               },
             },
           },
@@ -170,13 +165,19 @@ module RESTFramework::Mixins::BaseControllerMixin
             "BadRequest": {
               description: "Bad Request",
               content: self.openapi_response_content_types.map { |ct|
-                [ct, ct == "text/html" ? {} : {schema: {"$ref" => "#/components/schemas/Error"}}]
+                [
+                  ct,
+                  ct == "text/html" ? {} : { schema: { "$ref" => "#/components/schemas/Error" } },
+                ]
               }.to_h,
             },
             "NotFound": {
               description: "Not Found",
               content: self.openapi_response_content_types.map { |ct|
-                [ct, ct == "text/html" ? {} : {schema: {"$ref" => "#/components/schemas/Error"}}]
+                [
+                  ct,
+                  ct == "text/html" ? {} : { schema: { "$ref" => "#/components/schemas/Error" } },
+                ]
               }.to_h,
             },
           },
@@ -249,12 +250,12 @@ module RESTFramework::Mixins::BaseControllerMixin
   end
 
   def get_serializer_class
-    return self.class.serializer_class
+    self.class.serializer_class
   end
 
   # Serialize the given data using the `serializer_class`.
   def serialize(data, **kwargs)
-    return RESTFramework::Utils.wrap_ams(self.get_serializer_class).new(
+    RESTFramework::Utils.wrap_ams(self.get_serializer_class).new(
       data, controller: self, **kwargs
     ).serialize
   end
@@ -278,7 +279,7 @@ module RESTFramework::Mixins::BaseControllerMixin
   end
 
   def route_groups
-    return @route_groups ||= RESTFramework::Utils.get_routes(Rails.application.routes, request)
+    @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
@@ -379,7 +380,7 @@ module RESTFramework::Mixins::BaseControllerMixin
       end
     end
 
-    return document
+    document
   end
 
   def options

data/lib/rest_framework/mixins/bulk_model_controller_mixin.rb

@@ -7,7 +7,7 @@ module RESTFramework::Mixins::BulkCreateModelMixin
   # overloads the existing collection `POST` endpoint, so we add a special key to the OpenAPI
   # metadata to indicate bulk create is supported.
   def openapi_document
-    return super.merge({"x-rrf-bulk-create": true})
+    super.merge({ "x-rrf-bulk-create": true })
   end
 
   def create
@@ -17,7 +17,7 @@ module RESTFramework::Mixins::BulkCreateModelMixin
       return render(api: serialized_records)
     end
 
-    return super
+    super
   end
 
   # Perform the `create` call, and return the collection of (possibly) created records.
@@ -25,9 +25,7 @@ module RESTFramework::Mixins::BulkCreateModelMixin
     create_data = self.get_create_params(bulk_mode: true)[:_json]
 
     # Perform bulk create in a transaction.
-    return ActiveRecord::Base.transaction do
-      next self.get_create_from.create(create_data)
-    end
+    ActiveRecord::Base.transaction { self.get_create_from.create(create_data) }
   end
 end
 
@@ -42,17 +40,15 @@ module RESTFramework::Mixins::BulkUpdateModelMixin
   # Perform the `update` call and return the collection of (possibly) updated records.
   def update_all!
     pk = self.class.get_model.primary_key
-    update_data = if params[:_json].is_a?(Array)
+    data = if params[:_json].is_a?(Array)
       self.get_create_params(bulk_mode: :update)[:_json].index_by { |r| r[pk] }
     else
       create_params = self.get_create_params
-      {create_params[pk] => create_params}
+      { create_params[pk] => create_params }
     end
 
     # Perform bulk update in a transaction.
-    return ActiveRecord::Base.transaction do
-      next self.get_recordset.update(update_data.keys, update_data.values)
-    end
+    ActiveRecord::Base.transaction { self.get_recordset.update(data.keys, data.values) }
   end
 end
 
@@ -66,8 +62,7 @@ module RESTFramework::Mixins::BulkDestroyModelMixin
     end
 
     render(
-      api: {message: "Bulk destroy requires an array of primary keys as input."},
-      status: 400,
+      api: { message: "Bulk destroy requires an array of primary keys as input." }, status: 400,
     )
   end
 
@@ -77,9 +72,7 @@ module RESTFramework::Mixins::BulkDestroyModelMixin
     destroy_data = self.request.request_parameters[:_json]
 
     # Perform bulk destroy in a transaction.
-    return ActiveRecord::Base.transaction do
-      next self.get_recordset.where(pk => destroy_data).destroy_all
-    end
+    ActiveRecord::Base.transaction { self.get_recordset.where(pk => destroy_data).destroy_all }
   end
 end