rest_framework 1.2.0 → 2.0.0.beta2

data/lib/rest_framework/serializers/native_serializer.rb

@@ -111,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)
-
-    limit = @controller&.class&.native_serializer_associations_limit
-
-    # 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
+  # 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
+
+    default = field_config.key?(:limit) ?
+      field_config[:limit] : controller&.association_limit
+    return default unless controller&.enable_association_queries
+
+    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.
@@ -158,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
@@ -169,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)
@@ -181,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
@@ -190,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,59 +1,6 @@
 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
@@ -172,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) }
@@ -208,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" ]
@@ -243,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)
@@ -251,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
@@ -188,8 +160,6 @@ module RESTFramework
 
     def initialize
       self.register_api_renderer = true
-      self.auto_finalize = true
-      self.freeze_config = true
 
       self.show_backtrace = Rails.env.development?
 
@@ -221,7 +191,6 @@ end
 require_relative "rest_framework/engine"
 require_relative "rest_framework/errors"
 require_relative "rest_framework/filters"
-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.2.0
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-22 00:00:00.000000000 Z
+date: 2026-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -55,6 +55,7 @@ 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
@@ -66,10 +67,6 @@ files:
 - lib/rest_framework/filters/query_filter.rb
 - lib/rest_framework/filters/ransack_filter.rb
 - lib/rest_framework/filters/search_filter.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
@@ -101,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/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

data/lib/rest_framework/mixins/model_controller_mixin.rb

@@ -1,110 +0,0 @@
-module RESTFramework::Mixins::BaseModelControllerMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      BaseModelControllerMixin is deprecated; use RESTFramework::Controller and set the `model` and
-      `excluded_actions` class attributes instead.
-    TXT
-
-    base.include(RESTFramework::Controller)
-    base.model = RESTFramework::Utils.get_model(base)
-    base.excluded_actions = [
-      :index, :show, :create, :update, :destroy, :update_all, :destroy_all
-    ].freeze
-  end
-end
-
-module RESTFramework::Mixins::ListModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "ListModelMixin is deprecated; set the `excluded_actions` class attribute instead.",
-    )
-
-    if base.excluded_actions
-      base.excluded_actions = (base.excluded_actions - [ :index ]).freeze
-    end
-  end
-end
-
-module RESTFramework::Mixins::ShowModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "ShowModelMixin is deprecated; set the `excluded_actions` class attribute instead.",
-    )
-
-    if base.excluded_actions
-      base.excluded_actions = (base.excluded_actions - [ :show ]).freeze
-    end
-  end
-end
-
-module RESTFramework::Mixins::CreateModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "CreateModelMixin is deprecated; set the `excluded_actions` class attribute instead.",
-    )
-
-    if base.excluded_actions
-      base.excluded_actions = (base.excluded_actions - [ :create ]).freeze
-    end
-  end
-end
-
-module RESTFramework::Mixins::UpdateModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "UpdateModelMixin is deprecated; set the `excluded_actions` class attribute instead.",
-    )
-
-    if base.excluded_actions
-      base.excluded_actions = (base.excluded_actions - [ :update ]).freeze
-    end
-  end
-end
-
-module RESTFramework::Mixins::DestroyModelMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(
-      "DestroyModelMixin is deprecated; set the `excluded_actions` class attribute instead.",
-    )
-
-    if base.excluded_actions
-      base.excluded_actions = (base.excluded_actions - [ :destroy ]).freeze
-    end
-  end
-end
-
-module RESTFramework::Mixins::ReadOnlyModelControllerMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      ReadOnlyModelControllerMixin is deprecated; use RESTFramework::Controller and set the `model`
-      and `excluded_actions` class attributes instead.
-    TXT
-
-    base.include(RESTFramework::Controller)
-    base.model = RESTFramework::Utils.get_model(base)
-    base.excluded_actions = [ :create, :update, :destroy, :update_all, :destroy_all ].freeze
-  end
-end
-
-module RESTFramework::Mixins::ModelControllerMixin
-  def self.included(base)
-    RESTFramework.deprecator.warn(<<~TXT).squish
-      ModelControllerMixin is deprecated; use RESTFramework::Controller and set the `model` class
-      attribute instead.
-    TXT
-
-    base.include(RESTFramework::Controller)
-    base.model = RESTFramework::Utils.get_model(base)
-    base.excluded_actions = nil
-  end
-end
-
-# Aliases for convenience.
-RESTFramework::BaseModelControllerMixin = RESTFramework::Mixins::BaseModelControllerMixin
-RESTFramework::ListModelMixin = RESTFramework::Mixins::ListModelMixin
-RESTFramework::ShowModelMixin = RESTFramework::Mixins::ShowModelMixin
-RESTFramework::CreateModelMixin = RESTFramework::Mixins::CreateModelMixin
-RESTFramework::UpdateModelMixin = RESTFramework::Mixins::UpdateModelMixin
-RESTFramework::DestroyModelMixin = RESTFramework::Mixins::DestroyModelMixin
-RESTFramework::ReadOnlyModelControllerMixin = RESTFramework::Mixins::ReadOnlyModelControllerMixin
-RESTFramework::ModelControllerMixin = RESTFramework::Mixins::ModelControllerMixin

data/lib/rest_framework/mixins.rb

@@ -1,7 +0,0 @@
-module RESTFramework::Mixins
-end
-
-require_relative "mixins/base_controller_mixin"
-
-require_relative "mixins/bulk_model_controller_mixin"
-require_relative "mixins/model_controller_mixin"