rest_framework 1.1.0 → 2.0.0.beta1

data/lib/rest_framework/serializers/base_serializer.rb

@@ -16,7 +16,7 @@ class RESTFramework::Serializers::BaseSerializer
   end
 
   # Synonym for `serialize` for compatibility with `active_model_serializers`.
-  # :nocov:
+  # simplecov:disable
   def serializable_hash(*args)
     self.serialize(*args)
   end
@@ -35,7 +35,7 @@ class RESTFramework::Serializers::BaseSerializer
   def associations(*args, **kwargs)
     []
   end
-  # :nocov:
+  # simplecov:enable
 end
 
 # Alias for convenience.

data/lib/rest_framework/serializers/native_serializer.rb

@@ -28,8 +28,10 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     # Determine model either explicitly, or by inspecting @object or @controller.
     @model = model
     @model ||= @object.class if @object.is_a?(ActiveRecord::Base)
-    @model ||= @object[0].class if
-      @many && @object.is_a?(Enumerable) && @object.is_a?(ActiveRecord::Base)
+    @model ||= @object.klass if @many && @object.is_a?(ActiveRecord::Relation)
+    @model ||= @object.first.class if @many &&
+      @object.is_a?(Enumerable) &&
+      @object.first.is_a?(ActiveRecord::Base)
 
     @model ||= @controller.class.model if @controller
   end
@@ -109,25 +111,77 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
     controller_serializer || @controller.class.native_serializer_config
   end
 
-  # Get the associations limit from the controller.
-  def _associations_limit
-    return @_associations_limit if defined?(@_associations_limit)
+  # The record cap for a collection association (`nil` = unlimited). The default is applied even
+  # when the feature is off, so responses are always bounded. `key?` (not `||`) reads the
+  # `field_config` override so an explicit `nil` there means unlimited/uncapped rather than falling
+  # back to the controller default.
+  def _effective_association_limit(association_name, field_config)
+    controller = @controller&.class
 
-    limit = @controller&.class&.native_serializer_associations_limit
+    default = field_config.key?(:limit) ?
+      field_config[:limit] : controller&.association_limit
+    return default unless controller&.enable_association_queries
 
-    # Extract the limit from the query parameters if it's set.
-    if query_param = @controller&.class&.native_serializer_associations_limit_query_param
-      if @controller.request.query_parameters.key?(query_param)
-        query_limit = @controller.request.query_parameters[query_param].to_i
-        if query_limit > 0
-          limit = query_limit
-        else
-          limit = nil
-        end
-      end
-    end
+    requested = self._requested_association_limit(association_name)
+    return default if requested.nil?
+
+    max = field_config.key?(:limit_max) ?
+      field_config[:limit_max] : controller.association_limit_max
+
+    # `all` means "as many as allowed" — the cap, or unlimited when the cap is `nil`.
+    return max if requested == :all
+
+    max ? [ requested, max ].min : requested
+  end
+
+  # `all`, `none`, and `0` all mean "no limit" — `0` is free to reuse as a sentinel since an
+  # association is dropped via `except`, not `limit=0`. Anything else must be a plain positive
+  # integer, so a nested/array param or junk can't drive the query.
+  def _requested_association_limit(association_name)
+    return nil unless prefix = @controller.class.association_query_prefix.presence
+
+    raw = @controller.request&.query_parameters&.[]("#{prefix}.#{association_name}.limit")
+    return nil unless raw.is_a?(String)
+
+    raw = raw.strip
+    return :all if raw.in?(%w[all none])
+    return nil unless raw.match?(/\A\d+\z/)
+
+    # The regex guarantees a non-negative integer, so anything but zero is a positive limit.
+    limit = raw.to_i
+    limit.zero? ? :all : limit
+  end
+
+  # The fields to serialize for association `f`, honoring a consumer's `?<prefix>.<f>.fields=`
+  # request bounded by the allowlist. Only active when the feature is enabled.
+  def _effective_association_fields(association_name, ref, field_config)
+    default_fields = field_config[:fields]
+    return default_fields unless @controller&.class&.enable_association_queries
+    return default_fields if ref.polymorphic? # no single target class to bound the request
+
+    requested = self._requested_association_fields(association_name)
+    return default_fields if requested.blank?
+
+    # The primary key is always kept so records stay identifiable. `_valid_association_field?` is
+    # the last line of defense against leaking a non-serializable or nested-association field.
+    allowed = (default_fields + (field_config[:requestable_fields] || [])).uniq
+    valid = (requested & allowed).select { |sf| self._valid_association_field?(ref, sf) }
+    (Array(ref.klass.primary_key).map(&:to_s) + valid).uniq
+  end
+
+  # Only a plain scalar string is honored, so a nested-hash/array param can't reach `where`/`split`.
+  def _requested_association_fields(association_name)
+    return nil unless prefix = @controller.class.association_query_prefix.presence
+
+    raw = @controller.request&.query_parameters&.[]("#{prefix}.#{association_name}.fields")
+    return nil unless raw.is_a?(String)
+
+    raw.split(",").map { |x| x.strip.presence }.compact
+  end
 
-    @_associations_limit = limit
+  def _valid_association_field?(ref, field)
+    field.in?(ref.klass.column_names) ||
+      (ref.klass.method_defined?(field) && !ref.klass.reflect_on_association(field.to_sym))
   end
 
   # Get a serializer configuration from the controller. `@controller` and `@model` must be set.
@@ -156,7 +210,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
       elsif ref = reflections[f]
         sub_columns = []
         sub_methods = []
-        field_config[:sub_fields].each do |sf|
+        self._effective_association_fields(f, ref, field_config).each do |sf|
           if !ref.polymorphic? && sf.in?(ref.klass.column_names)
             sub_columns << sf
           else
@@ -167,9 +221,9 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
 
         # Apply certain rules regarding collection associations.
         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._associations_limit
+          # A finite limit needs a per-record `.limit` query, since eager `includes` can't cap rows
+          # per parent; an unlimited (`nil`) association falls through to `includes` preloading.
+          if limit = self._effective_association_limit(f, field_config)
             serializer_methods[f] = f
             self.define_singleton_method(f) do |record|
               next record.send(f).limit(limit).as_json(**sub_config)
@@ -179,7 +233,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
             #
             # # Even though we use a serializer method, if the count will later be added, then put
             # # this field into the includes_map.
-            # if @controller.class.native_serializer_include_associations_count
+            # if @controller.class.include_association_count
             #   includes_map[f] = f.to_sym
             # end
           else
@@ -188,7 +242,7 @@ class RESTFramework::Serializers::NativeSerializer < RESTFramework::Serializers:
           end
 
           # If we need to include the association count, then add it here.
-          if @controller.class.native_serializer_include_associations_count
+          if @controller.class.include_association_count
             method_name = "#{f}.count"
             serializer_methods[method_name] = method_name
             self.define_singleton_method(method_name) do |record|

data/lib/rest_framework/utils.rb

@@ -1,61 +1,15 @@
 module RESTFramework::Utils
   HTTP_VERB_ORDERING = %w[GET POST PUT PATCH DELETE OPTIONS HEAD]
 
-  # Convert `extra_actions` hash to a consistent format: `{path:, methods:, metadata:, kwargs:}`.
-  def self.parse_extra_actions(extra_actions)
-    (extra_actions || {}).map { |k, v|
-      path = k
-      kwargs = {}
-
-      # Convert structure to path/methods/kwargs.
-      if v.is_a?(Hash)
-        # Symbolize keys (which also makes a copy so we don't mutate the original).
-        v = v.symbolize_keys
-
-        # Cast method/methods to an array.
-        methods = [ v.delete(:methods), v.delete(:method) ].flatten.compact
-
-        # Override path if it's provided.
-        if v.key?(:path)
-          path = v.delete(:path)
-        end
-
-        # Extract metadata, if provided.
-        metadata = v.delete(:metadata).presence
-
-        # Pass any further kwargs to the underlying Rails interface.
-        kwargs = v
-      else
-        methods = [ v ].flatten
-      end
-
-      next [
-        k,
-        {
-          path: path,
-          methods: methods,
-          metadata: metadata,
-          kwargs: kwargs,
-        }.compact,
-      ]
-    }.to_h
-  end
-
-  def self.get_skipped_builtin_actions(controller_class, singular)
-    candidates = (
-      RESTFramework::BUILTIN_ACTIONS.keys - (singular ? [ :index ] : [])
-    ) + RESTFramework::BUILTIN_MEMBER_ACTIONS.keys
-
-    return candidates unless controller_class.model
-
-    exclude = controller_class.excluded_actions&.to_set || Set.new
-    candidates.reject do |action|
-      controller_class.method_defined?(action) && !exclude.include?(action)
-    end
-  end
-
   # Get the first route pattern which matches the given request.
   def self.get_request_route(application_routes, request)
+    # Prefer the route already resolved by the router to avoid an expensive `recognize` call. This
+    # is also required for Rails 8.1+ where OPTIONS routes are non-anchored, causing `path_info` to
+    # be modified during dispatch, which makes `recognize` fail from inside the controller action.
+    if route = request.env["action_dispatch.route"]
+      return route
+    end
+
     application_routes.router.recognize(request) { |route, _| return route }
   end
 
@@ -165,9 +119,8 @@ module RESTFramework::Utils
     parsed_fields.map(&:to_s)
   end
 
-  # Get the fields for a given model, including not just columns (which includes
-  # foreign keys), but also associations. Note that we always return an array of
-  # strings, not symbols.
+  # Get the fields for a given model, including not just columns (which includes foreign keys), but
+  # also associations. Note that we always return an array of strings, not symbols.
   def self.fields_for(model, exclude_associations:, action_text:, active_storage:)
     foreign_keys = model.reflect_on_all_associations(:belongs_to).map(&:foreign_key)
     base_fields = model.column_names.reject { |c| c.in?(foreign_keys) }
@@ -201,23 +154,23 @@ module RESTFramework::Utils
     base_fields + associations + atf + asf
   end
 
-  # Get the sub-fields that may be serialized and filtered/ordered for a reflection.
-  def self.sub_fields_for(ref)
+  # Get the association's fields that may be serialized and filtered/ordered for a reflection.
+  def self.association_fields_for(ref)
     if !ref.polymorphic? && model = ref.klass
-      sub_fields = [ model.primary_key ].flatten.compact
+      fields = [ model.primary_key ].flatten.compact
       label_fields = RESTFramework.config.label_fields
 
       # Preferably find a database column to use as label.
       if match = label_fields.find { |f| f.in?(model.column_names) }
-        return sub_fields + [ match ]
+        return fields + [ match ]
       end
 
       # Otherwise, find a method.
       if match = label_fields.find { |f| model.method_defined?(f) }
-        return sub_fields + [ match ]
+        return fields + [ match ]
       end
 
-      return sub_fields
+      return fields
     end
 
     [ "id", "name" ]
@@ -236,6 +189,30 @@ module RESTFramework::Utils
     nil
   end
 
+  # Find the REST controller for `model` at the same namespace level as `current_controller`, e.g.
+  # `Api::Demo::MoviesController` + `Genre` => `Api::Demo::GenresController`, or `nil` if none. The
+  # `model` match guards against trusting a same-named controller for a different model.
+  def self.controller_for_model(current_controller, model)
+    return nil unless model && (base_name = current_controller.name)
+
+    namespace = base_name.deconstantize
+    model_name = model.model_name
+
+    # Plural for a collection controller, singular for a singular-resource one.
+    [ model_name.plural, model_name.singular ].each do |name|
+      candidate_name = "#{name.camelize}Controller"
+      candidate_name = "#{namespace}::#{candidate_name}" if namespace.present?
+
+      candidate = candidate_name.safe_constantize
+      next unless candidate.is_a?(Class) && candidate.include?(RESTFramework::Controller)
+      next unless candidate.model == model
+
+      return candidate
+    end
+
+    nil
+  end
+
   # Wrap a serializer with an adapter if it is an ActiveModel::Serializer.
   def self.wrap_ams(s)
     if defined?(ActiveModel::Serializer) && (s < ActiveModel::Serializer)
@@ -244,12 +221,4 @@ module RESTFramework::Utils
 
     s
   end
-
-  # Used for deprecated mixins that rely on model being determined from the controller name.
-  def self.get_model(controller_class)
-    begin
-      controller_class.name.demodulize.chomp("Controller").singularize.constantize
-    rescue NameError
-    end
-  end
 end

data/lib/rest_framework/version.rb

@@ -22,11 +22,14 @@ module RESTFramework
       UNKNOWN
     end
 
-    def self.stamp_version
-      # Only stamp the version if it's not unknown.
-      if RESTFramework::VERSION != UNKNOWN
-        File.write(VERSION_FILEPATH, RESTFramework::VERSION)
+    def self.stamp_version(version = nil)
+      # Stamp the given version into the VERSION file, deriving it from git when none is provided.
+      # Returns the stamped version so callers don't rely on the (require-time) `VERSION` constant.
+      version ||= self.get_version
+      if version != UNKNOWN
+        File.write(VERSION_FILEPATH, version)
       end
+      version
     end
 
     def self.unstamp_version
@@ -34,5 +37,5 @@ module RESTFramework
     end
   end
 
-  VERSION = Version.get_version
+  VERSION = Version.get_version(skip_git: true)
 end

data/lib/rest_framework.rb

@@ -1,26 +1,6 @@
 # frozen_string_literal: true
 
 module RESTFramework
-  BUILTIN_FORM_ACTIONS = [ :new, :edit ].freeze
-  BUILTIN_ACTIONS = {
-    index: :get,
-    new: :get,
-    create: :post,
-  }.freeze
-  BUILTIN_MEMBER_ACTIONS = {
-    show: :get,
-    edit: :get,
-    update: [ :put, :patch ].freeze,
-    destroy: :delete,
-  }.freeze
-  RRF_BUILTIN_ACTIONS = {
-    options: :options,
-  }.freeze
-  RRF_BUILTIN_BULK_ACTIONS = {
-    update_all: [ :put, :patch ].freeze,
-    destroy_all: :delete,
-  }.freeze
-
   # Storage for extra routes and associated metadata.
   EXTRA_ACTION_ROUTES = Set.new
   ROUTE_METADATA = {}
@@ -47,6 +27,7 @@ module RESTFramework
     # Bootstrap Icons
     "bootstrap-icons.min.css" => {
       url: "https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.min.css",
+      sri: "sha384-XGjxtQfXaH2tnPFa9x+ruJTuLE3Aa6LhHSWRr1XeTyhezb4abCG4ccI5AkVDxqC+",
       inline_fonts: true,
     },
 
@@ -74,19 +55,23 @@ module RESTFramework
       extra_tag_attrs: { class: "rrf-light-mode" },
     },
 
-    # NeatJSON
+    # NeatJSON. The package publishes no minified build; jsdelivr's `neatjson.min.js` is synthesized
+    # on the fly (so its bytes/SRI aren't stable), so we pin the published `neatjson.js` instead.
     "neatjson.min.js" => {
-      url: "https://cdn.jsdelivr.net/npm/neatjson@0.10.6/javascript/neatjson.min.js",
+      url: "https://cdn.jsdelivr.net/npm/neatjson@0.10.6/javascript/neatjson.js",
+      sri: "sha384-7yRMvyGBuBnnlsgFwUDx7wY7Y/kXt7Irg5xppXVAI0yp3R0870lWaXNP/JE2rbFA",
       exclude_from_docs: true,
     },
 
     # Trix
     "trix.min.css" => {
       url: "https://unpkg.com/trix@2.0.8/dist/trix.css",
+      sri: "sha384-Cgg84c/W0Q5VrTzc4ITmV88Ocx4Pn1YlTXPvSTJjX6+lxJRLYrZ4chaighxlqOY1",
       exclude_from_docs: true,
     },
     "trix.min.js" => {
       url: "https://unpkg.com/trix@2.0.8/dist/trix.umd.min.js",
+      sri: "sha384-Ki3zDe3whjAHK/GOksrYLGCU8m0SkmiJQ4Kqm3jQlM3YCl2hFBf17s9bzjVYmXWX",
       exclude_from_docs: true,
     },
   }.map { |name, cfg|
@@ -149,19 +134,6 @@ module RESTFramework
     # Permits use of `render(api: obj)` syntax over `render_api(obj)`; `true` by default.
     attr_accessor :register_api_renderer
 
-    # Run `rrf_finalize` on controllers automatically using a `TracePoint` hook. This is `true` by
-    # default, and can be disabled for performance, and must be global because we have to determine
-    # this before any controller-specific configuration is set. If this is set to `false`, then you
-    # must manually call `rrf_finalize` after any configuration on each controller that needs to
-    # participate in:
-    #  - Model delegation, for the helper methods to be defined dynamically.
-    #  - Websockets, for `::Channel` class to be defined dynamically.
-    #  - Controller configuration freezing.
-    attr_accessor :auto_finalize
-
-    # Freeze configuration attributes during finalization to prevent accidental mutation.
-    attr_accessor :freeze_config
-
     # Specify reverse association tables that are typically very large, and therefore should not be
     # added to fields by default.
     attr_accessor :large_reverse_association_tables
@@ -169,9 +141,6 @@ module RESTFramework
     # Whether the backtrace should be shown in rescued errors.
     attr_accessor :show_backtrace
 
-    # Disable `rescue_from` on the controller mixins.
-    attr_accessor :disable_rescue_from
-
     # The default label fields to use when generating labels for `has_many` associations.
     attr_accessor :label_fields
 
@@ -191,7 +160,6 @@ module RESTFramework
 
     def initialize
       self.register_api_renderer = true
-      self.auto_finalize = true
 
       self.show_backtrace = Rails.env.development?
 
@@ -223,8 +191,6 @@ end
 require_relative "rest_framework/engine"
 require_relative "rest_framework/errors"
 require_relative "rest_framework/filters"
-require_relative "rest_framework/generators"
-require_relative "rest_framework/mixins"
 require_relative "rest_framework/paginators"
 require_relative "rest_framework/routers"
 require_relative "rest_framework/serializers"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0.beta1
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-16 00:00:00.000000000 Z
+date: 2026-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -55,25 +55,18 @@ files:
 - app/views/rest_framework/routes_and_forms/routes/_route.html.erb
 - lib/rest_framework.rb
 - lib/rest_framework/controller.rb
+- lib/rest_framework/controller/actions.rb
 - lib/rest_framework/controller/bulk.rb
 - lib/rest_framework/controller/crud.rb
 - lib/rest_framework/controller/openapi.rb
 - lib/rest_framework/engine.rb
 - lib/rest_framework/errors.rb
-- lib/rest_framework/errors/base_error.rb
-- lib/rest_framework/errors/nil_passed_to_render_api_error.rb
 - lib/rest_framework/filters.rb
 - lib/rest_framework/filters/base_filter.rb
 - lib/rest_framework/filters/ordering_filter.rb
 - lib/rest_framework/filters/query_filter.rb
 - lib/rest_framework/filters/ransack_filter.rb
 - lib/rest_framework/filters/search_filter.rb
-- lib/rest_framework/generators.rb
-- lib/rest_framework/generators/controller_generator.rb
-- lib/rest_framework/mixins.rb
-- lib/rest_framework/mixins/base_controller_mixin.rb
-- lib/rest_framework/mixins/bulk_model_controller_mixin.rb
-- lib/rest_framework/mixins/model_controller_mixin.rb
 - lib/rest_framework/paginators.rb
 - lib/rest_framework/paginators/base_paginator.rb
 - lib/rest_framework/paginators/page_number_paginator.rb
@@ -105,9 +98,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.10
 signing_key:

data/lib/rest_framework/errors/base_error.rb

@@ -1,5 +0,0 @@
-class RESTFramework::Errors::BaseError < StandardError
-end
-
-# Alias for convenience.
-RESTFramework::BaseError = RESTFramework::Errors::BaseError

data/lib/rest_framework/errors/nil_passed_to_render_api_error.rb

@@ -1,14 +0,0 @@
-class RESTFramework::Errors::NilPassedToRenderAPIError < RESTFramework::Errors::BaseError
-  def message
-    <<~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.,
-      `find_by!`) to raise `ActiveRecord::RecordNotFound`, which the REST controller will catch and
-      return an appropriate error response.
-    MSG
-  end
-end
-
-# Alias for convenience.
-RESTFramework::NilPassedToRenderAPIError = RESTFramework::Errors::NilPassedToRenderAPIError

data/lib/rest_framework/generators/controller_generator.rb

@@ -1,64 +0,0 @@
-require "rails/generators"
-
-# Most projects don't have the inflection "REST" as an acronym, so this is a helper class to prevent
-# this generator from being namespaced as `"r_e_s_t_framework"`.
-# :nocov:
-class RESTFrameworkCustomGeneratorControllerNamespace < String
-  def camelize
-    "RESTFramework"
-  end
-end
-# :nocov:
-
-class RESTFramework::Generators::ControllerGenerator < Rails::Generators::Base
-  PATH_REGEX = %r{^[a-z0-9][a-z0-9_/]+$}
-
-  desc <<~END
-    Description:
-      Generates a new REST Framework controller.
-
-      Specify the controller as a path, including the module, if needed, like:
-      'parent_module/controller_name'.
-
-    Example:
-      `rails generate rest_framework:controller user_api/groups`
-
-      Generates a controller at `app/controllers/user_api/groups_controller.rb` named
-      `UserApi::GroupsController`.
-  END
-
-  argument :path, type: :string
-  class_option(
-    :parent_class, type: :string, default: "ApplicationController", desc: "Inheritance parent"
-  )
-  class_option(
-    :include_base,
-    type: :boolean,
-    default: false,
-    desc: "Include `BaseControllerMixin`, not `ModelControllerMixin`",
-  )
-
-  # 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
-    RESTFrameworkCustomGeneratorControllerNamespace.new("rest_framework:controller")
-  end
-
-  def create_rest_controller_file
-    unless PATH_REGEX.match?(self.path)
-      raise StandardError, "Path isn't valid."
-    end
-
-    # Remove '_controller' from end of path, if it exists.
-    cleaned_path = self.path.delete_suffix("_controller")
-
-    content = <<~END
-      class #{cleaned_path.camelize}Controller < #{options[:parent_class]}
-        include RESTFramework::#{
-          options[:include_base] ? "BaseControllerMixin" : "ModelControllerMixin"
-        }
-      end
-    END
-    create_file("app/controllers/#{cleaned_path}_controller.rb", content)
-  end
-end

data/lib/rest_framework/generators.rb

@@ -1,4 +0,0 @@
-module RESTFramework::Generators
-end
-
-require_relative "generators/controller_generator"

data/lib/rest_framework/mixins/base_controller_mixin.rb

@@ -1,12 +0,0 @@
-module RESTFramework::Mixins::BaseControllerMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "BaseControllerMixin is deprecated; use RESTFramework::Controller instead.",
-    )
-
-    base.include(RESTFramework::Controller)
-  end
-end
-
-# Alias for convenience.
-RESTFramework::BaseControllerMixin = RESTFramework::Mixins::BaseControllerMixin

data/lib/rest_framework/mixins/bulk_model_controller_mixin.rb

@@ -1,55 +0,0 @@
-module RESTFramework::Mixins::BulkCreateModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      BulkCreateModelMixin is deprecated; set the `bulk = true` class attribute instead.
-    TXT
-
-    base.bulk = true
-  end
-end
-
-# Mixin for updating records in bulk.
-module RESTFramework::Mixins::BulkUpdateModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      BulkUpdateModelMixin is deprecated; set the `bulk = true`, and `excluded_actions` class
-      attributes instead.
-    TXT
-
-    base.bulk = true
-    base.excluded_actions = (base.excluded_actions - [ :update_all ]).freeze
-  end
-end
-
-# Mixin for destroying records in bulk.
-module RESTFramework::Mixins::BulkDestroyModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      BulkDestroyModelMixin is deprecated; set the `bulk = true`, and `excluded_actions` class
-      attributes instead.
-    TXT
-
-    base.bulk = true
-    base.excluded_actions = (base.excluded_actions - [ :destroy_all ]).freeze
-  end
-end
-
-# Mixin that includes all the CRUD bulk mixins.
-module RESTFramework::Mixins::BulkModelControllerMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      BulkModelControllerMixin is deprecated; use RESTFramework::Controller and set the `model` and
-      `bulk = true` class attributes instead.
-    TXT
-
-    base.include(RESTFramework::Controller)
-    base.model = RESTFramework::Utils.get_model(base)
-    base.bulk = true
-  end
-end
-
-# Aliases for convenience.
-RESTFramework::BulkCreateModelMixin = RESTFramework::Mixins::BulkCreateModelMixin
-RESTFramework::BulkUpdateModelMixin = RESTFramework::Mixins::BulkUpdateModelMixin
-RESTFramework::BulkDestroyModelMixin = RESTFramework::Mixins::BulkDestroyModelMixin
-RESTFramework::BulkModelControllerMixin = RESTFramework::Mixins::BulkModelControllerMixin