rest_framework 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b0053684520db23e669f2badfea90f4bc138106f79cfece16e17fc4ef449f0
-  data.tar.gz: 03a2d6ec4d1178fca154641ca6522df27592fa2b32b7024de76ceec827d23a8f
+  metadata.gz: '087da1898a00546ec0964c7f16a31ccdfdfefe6574e614764a9a3fe50dbbd89b'
+  data.tar.gz: a9720b7867fb57f681d786080d570161ff4ebb653015d429b331397a9962d95d
 SHA512:
-  metadata.gz: bb23fb3f071a17bbc1aaf2f8c5b8571e47a46a8faeeeb43f851dc64d60d422b7a12ba924200e5ec4124b5b75fe06f868a8ee623c97345753f7d1dc3d5244c16d
-  data.tar.gz: 2828fe0ca8cf5415c781f09da370dc1e92e5408b21e0d77650151aa1d9234e0a31e1e4fb8db2737166acdeba4166b79f42659086fdbd0dcf6bd80150cfb73f11
+  metadata.gz: cd6d3507ce2a40c4dffa147b5bd381ff5ae4b9dedc0f42d879ef96c66c9f67b07abb7de1005fe46fdaa8412aedd1d0c2c5332c17a11c407a577997b70dc3455f
+  data.tar.gz: d2d76d723db9f61c731aeb58d9cfd0c5c02c73bc7c75406ae835c4a24fc75f0fdfc9df24083313b2dc792b1dc7fe86eb4d8bdc32f6c15dfd60a5603ee7114cea

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/app/views/rest_framework/_head.html.erb

@@ -184,7 +184,7 @@
           el.setAttribute("data-bs-theme", "dark")
         })
       } else {
-        console.log(`RRF: Unknown mode: ${mode}`)
+        console.log(`RRF: Unknown mode: ${realMode}`)
       }
     }
 
@@ -372,3 +372,5 @@
       .then((body) => { rrfReplaceDocument(body) })
   }
 </script>
+
+<%= render partial: "rest_framework/head/extra" %>

data/app/views/rest_framework/_heading.html.erb

@@ -5,6 +5,7 @@
     <% if @description.present? %>
       <p style="display: inline-block; margin-bottom: 0; margin-top: 1em"><%= @description %></p>
     <% end %>
+    <%= render partial: "rest_framework/heading/extra" %>
   </div>
 </div>
 <hr/>

data/app/views/rest_framework/heading/_actions.html.erb

@@ -1,4 +1,5 @@
 <div style="float: right">
+  <%= render partial: "rest_framework/heading/actions/extra" %>
   <% if @route_groups.values[0].any? { |r| r[:matches_path] && r[:verb] == "DELETE" && r[:action] == "destroy" } %>
     <button type="button" class="btn btn-danger" onclick="rrfDelete(this)">DELETE</button>
   <% end %>
@@ -6,4 +7,4 @@
     <button type="button" class="btn btn-primary" onclick="rrfOptions(this)">OPTIONS</button>
   <% end %>
   <button type="button" class="btn btn-primary" onclick="rrfGet(this)">GET</button>
-</div>
+</div>

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

@@ -20,9 +20,9 @@
   }.compact) do |form| %>
     <% controller.get_fields.map(&:to_s).each do |f| %>
       <%
-        # Don't provide form fields for associations or primary keys.
+        # Don't provide form fields for associations or read-only fields.
         cfg = controller.class.field_configuration[f]
-        next if !cfg || cfg[:kind] == "association" || cfg[:readonly]
+        next if !cfg || cfg[:kind] == "association" || cfg[:read_only]
       %>
       <div class="mb-2">
         <% if cfg[:kind] == "rich_text" %>

data/lib/rest_framework/filters/query_filter.rb

@@ -15,6 +15,7 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
     null: nil,
     lt: ->(f, v) { { f => ...v } },
     # `gt` must negate `lte` because Rails doesn't support `>` with endless ranges.
+    # Ref: https://github.com/rails/rails/pull/47345
     gt: ->(f, v) { Not.new({ f => ..v }) },
     lte: ->(f, v) { { f => ..v } },
     gte: ->(f, v) { { f => v.. } },
@@ -22,9 +23,9 @@ class RESTFramework::Filters::QueryFilter < RESTFramework::Filters::BaseFilter
     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 { |el| el == "null" ? nil : el } }
       elsif v.is_a?(String)
-        { f => v.split(",").map { |v| v == "null" ? nil : v } }
+        { f => v.split(",").map { |el| el == "null" ? nil : el } }
       end
     },
   }.freeze

data/lib/rest_framework/mixins/bulk_model_controller_mixin.rb

@@ -25,7 +25,7 @@ module RESTFramework::Mixins::BulkCreateModelMixin
     create_data = self.get_create_params(bulk_mode: true)[:_json]
 
     # Perform bulk create in a transaction.
-    ActiveRecord::Base.transaction { self.get_create_from.create(create_data) }
+    ActiveRecord::Base.transaction { self.create_from.create(create_data) }
   end
 end
 

data/lib/rest_framework/mixins/model_controller_mixin.rb

@@ -23,27 +23,30 @@ module RESTFramework::Mixins::BaseModelControllerMixin
     # Attributes for configuring record fields.
     fields: nil,
     field_config: nil,
+    read_only_fields: RESTFramework.config.read_only_fields,
+    write_only_fields: RESTFramework.config.write_only_fields,
+    hidden_fields: nil,
 
     # Attributes for finding records.
     find_by_fields: nil,
-    find_by_query_param: "find_by",
+    find_by_query_param: "find_by".freeze,
 
     # Options for what should be included/excluded from default fields.
     exclude_associations: false,
 
     # Options for handling request body parameters.
     allowed_parameters: nil,
-    filter_pk_from_request_body: true,
-    exclude_body_fields: RESTFramework.config.exclude_body_fields,
 
     # Attributes for the default native serializer.
     native_serializer_config: nil,
     native_serializer_singular_config: nil,
     native_serializer_plural_config: nil,
-    native_serializer_only_query_param: "only",
-    native_serializer_except_query_param: "except",
+    native_serializer_only_query_param: "only".freeze,
+    native_serializer_except_query_param: "except".freeze,
+    native_serializer_include_query_param: "include".freeze,
+    native_serializer_exclude_query_param: "exclude".freeze,
     native_serializer_associations_limit: nil,
-    native_serializer_associations_limit_query_param: "associations_limit",
+    native_serializer_associations_limit_query_param: "associations_limit".freeze,
     native_serializer_include_associations_count: false,
 
     # Attributes for filtering, ordering, and searching.
@@ -51,19 +54,19 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       RESTFramework::QueryFilter,
       RESTFramework::OrderingFilter,
       RESTFramework::SearchFilter,
-    ],
+    ].freeze,
     filter_recordset_before_find: true,
     filter_fields: nil,
     ordering_fields: nil,
-    ordering_query_param: "ordering",
+    ordering_query_param: "ordering".freeze,
     ordering_no_reorder: false,
     search_fields: nil,
-    search_query_param: "search",
+    search_query_param: "search".freeze,
     search_ilike: false,
     ransack_options: nil,
-    ransack_query_param: "q",
+    ransack_query_param: "q".freeze,
     ransack_distinct: true,
-    ransack_distinct_query_param: "distinct",
+    ransack_distinct_query_param: "distinct".freeze,
 
     # Options for association assignment.
     permit_id_assignment: true,
@@ -135,7 +138,9 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       reflections = model.reflections
       attributes = model._default_attributes
       readonly_attributes = model.readonly_attributes
-      exclude_body_fields = self.exclude_body_fields&.map(&:to_s)
+      read_only_fields = self.read_only_fields&.map(&:to_s)&.to_set || Set[]
+      write_only_fields = self.write_only_fields&.map(&:to_s)&.to_set || Set[]
+      hidden_fields = self.hidden_fields&.map(&:to_s)&.to_set || Set[]
       rich_text_association_names = model.reflect_on_all_associations(:has_one)
         .collect(&:name)
         .select { |n| n.to_s.start_with?("rich_text_") }
@@ -149,14 +154,29 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         if model.primary_key == f
           cfg[:primary_key] = true
 
-          unless cfg.key?(:readonly)
-            cfg[:readonly] = true
+          unless cfg.key?(:read_only)
+            cfg[:read_only] = true
           end
         end
 
-        # Annotate readonly attributes.
-        if f.in?(readonly_attributes) || f.in?(exclude_body_fields)
-          cfg[:readonly] = true
+        # Annotate field mutability and display properties.
+        cfg[:read_only] = true if f.in?(readonly_attributes) || f.in?(read_only_fields)
+        cfg[:write_only] = true if f.in?(write_only_fields)
+        cfg[:hidden] = true if f.in?(hidden_fields)
+
+        # Raise warnings on some bad combinations of properties.
+        if cfg[:write_only]
+          if cfg[:read_only]
+            Rails.logger.warn("RRF: `#{f}` write_only conflicts with read_only.")
+          end
+
+          if cfg[:hidden]
+            Rails.logger.warn("RRF: `#{f}` write_only implies hidden.")
+          end
+
+          if cfg[:hidden_from_index]
+            Rails.logger.warn("RRF: `#{f}` write_only implies hidden_from_index.")
+          end
         end
 
         # Annotate column data.
@@ -167,12 +187,12 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         end
 
         # Add default values from the model's schema.
-        if column_default = column_defaults[f] && !cfg[:default].nil?
-          cfg[:default] ||= column_default
+        if cfg[:default].nil? && (column_default = column_defaults[f])
+          cfg[:default] = column_default
         end
 
         # Add metadata from the model's attributes hash.
-        if attribute = attributes[f]
+        if attributes.key?(f) && attribute = attributes[f]
           if cfg[:default].nil? && default = attribute.value_before_type_cast
             cfg[:default] = default
           end
@@ -256,6 +276,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         # Determine if this is just a method.
         if !cfg[:kind] && model.method_defined?(f)
           cfg[:kind] = "method"
+          cfg[:read_only] = true if cfg[:read_only].nil?
         end
 
         # Collect validator options into a hash on their type, while also updating `required` based
@@ -284,7 +305,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
         end
 
         next [ f, cfg ]
-      }.to_h.with_indifferent_access
+      }.to_h.compact.with_indifferent_access
     end
 
     def openapi_schema
@@ -309,7 +330,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
             v[:type] = cfg[:type]
           end
 
-          v[:readOnly] = true if cfg[:readonly]
+          v[:readOnly] = true if cfg[:read_only]
           v[:default] = cfg[:default] if cfg.key?(:default)
 
           if enum_variants = cfg[:enum_variants]
@@ -497,7 +518,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       config = self.class.field_configuration[f]
 
       # ActionText Integration:
-      if self.class.enable_action_text && reflections.key?("rich_test_#{f}")
+      if self.class.enable_action_text && reflections.key?("rich_text_#{f}")
         next f
       end
 
@@ -632,14 +653,12 @@ module RESTFramework::Mixins::BaseModelControllerMixin
       body_params[k].unshift(*v)
     end
 
-    # Filter primary key, if configured.
-    if self.class.filter_pk_from_request_body && bulk_mode != :update
-      body_params.delete(pk)
+    # Filter read-only fields.
+    body_params.delete_if do |f, _|
+      cfg = self.class.field_configuration[f]
+      cfg && cfg[:read_only]
     end
 
-    # Filter fields in `exclude_body_fields`.
-    (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
-
     body_params
   end
   alias_method :get_create_params, :get_body_params
@@ -701,7 +720,7 @@ module RESTFramework::Mixins::BaseModelControllerMixin
   end
 
   # Determine what collection to call `create` on.
-  def get_create_from
+  def create_from
     if self.class.create_from_recordset
       # Create with any properties inherited from the recordset. We exclude any `select` clauses
       # in case model callbacks need to call `count` on this collection, which typically raises a
@@ -769,7 +788,7 @@ module RESTFramework::Mixins::CreateModelMixin
 
   # Perform the `create!` call and return the created record.
   def create!
-    self.get_create_from.create!(self.get_create_params)
+    self.create_from.create!(self.get_create_params)
   end
 end
 

data/lib/rest_framework/routers.rb

@@ -46,7 +46,7 @@ module ActionDispatch::Routing
       controller
     end
 
-    # Interal interface for routing extra actions.
+    # Internal interface for routing extra actions.
     def _route_extra_actions(actions, &block)
       parsed_actions = RESTFramework::Utils.parse_extra_actions(actions)
 
@@ -84,13 +84,7 @@ module ActionDispatch::Routing
       unscoped = kwargs.delete(:unscoped)
 
       # Determine plural/singular resource.
-      force_singular = kwargs.delete(:force_singular)
-      force_plural = kwargs.delete(:force_plural)
-      if force_singular
-        singular = true
-      elsif force_plural
-        singular = false
-      elsif !controller_class.singleton_controller.nil?
+      if !controller_class.singleton_controller.nil?
         singular = controller_class.singleton_controller
       else
         singular = default_singular
@@ -98,7 +92,7 @@ module ActionDispatch::Routing
       resource_method = singular ? :resource : :resources
 
       # Call either `resource` or `resources`, passing appropriate modifiers.
-      skip = RESTFramework::Utils.get_skipped_builtin_actions(controller_class)
+      skip = RESTFramework::Utils.get_skipped_builtin_actions(controller_class, singular)
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do

data/lib/rest_framework/serializers/native_serializer.rb

@@ -1,6 +1,14 @@
 # This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
 # top-level being either an array or a hash).
 class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers::BaseSerializer
+  EXTRACT_FROM_QUERY = ->(p, controller) {
+    return Set[] if p.blank?
+    (
+      controller.request&.query_parameters&.[](p).presence&.split(",")&.map { |x|
+        x.strip.presence
+      }&.compact || []
+    ).to_set
+  }
   class_attribute :config
   class_attribute :singular_config
   class_attribute :plural_config
@@ -26,28 +34,66 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     @model ||= @controller.class.get_model if @controller
   end
 
-  # Get controller action, if possible.
-  def get_action
-    @controller&.action_name&.to_sym
+  def action
+    @action ||= @controller&.action_name&.to_sym
   end
 
-  # Get a locally defined native serializer configuration, if one is defined.
-  def get_local_native_serializer_config
-    action = self.get_action
+  def fields
+    return @fields if defined?(@fields)
+    return nil unless base_fields = @controller&.get_fields
+
+    only_param = @controller.class.native_serializer_only_query_param
+    except_param = @controller.class.native_serializer_except_query_param
+    include_param = @controller.class.native_serializer_include_query_param
+    exclude_param = @controller.class.native_serializer_exclude_query_param
+
+    only = EXTRACT_FROM_QUERY.call(only_param, @controller)
+    except = EXTRACT_FROM_QUERY.call(except_param, @controller)
+    include = EXTRACT_FROM_QUERY.call(include_param, @controller)
+    exclude = EXTRACT_FROM_QUERY.call(exclude_param, @controller)
+
+    field_configuration = @controller.class.field_configuration
+    @fields = base_fields.select do |f|
+      cfg = field_configuration[f]
+
+      # We never serialize write-only fields.
+      next false if cfg[:write_only]
+
+      # We never serialize `hidden_from_index` fields for collections as this is a performance
+      # option.
+      next false if cfg[:hidden_from_index] && @many
+
+      # Explicitly excluded fields should never be serialized.
+      next false if f.in?(except) || f.in?(exclude)
+
+      # Hidden fields must be in `only` or `include` to be serialized; for non-hidden fields, either
+      # `only` must be empty, or the field must be in `only` or `include`.
+      if cfg[:hidden]
+        next true if f.in?(only) || f.in?(include)
+      elsif only.empty? || f.in?(only) || f.in?(include)
+        next true
+      end
 
-    if action && self.action_config
+      next false
+    end
+
+    @fields
+  end
+
+  def get_local_native_serializer_config
+    if (action = self.action) && (cfg = action_config)
       # Index action should use :list serializer config if :index is not provided.
-      action = :list if action == :index && !self.action_config.key?(:index)
+      action = :list if action == :index && !cfg.key?(:index)
 
-      return self.action_config[action] if self.action_config[action]
+      return cfg[action] if cfg[action]
     end
 
     # No action_config, so try singular/plural config if explicitly instructed to via @many.
     return self.plural_config if @many == true && self.plural_config
     return self.singular_config if @many == false && self.singular_config
 
-    # Lastly, try returning the default config, or singular/plural config in that order.
-    self.config || self.singular_config || self.plural_config
+    # Lastly, try returning the default config.
+    self.config
   end
 
   # Get a native serializer configuration from the controller.
@@ -63,102 +109,9 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     controller_serializer || @controller.class.native_serializer_config
   end
 
-  # Filter a single subconfig for specific keys. By default, keys from `fields` are removed from the
-  # provided `subcfg`. There are two (mutually exclusive) options to adjust the behavior:
-  #
-  #  `add`: Add any `fields` to the `subcfg` which aren't already in the `subcfg`.
-  #  `only`: Remove any values found in the `subcfg` not in `fields`.
-  def self.filter_subcfg(subcfg, fields:, add: false, only: false)
-    raise "`add` and `only` conflict with one another" if add && only
-
-    # Don't process nil `subcfg`s.
-    return subcfg unless subcfg
-
-    if subcfg.is_a?(Array)
-      subcfg = subcfg.map(&:to_sym)
-
-      if add
-        # Only add fields which are not already included.
-        subcfg += fields - subcfg
-      elsif only
-        subcfg.select! { |c| c.in?(fields) }
-      else
-        subcfg -= fields
-      end
-    elsif subcfg.is_a?(Hash)
-      subcfg = subcfg.symbolize_keys
-
-      if add
-        # Add doesn't make sense in a hash context since we wouldn't know the values.
-      elsif only
-        subcfg.select! { |k, _v| k.in?(fields) }
-      else
-        subcfg.reject! { |k, _v| k.in?(fields) }
-      end
-    else  # Subcfg is a single element (assume string/symbol).
-      subcfg = subcfg.to_sym
-
-      if add
-        subcfg = subcfg.in?(fields) ? fields : [ subcfg, *fields ]
-      elsif only
-        subcfg = subcfg.in?(fields) ? subcfg : []
-      else
-        subcfg = subcfg.in?(fields) ? [] : subcfg
-      end
-    end
-
-    subcfg
-  end
-
-  # Filter out configuration properties based on the :except/:only query parameters.
-  def filter_from_request(cfg)
-    return cfg unless @controller
-
-    except_param = @controller.class.native_serializer_except_query_param
-    only_param = @controller.class.native_serializer_only_query_param
-    if except_param && except = @controller.request&.query_parameters&.[](except_param).presence
-      if except = except.split(",").map(&:strip).map(&:to_sym).presence
-        # Filter `only`, `except` (additive), `include`, `methods`, and `serializer_methods`.
-        if cfg[:only]
-          cfg[:only] = self.class.filter_subcfg(cfg[:only], fields: except)
-        elsif cfg[:except]
-          cfg[:except] = self.class.filter_subcfg(cfg[:except], fields: except, add: true)
-        else
-          cfg[:except] = except
-        end
-
-        cfg[:include] = self.class.filter_subcfg(cfg[:include], fields: except)
-        cfg[:methods] = self.class.filter_subcfg(cfg[:methods], fields: except)
-        cfg[:serializer_methods] = self.class.filter_subcfg(
-          cfg[:serializer_methods], fields: except
-        )
-        cfg[:includes_map] = self.class.filter_subcfg(cfg[:includes_map], fields: except)
-      end
-    elsif only_param && only = @controller.request&.query_parameters&.[](only_param).presence
-      if only = only.split(",").map(&:strip).map(&:to_sym).presence
-        # Filter `only`, `include`, and `methods`. Adding anything to `except` is not needed,
-        # because any configuration there takes precedence over `only`.
-        if cfg[:only]
-          cfg[:only] = self.class.filter_subcfg(cfg[:only], fields: only, only: true)
-        else
-          cfg[:only] = only
-        end
-
-        cfg[:include] = self.class.filter_subcfg(cfg[:include], fields: only, only: true)
-        cfg[:methods] = self.class.filter_subcfg(cfg[:methods], fields: only, only: true)
-        cfg[:serializer_methods] = self.class.filter_subcfg(
-          cfg[:serializer_methods], fields: only, only: true
-        )
-        cfg[:includes_map] = self.class.filter_subcfg(cfg[:includes_map], fields: only, only: true)
-      end
-    end
-
-    cfg
-  end
-
   # Get the associations limit from the controller.
-  def _get_associations_limit
-    return @_get_associations_limit if defined?(@_get_associations_limit)
+  def _associations_limit
+    return @_associations_limit if defined?(@_associations_limit)
 
     limit = @controller&.class&.native_serializer_associations_limit
 
@@ -174,11 +127,11 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       end
     end
 
-    @_get_associations_limit = limit
+    @_associations_limit = limit
   end
 
   # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
-  def _get_controller_serializer_config(fields)
+  def _get_controller_serializer_config
     columns = []
     includes = {}
     methods = []
@@ -194,7 +147,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     reflections = @model.reflections
     attachment_reflections = @model.attachment_reflections
 
-    fields.each do |f|
+    self.fields.each do |f|
       field_config = @controller.class.field_configuration[f]
       next if field_config[:write_only]
 
@@ -216,7 +169,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
         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
+          if limit = self._associations_limit
             serializer_methods[f] = f
             self.define_singleton_method(f) do |record|
               next record.send(f).limit(limit).as_json(**sub_config)
@@ -312,17 +265,17 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     end
 
     # If the config wasn't determined, build a serializer config from controller fields.
-    if @model && fields = @controller&.get_fields
-      return self._get_controller_serializer_config(fields.deep_dup)
+    if @model && self.fields
+      return self._get_controller_serializer_config
     end
 
     # By default, pass an empty configuration, using the default Rails serializer.
     {}
   end
 
-  # Get a configuration passable to `serializable_hash` for the object, filtered if required.
+  # Get a configuration passable to `serializable_hash` for the object.
   def get_serializer_config
-    self.filter_from_request(self.get_raw_serializer_config)
+    self.get_raw_serializer_config
   end
 
   # Serialize a single record and merge results of `serializer_methods`.

data/lib/rest_framework/utils.rb

@@ -41,10 +41,11 @@ module RESTFramework::Utils
     }.to_h
   end
 
-  # Get actions which should be skipped for a given controller.
-  def self.get_skipped_builtin_actions(controller_class)
+  def self.get_skipped_builtin_actions(controller_class, singular)
     (
-      RESTFramework::BUILTIN_ACTIONS.keys + RESTFramework::BUILTIN_MEMBER_ACTIONS.keys
+      (
+        RESTFramework::BUILTIN_ACTIONS.keys - (singular ? [ :index ] : [])
+      ) + RESTFramework::BUILTIN_MEMBER_ACTIONS.keys
     ).reject do |action|
       controller_class.method_defined?(action)
     end
@@ -154,7 +155,7 @@ module RESTFramework::Utils
 
     # Warn for any unknown keys.
     (h.keys - [ :only, :except, :include, :exclude ]).each do |k|
-      Rails.logger.warn("RRF: Unknown key in fields hash: #{k}")
+      Rails.logger.warn("RRF: Unknown key in fields hash: #{k}.")
     end
 
     # We should always return strings, not symbols.
@@ -203,7 +204,7 @@ module RESTFramework::Utils
       sub_fields = [ model.primary_key ].flatten.compact
       label_fields = RESTFramework.config.label_fields
 
-      # Preferrably find a database column to use as label.
+      # Preferably find a database column to use as label.
       if match = label_fields.find { |f| f.in?(model.column_names) }
         return sub_fields + [ match ]
       end