rest_framework 0.9.7 → 0.9.9

data/lib/rest_framework/{controller_mixins/models.rb → mixins/model_controller_mixin.rb}

@@ -1,8 +1,5 @@
-require_relative "base"
-require_relative "../filters"
-
 # This module provides the core functionality for controllers based on models.
-module RESTFramework::BaseModelControllerMixin
+module RESTFramework::Mixins::BaseModelControllerMixin
   BASE64_REGEX = /data:(.*);base64,(.*)/
   BASE64_TRANSLATE = ->(field, value) {
     _, content_type, payload = value.match(BASE64_REGEX).to_a
@@ -552,54 +549,28 @@ module RESTFramework::BaseModelControllerMixin
   alias_method :get_create_params, :get_body_params
   alias_method :get_update_params, :get_body_params
 
-  # Get the set of records this controller has access to. The return value is cached and exposed to
-  # the view as the `@recordset` instance variable.
+  # Get the set of records this controller has access to.
   def get_recordset
-    return @recordset if instance_variable_defined?(:@recordset)
-    return (@recordset = self.class.recordset) if self.class.recordset
+    return self.class.recordset if self.class.recordset
 
     # If there is a model, return that model's default scope (all records by default).
-    if (model = self.class.get_model)
-      return @recordset = model.all
+    if model = self.class.get_model
+      return model.all
     end
 
-    return @recordset = nil
-  end
-
-  # Get the recordset but with any associations included to avoid N+1 queries.
-  def get_recordset_with_includes
-    reflections = self.class.get_model.reflections
-    associations = self.get_fields.map { |f|
-      if reflections.key?(f)
-        f.to_sym
-      elsif reflections.key?("rich_text_#{f}")
-        :"rich_text_#{f}"
-      elsif reflections.key?("#{f}_attachment")
-        :"#{f}_attachment"
-      elsif reflections.key?("#{f}_attachments")
-        :"#{f}_attachments"
-      end
-    }.compact
-
-    if associations.any?
-      return self.get_recordset.includes(associations)
-    end
-
-    return self.get_recordset
+    return nil
   end
 
   # Get the records this controller has access to *after* any filtering is applied.
   def get_records
-    return @records if instance_variable_defined?(:@records)
-
-    return @records = self.get_filtered_data(self.get_recordset_with_includes)
+    return @records ||= self.get_filtered_data(self.get_recordset)
   end
 
   # Get a single record by primary key or another column, if allowed. The return value is cached and
   # exposed to the view as the `@record` instance variable.
   def get_record
     # Cache the result.
-    return @record if instance_variable_defined?(:@record)
+    return @record if @record
 
     recordset = self.get_recordset
     find_by_key = self.class.get_model.primary_key
@@ -661,7 +632,7 @@ module RESTFramework::BaseModelControllerMixin
 end
 
 # Mixin for listing records.
-module RESTFramework::ListModelMixin
+module RESTFramework::Mixins::ListModelMixin
   def index
     return api_response(self.get_index_records)
   end
@@ -689,14 +660,14 @@ module RESTFramework::ListModelMixin
 end
 
 # Mixin for showing records.
-module RESTFramework::ShowModelMixin
+module RESTFramework::Mixins::ShowModelMixin
   def show
     return api_response(self.get_record)
   end
 end
 
 # Mixin for creating records.
-module RESTFramework::CreateModelMixin
+module RESTFramework::Mixins::CreateModelMixin
   def create
     return api_response(self.create!, status: :created)
   end
@@ -708,7 +679,7 @@ module RESTFramework::CreateModelMixin
 end
 
 # Mixin for updating records.
-module RESTFramework::UpdateModelMixin
+module RESTFramework::Mixins::UpdateModelMixin
   def update
     return api_response(self.update!)
   end
@@ -722,7 +693,7 @@ module RESTFramework::UpdateModelMixin
 end
 
 # Mixin for destroying records.
-module RESTFramework::DestroyModelMixin
+module RESTFramework::Mixins::DestroyModelMixin
   def destroy
     self.destroy!
     return api_response("")
@@ -735,11 +706,11 @@ module RESTFramework::DestroyModelMixin
 end
 
 # Mixin that includes show/list mixins.
-module RESTFramework::ReadOnlyModelControllerMixin
-  include RESTFramework::BaseModelControllerMixin
+module RESTFramework::Mixins::ReadOnlyModelControllerMixin
+  include RESTFramework::Mixins::BaseModelControllerMixin
 
-  include RESTFramework::ListModelMixin
-  include RESTFramework::ShowModelMixin
+  include RESTFramework::Mixins::ListModelMixin
+  include RESTFramework::Mixins::ShowModelMixin
 
   def self.included(base)
     RESTFramework::BaseModelControllerMixin.included(base)
@@ -747,16 +718,26 @@ module RESTFramework::ReadOnlyModelControllerMixin
 end
 
 # Mixin that includes all the CRUD mixins.
-module RESTFramework::ModelControllerMixin
-  include RESTFramework::BaseModelControllerMixin
+module RESTFramework::Mixins::ModelControllerMixin
+  include RESTFramework::Mixins::BaseModelControllerMixin
 
-  include RESTFramework::ListModelMixin
-  include RESTFramework::ShowModelMixin
-  include RESTFramework::CreateModelMixin
-  include RESTFramework::UpdateModelMixin
-  include RESTFramework::DestroyModelMixin
+  include RESTFramework::Mixins::ListModelMixin
+  include RESTFramework::Mixins::ShowModelMixin
+  include RESTFramework::Mixins::CreateModelMixin
+  include RESTFramework::Mixins::UpdateModelMixin
+  include RESTFramework::Mixins::DestroyModelMixin
 
   def self.included(base)
     RESTFramework::BaseModelControllerMixin.included(base)
   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

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

data/lib/rest_framework/paginators/base_paginator.rb

@@ -0,0 +1,19 @@
+class RESTFramework::Paginators::BasePaginator
+  def initialize(data:, controller:, **kwargs)
+    @data = data
+    @controller = controller
+  end
+
+  # Get the page and return it so the caller can serialize it.
+  def get_page
+    raise NotImplementedError
+  end
+
+  # Wrap the serialized page with appropriate metadata.
+  def get_paginated_response(serialized_page)
+    raise NotImplementedError
+  end
+end
+
+# Alias for convenience.
+RESTFramework::BasePaginator = RESTFramework::Paginators::BasePaginator

data/lib/rest_framework/paginators/page_number_paginator.rb

@@ -0,0 +1,84 @@
+# A simple paginator based on page numbers.
+#
+# Example: http://example.com/api/users/?page=3&page_size=50
+class RESTFramework::Paginators::PageNumberPaginator < RESTFramework::Paginators::BasePaginator
+  def initialize(**kwargs)
+    super
+    # Exclude any `select` clauses since that would cause `count` to fail with a SQL `SyntaxError`.
+    @count = @data.except(:select).count
+    @page_size = self._page_size
+
+    @total_pages = @count / @page_size
+    @total_pages += 1 if @count % @page_size != 0
+  end
+
+  def _page_size
+    page_size = nil
+
+    # Get from context, if allowed.
+    if @controller.page_size_query_param
+      if page_size = @controller.params[@controller.page_size_query_param].presence
+        page_size = page_size.to_i
+      end
+    end
+
+    # Otherwise, get from config.
+    if !page_size && @controller.page_size
+      page_size = @controller.page_size
+    end
+
+    # Ensure we don't exceed the max page size.
+    if @controller.max_page_size && page_size > @controller.max_page_size
+      page_size = @controller.max_page_size
+    end
+
+    # Ensure we return at least 1.
+    return page_size.zero? ? 1 : page_size
+  end
+
+  # Get the page and return it so the caller can serialize it.
+  def get_page(page_number=nil)
+    # If page number isn't provided, infer from the params or use 1 as a fallback value.
+    unless page_number
+      page_number = @controller&.params&.[](@controller.page_query_param&.to_sym)
+      if page_number.blank?
+        page_number = 1
+      else
+        page_number = page_number.to_i
+        if page_number.zero?
+          page_number = 1
+        end
+      end
+    end
+    @page_number = page_number
+
+    # Get the data page and return it so the caller can serialize the data in the proper format.
+    page_index = @page_number - 1
+    return @data.limit(@page_size).offset(page_index * @page_size)
+  end
+
+  # Wrap the serialized page with appropriate metadata. TODO: include links.
+  def get_paginated_response(serialized_page)
+    page_query_param = @controller.page_query_param
+    base_params = @controller.params.to_unsafe_h
+    next_url = if @page_number < @total_pages
+      @controller.url_for({**base_params, page_query_param => @page_number + 1})
+    end
+    previous_url = if @page_number > 1
+      @controller.url_for({**base_params, page_query_param => @page_number - 1})
+    end
+
+    return {
+      count: @count,
+      page: @page_number,
+      page_size: @page_size,
+      total_pages: @total_pages,
+      next: next_url,
+      previous: previous_url,
+      results: serialized_page,
+    }.compact
+  end
+end
+
+# Alias for convenience.
+RESTFramework::PageNumberPaginator = RESTFramework::Paginators::PageNumberPaginator

data/lib/rest_framework/paginators.rb

@@ -1,90 +1,9 @@
-class RESTFramework::BasePaginator
-  def initialize(data:, controller:, **kwargs)
-    @data = data
-    @controller = controller
-  end
-
-  # Get the page and return it so the caller can serialize it.
-  def get_page
-    raise NotImplementedError
-  end
-
-  # Wrap the serialized page with appropriate metadata.
-  def get_paginated_response(serialized_page)
-    raise NotImplementedError
-  end
+module RESTFramework::Paginators
 end
 
-# A simple paginator based on page numbers.
-#
-# Example: http://example.com/api/users/?page=3&page_size=50
-class RESTFramework::PageNumberPaginator < RESTFramework::BasePaginator
-  def initialize(**kwargs)
-    super
-    # Exclude any `select` clauses since that would cause `count` to fail with a SQL `SyntaxError`.
-    @count = @data.except(:select).count
-    @page_size = self._page_size
-
-    @total_pages = @count / @page_size
-    @total_pages += 1 if @count % @page_size != 0
-  end
-
-  def _page_size
-    page_size = nil
-
-    # Get from context, if allowed.
-    if @controller.page_size_query_param
-      if page_size = @controller.params[@controller.page_size_query_param].presence
-        page_size = page_size.to_i
-      end
-    end
-
-    # Otherwise, get from config.
-    if !page_size && @controller.page_size
-      page_size = @controller.page_size
-    end
+require_relative "paginators/base_paginator"
 
-    # Ensure we don't exceed the max page size.
-    if @controller.max_page_size && page_size > @controller.max_page_size
-      page_size = @controller.max_page_size
-    end
-
-    # Ensure we return at least 1.
-    return page_size.zero? ? 1 : page_size
-  end
-
-  # Get the page and return it so the caller can serialize it.
-  def get_page(page_number=nil)
-    # If page number isn't provided, infer from the params or use 1 as a fallback value.
-    unless page_number
-      page_number = @controller&.params&.[](@controller.page_query_param&.to_sym)
-      if page_number.blank?
-        page_number = 1
-      else
-        page_number = page_number.to_i
-        if page_number.zero?
-          page_number = 1
-        end
-      end
-    end
-    @page_number = page_number
-
-    # Get the data page and return it so the caller can serialize the data in the proper format.
-    page_index = @page_number - 1
-    return @data.limit(@page_size).offset(page_index * @page_size)
-  end
-
-  # Wrap the serialized page with appropriate metadata. TODO: include links.
-  def get_paginated_response(serialized_page)
-    return {
-      count: @count,
-      page: @page_number,
-      page_size: @page_size,
-      total_pages: @total_pages,
-      results: serialized_page,
-    }
-  end
-end
+require_relative "paginators/page_number_paginator"
 
 # TODO: implement this
 # class RESTFramework::CountOffsetPaginator

data/lib/rest_framework/routers.rb

@@ -1,5 +1,4 @@
 require "action_dispatch/routing/mapper"
-require_relative "utils"
 
 module ActionDispatch::Routing
   class Mapper

data/lib/rest_framework/serializers/active_model_serializer_adapter_factory.rb

@@ -0,0 +1,20 @@
+# This is a helper factory to wrap an ActiveModelSerializer to provide a `serialize` method which
+# accepts both collections and individual records. Use `.for` to build adapters.
+class RESTFramework::Serializers::ActiveModelSerializerAdapterFactory
+  def self.for(active_model_serializer)
+    return Class.new(active_model_serializer) do
+      def serialize
+        if self.object.respond_to?(:to_ary)
+          return self.object.map { |r| self.class.superclass.new(r).serializable_hash }
+        end
+
+        return self.serializable_hash
+      end
+    end
+  end
+end
+
+# Alias for convenience.
+# rubocop:disable Layout/LineLength
+RESTFramework::ActiveModelSerializerAdapterFactory = RESTFramework::Serializers::ActiveModelSerializerAdapterFactory
+# rubocop:enable Layout/LineLength

data/lib/rest_framework/serializers/base_serializer.rb

@@ -0,0 +1,40 @@
+# The base serializer defines the interface for all REST Framework serializers.
+class RESTFramework::Serializers::BaseSerializer
+  # Add `object` accessor to be compatible with `ActiveModel::Serializer`.
+  attr_accessor :object
+
+  # Accept/ignore `*args` to be compatible with the `ActiveModel::Serializer#initialize` signature.
+  def initialize(object=nil, *args, controller: nil, **kwargs)
+    @object = object
+    @controller = controller
+  end
+
+  # The primary interface for extracting a native Ruby types. This works both for records and
+  # collections. We accept and ignore `*args` for compatibility with `active_model_serializers`.
+  def serialize(*args)
+    raise NotImplementedError
+  end
+
+  # Synonym for `serialize` for compatibility with `active_model_serializers`.
+  def serializable_hash(*args)
+    return self.serialize(*args)
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def self.fragment_cache_enabled?
+    return false
+  end
+
+  # For compatibility with `active_model_serializers`.
+  def associations(*args, **kwargs)
+    return []
+  end
+end
+
+# Alias for convenience.
+RESTFramework::BaseSerializer = RESTFramework::Serializers::BaseSerializer