rest_framework 0.0.12 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c3691667e86ee77e9d15a1732d0013687a2e63a062a4ff01d1c6d8cc66f45fc
-  data.tar.gz: 6bcab926c283feb9a0643a06eab750f941882e5b56b294c59794f64a966883bb
+  metadata.gz: 46db4e7aa05600caaa4c1f9f645f417b4d3cd9e5bcde7da0b54d3c5fa84e872e
+  data.tar.gz: 95c9d018b687795f80c38b43289f19ffd44eb1b170d883c164b590ab6b1c20d0
 SHA512:
-  metadata.gz: 204e0b5ea7b46710968a6274791f9e0f676db34f4eaefa1cf831fe8f9e4ab1f076a24b0375ef0554e1c4b57db3d1787adeebc31c4201da40b504aded51ca097b
-  data.tar.gz: 7e46ed5bbe61832045207664d679ecf394aead2928cdd78a1b29873087b78130546fd80595fe443680d5c26eebfa8bf5f23246b56a9a4a83e801c7763c024c76
+  metadata.gz: 2c376d191ffa5ae9de932dceb8411362a00be789ff9aa3733f038608da890fc5437d981576e3b17d402b857f7966cb15e437d7cbe2c8447191088a9a2249134f
+  data.tar.gz: 72e31acb2e66c6d8d2af2dd7375e7732a93b5e66b1c1fedf4c1d781421422c582958d32c6022305cd9cc2ca9dda51e2c2f6c540b1737e11eb3506501ef91b618

data/README.md

@@ -116,18 +116,6 @@ To run the full test suite:
 $ rake test
 ```
 
-To run unit tests:
-
-```shell
-$ rake test:unit
-```
-
-To run integration tests:
-
-```shell
-$ rake test:integration
-```
-
-To interact with the integration app, you can `cd test/integration` and operate it via the normal
-Rails interfaces. Ensure you run `rake db:schema:load` before running `rails server` or
-`rails console`.
+To interact with the test app, `cd test` and operate it via the normal Rails interfaces. Ensure you
+run `rake db:schema:load` before running `rails server` or `rails console`. You can also load the
+test fixtures with `rake db:fixtures:load`.

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

@@ -30,14 +30,14 @@
                 <% if @json_payload %>
                   <li class="nav-item">
                     <a class="nav-link active" href="#tab-json" data-toggle="tab" role="tab">
-                      JSON
+                      .json
                     </a>
                   </li>
                 <% end %>
                 <% if @xml_payload %>
                   <li class="nav-item">
                     <a class="nav-link" href="#tab-xml" data-toggle="tab" role="tab">
-                      XML
+                      .xml
                     </a>
                   </li>
                 <% end %>

data/lib/rest_framework.rb

@@ -3,5 +3,8 @@ end
 
 require_relative "rest_framework/controller_mixins"
 require_relative "rest_framework/engine"
+require_relative "rest_framework/filters"
+require_relative "rest_framework/paginators"
 require_relative "rest_framework/routers"
+require_relative "rest_framework/serializers"
 require_relative "rest_framework/version"

data/lib/rest_framework/VERSION_STAMP

@@ -1 +1 @@
-0.0.12
+0.1.0

data/lib/rest_framework/controller_mixins/base.rb

@@ -1,3 +1,5 @@
+require_relative '../serializers'
+
 module RESTFramework
 
   # This module provides the common functionality for any controller mixins, a `root` action, and
@@ -28,12 +30,40 @@ module RESTFramework
     def self.included(base)
       if base.is_a? Class
         base.extend ClassMethods
-        base.class_attribute(*[
-          :singleton_controller,
-          :extra_actions,
-          :skip_actions,
-          :paginator_class,
-        ])
+
+        # Add class attributes (with defaults) unless they already exist.
+        {
+          extra_actions: nil,
+          extra_member_actions: nil,
+          filter_backends: nil,
+          paginator_class: nil,
+          page_size: nil,
+          page_query_param: 'page',
+          page_size_query_param: 'page_size',
+          max_page_size: nil,
+          serializer_class: nil,
+          singleton_controller: nil,
+          skip_actions: nil,
+        }.each do |a, default|
+          unless base.respond_to?(a)
+            base.class_attribute(a)
+
+            # Set default manually so we can still support Rails 4. Maybe later we can use the
+            # default parameter on `class_attribute`.
+            base.send(:"#{a}=", default)
+          end
+        end
+
+        # Alias `extra_actions` to `extra_collection_actions`.
+        unless base.respond_to?(:extra_collection_actions)
+          base.alias_method(:extra_collection_actions, :extra_actions)
+          base.alias_method(:extra_collection_actions=, :extra_actions=)
+        end
+
+        # skip csrf since this is an API
+        base.skip_before_action(:verify_authenticity_token) rescue nil
+
+        # handle some common exceptions
         base.rescue_from(ActiveRecord::RecordNotFound, with: :record_not_found)
         base.rescue_from(ActiveRecord::RecordInvalid, with: :record_invalid)
         base.rescue_from(ActiveRecord::RecordNotSaved, with: :record_not_saved)
@@ -43,6 +73,40 @@ module RESTFramework
 
     protected
 
+    # Helper to get filtering backends with a sane default.
+    def get_filter_backends
+      return self.class.filter_backends || []
+    end
+
+    # Filter the recordset over all configured filter backends.
+    def get_filtered_data(data)
+      self.get_filter_backends.each do |filter_class|
+        filter = filter_class.new(controller: self)
+        data = filter.get_filtered_data(data)
+      end
+
+      return data
+    end
+
+    # Helper to get the configured serializer class.
+    def get_serializer_class
+      return self.class.serializer_class
+    end
+
+    # Get a native serializer config for the current action.
+    def get_native_serializer_config
+      action_serializer_config = self.class.native_serializer_action_config || {}
+      action = self.action_name.to_sym
+
+      # Handle case where :index action is not defined.
+      if action == :index && !action_serializer_config.key?(:index)
+        # Default is :show if `singleton_controller`, otherwise :list.
+        action = self.class.singleton_controller ? :show : :list
+      end
+
+      return (action_serializer_config[action] if action) || self.class.native_serializer_config
+    end
+
     def record_invalid(e)
       return api_response(
         {message: "Record invalid.", exception: e, errors: e.record.errors}, status: 400
@@ -61,6 +125,7 @@ module RESTFramework
       return api_response({message: "Record not destroyed.", exception: e}, status: 406)
     end
 
+    # Helper for showing routes under a controller action, used for the browsable API.
     def _get_routes
       begin
         formatter = ActionDispatch::Routing::ConsoleFormatter::Sheet
@@ -69,14 +134,14 @@ module RESTFramework
       end
       return ActionDispatch::Routing::RoutesInspector.new(Rails.application.routes.routes).format(
         formatter.new
-      ).lines[1..].map { |r| r.split.last(3) }.map { |r|
+      ).lines.drop(1).map { |r| r.split.last(3) }.map { |r|
         {verb: r[0], path: r[1], action: r[2]}
       }.select { |r| r[:path].start_with?(request.path) }
     end
 
     # Helper alias for `respond_to`/`render`. `payload` should be already serialized to Ruby
     # primitives.
-    def api_response(payload=nil, html_kwargs: nil, json_kwargs: nil, xml_kwargs: nil, **kwargs)
+    def api_response(payload, html_kwargs: nil, json_kwargs: nil, xml_kwargs: nil, **kwargs)
       html_kwargs ||= {}
       json_kwargs ||= {}
       xml_kwargs ||= {}
@@ -119,8 +184,8 @@ module RESTFramework
           rescue ActionView::MissingTemplate  # fallback to rest_framework layout/view
             kwargs[:layout] = "rest_framework"
             kwargs[:template] = "rest_framework/default"
+            render(**kwargs)
           end
-          render(**kwargs)
         }
       end
     end

data/lib/rest_framework/controller_mixins/models.rb

@@ -1,5 +1,5 @@
 require_relative 'base'
-require_relative '../serializers'
+require_relative '../filters'
 
 module RESTFramework
 
@@ -8,95 +8,94 @@ module RESTFramework
     def self.included(base)
       if base.is_a? Class
         BaseControllerMixin.included(base)
-        base.class_attribute(*[
-          :model,
-          :recordset,
-          :fields,
-          :action_fields,
-          :native_serializer_config,
-          :native_serializer_action_config,
-          :filterset_fields,
-          :allowed_parameters,
-          :allowed_action_parameters,
-          :serializer_class,
-          :extra_member_actions,
-        ])
-        base.alias_method(:extra_collection_actions=, :extra_actions=)
+
+        # Add class attributes (with defaults) unless they already exist.
+        {
+          # Core attributes related to models.
+          model: nil,
+          recordset: nil,
+
+          # Attributes for create/update parameters.
+          allowed_parameters: nil,
+          allowed_action_parameters: nil,
+
+          # Attributes for configuring record fields.
+          fields: nil,
+          action_fields: nil,
+
+          # Attributes for the default native serializer.
+          native_serializer_config: nil,
+          native_serializer_action_config: nil,
+
+          # Attributes for default model filtering (and ordering).
+          filterset_fields: nil,
+          ordering_fields: nil,
+          ordering_query_param: 'ordering',
+
+          # Other misc attributes.
+          disable_creation_from_recordset: nil,  # Option to disable `recordset.create` behavior.
+        }.each do |a, default|
+          unless base.respond_to?(a)
+            base.class_attribute(a)
+
+            # Set default manually so we can still support Rails 4. Maybe later we can use the
+            # default parameter on `class_attribute`.
+            base.send(:"#{a}=", default)
+          end
+        end
       end
     end
 
     protected
 
+    # Helper to get the configured serializer class, or `NativeModelSerializer` as a default.
     def get_serializer_class
-      return self.class.serializer_class || NativeModelSerializer
+      return self.class.serializer_class || RESTFramework::NativeModelSerializer
     end
 
-    # Get a list of fields for the current action.
-    def get_fields
-      action_fields = self.class.action_fields || {}
+    # Get a list of parameters allowed for the current action.
+    def get_allowed_parameters
+      allowed_action_parameters = self.class.allowed_action_parameters || {}
       action = self.action_name.to_sym
 
-      # index action should use :list fields if :index is not provided
-      action = :list if action == :index && !action_fields.key?(:index)
+      # index action should use :list allowed parameters if :index is not provided
+      action = :list if action == :index && !allowed_action_parameters.key?(:index)
 
-      return (action_fields[action] if action) || self.class.fields || []
+      return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
     end
 
-    # Get a native serializer config for the current action.
-    def get_native_serializer_config
-      action_serializer_config = self.class.native_serializer_action_config || {}
-      action = self.action_name.to_sym
-
-      # index action should use :list serializer config if :index is not provided
-      action = :list if action == :index && !action_serializer_config.key?(:index)
-
-      return (action_serializer_config[action] if action) || self.class.native_serializer_config
+    # Get the list of filtering backends to use.
+    def get_filter_backends
+      return self.class.filter_backends || [
+        RESTFramework::ModelFilter, RESTFramework::ModelOrderingFilter
+      ]
     end
 
-    # Get a list of parameters allowed for the current action.
-    def get_allowed_parameters
-      allowed_action_parameters = self.class.allowed_action_parameters || {}
+    # Get a list of fields for the current action.
+    def get_fields
+      action_fields = self.class.action_fields || {}
       action = self.action_name.to_sym
 
-      # index action should use :list allowed parameters if :index is not provided
-      action = :list if action == :index && !allowed_action_parameters.key?(:index)
+      # index action should use :list fields if :index is not provided
+      action = :list if action == :index && !action_fields.key?(:index)
 
-      return (allowed_action_parameters[action] if action) || self.class.allowed_parameters
+      return (action_fields[action] if action) || self.class.fields || []
     end
 
     # Filter the request body for keys in current action's allowed_parameters/fields config.
-    def _get_parameter_values_from_request_body
+    def get_body_params
       fields = self.get_allowed_parameters || self.get_fields
-      return @_get_parameter_values_from_request_body ||= (request.request_parameters.select { |p|
+      return @get_body_params ||= (request.request_parameters.select { |p|
         fields.include?(p.to_sym) || fields.include?(p.to_s)
       })
     end
-    alias :get_create_params :_get_parameter_values_from_request_body
-    alias :get_update_params :_get_parameter_values_from_request_body
-
-    # Filter params for keys allowed by the current action's filterset_fields/fields config.
-    def _get_filterset_values_from_params
-      fields = self.filterset_fields || self.get_fields
-      return @_get_filterset_values_from_params ||= request.query_parameters.select { |p|
-        fields.include?(p.to_sym) || fields.include?(p.to_s)
-      }
-    end
-    alias :get_lookup_params :_get_filterset_values_from_params
-    alias :get_filter_params :_get_filterset_values_from_params
-
-    # Get the recordset, filtered by the filter params.
-    def get_filtered_recordset
-      filter_params = self.get_filter_params
-      unless filter_params.blank?
-        return self.get_recordset.where(**self.get_filter_params.to_hash.symbolize_keys)
-      end
-      return self.get_recordset
-    end
+    alias :get_create_params :get_body_params
+    alias :get_update_params :get_body_params
 
     # Get a record by `id` or return a single record if recordset is filtered down to a single
     # record.
     def get_record
-      records = self.get_filtered_recordset
+      records = self.get_filtered_data(self.get_recordset)
       if params['id']  # direct lookup
         return records.find(params['id'])
       elsif records.length == 1
@@ -143,33 +142,42 @@ module RESTFramework
   end
 
   module ListModelMixin
-    # TODO: pagination classes like Django
     def index
-      @records = self.get_filtered_recordset
-      @serialized_records = self.get_serializer_class.new(
-        object: @records, controller: self
-      ).serialize
-      return api_response(@serialized_records)
+      @records = self.get_filtered_data(self.get_recordset)
+
+      # Handle pagination, if enabled.
+      if self.class.paginator_class
+        paginator = self.class.paginator_class.new(data: @records, controller: self)
+        page = paginator.get_page
+        serialized_page = self.get_serializer_class.new(object: page, controller: self).serialize
+        data = paginator.get_paginated_response(serialized_page)
+      else
+        data = self.get_serializer_class.new(object: @records, controller: self).serialize
+      end
+
+      return api_response(data)
     end
   end
 
   module ShowModelMixin
     def show
       @record = self.get_record
-      @serialized_record = self.get_serializer_class.new(
-        object: @record, controller: self
-      ).serialize
-      return api_response(@serialized_record)
+      serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
+      return api_response(serialized_record)
     end
   end
 
   module CreateModelMixin
     def create
-      @record = self.get_model.create!(self.get_create_params)
-      @serialized_record = self.get_serializer_class.new(
-        object: @record, controller: self
-      ).serialize
-      return api_response(@serialized_record)
+      if self.get_recordset.respond_to?(:create!) && !self.disable_creation_from_recordset
+        # Create with any properties inherited from the recordset (like associations).
+        @record = self.get_recordset.create!(self.get_create_params)
+      else
+        # Otherwise, perform a "bare" create.
+        @record = self.get_model.create!(self.get_create_params)
+      end
+      serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
+      return api_response(serialized_record)
     end
   end
 
@@ -177,10 +185,8 @@ module RESTFramework
     def update
       @record = self.get_record
       @record.update!(self.get_update_params)
-      @serialized_record = self.get_serializer_class.new(
-        object: @record, controller: self
-      ).serialize
-      return api_response(@serialized_record)
+      serialized_record = self.get_serializer_class.new(object: @record, controller: self).serialize
+      return api_response(serialized_record)
     end
   end
 

data/lib/rest_framework/filters.rb

@@ -0,0 +1,65 @@
+module RESTFramework
+  class BaseFilter
+    def initialize(controller:)
+      @controller = controller
+    end
+
+    def get_filtered_data(data)
+      raise NotImplementedError
+    end
+  end
+
+  # A simple filtering backend that supports filtering a recordset based on fields defined on the
+  # controller class.
+  class ModelFilter < BaseFilter
+    # Filter params for keys allowed by the current action's filterset_fields/fields config.
+    def _get_filter_params
+      fields = @controller.class.filterset_fields || @controller.send(:get_fields)
+      return @controller.request.query_parameters.select { |p|
+        fields.include?(p.to_sym) || fields.include?(p.to_s)
+      }.to_hash.symbolize_keys
+    end
+
+    def get_filtered_data(data)
+      filter_params = self._get_filter_params
+      unless filter_params.blank?
+        return data.where(**filter_params)
+      end
+
+      return data
+    end
+  end
+
+  # A filter backend which handles ordering of the recordset.
+  class ModelOrderingFilter < BaseFilter
+    # Convert ordering string to an ordering configuration.
+    def _get_ordering
+      return nil unless @controller.class.ordering_query_param
+
+      order_string = @controller.params[@controller.class.ordering_query_param]
+      unless order_string.blank?
+        return order_string.split(',').map { |field|
+          if field[0] == '-'
+            [field[1..-1].to_sym, :desc]
+          else
+            [field.to_sym, :asc]
+          end
+        }.to_h
+      end
+
+      return nil
+    end
+
+    def get_filtered_data(data)
+      ordering = self._get_ordering
+      if ordering && !ordering.empty?
+        return data.order(_get_ordering)
+      end
+      return data
+    end
+  end
+
+  # TODO: implement searching within fields rather than exact match filtering (ModelFilter)
+  # class ModelSearchFilter < BaseFilter
+  # end
+end

data/lib/rest_framework/paginators.rb

@@ -0,0 +1,84 @@
+module RESTFramework
+
+  # A simple paginator based on page numbers.
+  #
+  # Example: http://example.com/api/users/?page=3&page_size=50
+  class PageNumberPaginator
+    def initialize(data:, controller:, **kwargs)
+      @data = data
+      @controller = controller
+      @count = data.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.class.page_size_query_param
+        page_size = @controller.params[@controller.class.page_size_query_param].presence
+        if page_size
+          page_size = page_size.to_i
+        end
+      end
+
+      # Otherwise, get from config.
+      if !page_size && @controller.class.page_size
+        page_size = @controller.class.page_size
+      end
+
+      # Fallback to a page size of 15.
+      page_size = 15 unless page_size
+
+      # Ensure we don't exceed the max page size.
+      if @controller.class.max_page_size && page_size > @controller.class.max_page_size
+        page_size = @controller.class.max_page_size
+      end
+
+      # Ensure we return at least 1.
+      return page_size.zero? ? 1 : page_size
+    end
+
+    def _page_query_param
+      return @controller.class.page_query_param&.to_sym
+    end
+
+    def get_page(page_number=nil)
+      # If page number isn't provided, infer from the params or use 1 as a fallback value.
+      if !page_number
+        page_number = @controller&.params&.[](self._page_query_param)
+        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 appripriate metadata.
+    def get_paginated_response(serialized_page)
+      return {
+        count: @count,
+        page: @page_number,
+        total_pages: @total_pages,
+        results: serialized_page,
+      }
+    end
+  end
+
+  # TODO: implement this
+  # class CountOffsetPaginator
+  # end
+
+end

data/lib/rest_framework/routers.rb

@@ -2,6 +2,41 @@ require 'action_dispatch/routing/mapper'
 
 module ActionDispatch::Routing
   class Mapper
+    # Helper to take extra_actions hash and convert to a consistent format.
+    protected def _parse_extra_actions(extra_actions)
+      return (extra_actions || {}).map do |k,v|
+        kwargs = {}
+        path = k
+
+        # Convert structure to path/methods/kwargs.
+        if v.is_a?(Hash)  # allow kwargs
+          v = v.symbolize_keys
+
+          # Ensure methods is an array.
+          if v[:methods].is_a?(String) || v[:methods].is_a?(Symbol)
+            methods = [v.delete(:methods)]
+          else
+            methods = v.delete(:methods)
+          end
+
+          # Override path if it's provided.
+          if v.key?(:path)
+            path = v.delete(:path)
+          end
+
+          # Pass any further kwargs to the underlying Rails interface.
+          kwargs = kwargs.merge(v)
+        elsif v.is_a?(Symbol) || v.is_a?(String)
+          methods = [v]
+        else
+          methods = v
+        end
+
+        # Return a hash with keys: :path, :methods, :kwargs.
+        {path: path, methods: methods, kwargs: kwargs}
+      end
+    end
+
     # Private interface to get the controller class from the name and current scope.
     protected def _get_controller_class(name, pluralize: true, fallback_reverse_pluralization: true)
       # get class name
@@ -40,16 +75,16 @@ module ActionDispatch::Routing
     # @param default_singular [Boolean] the default plurality of the resource if the plurality is
     #   not otherwise defined by the controller
     # @param name [Symbol] the resource name, from which path and controller are deduced by default
-    # @param skip_undefined [Boolean] whether we should skip routing undefined actions
+    # @param skip_undefined [Boolean] whether we should skip routing undefined resourceful actions
     protected def _rest_resources(default_singular, name, skip_undefined: true, **kwargs, &block)
-      controller = kwargs[:controller] || name
+      controller = kwargs.delete(:controller) || name
       if controller.is_a?(Class)
         controller_class = controller
       else
         controller_class = _get_controller_class(controller, pluralize: !default_singular)
       end
 
-      # set controller if it's not explicitly set
+      # Set controller if it's not explicitly set.
       kwargs[:controller] = name unless kwargs[:controller]
 
       # determine plural/singular resource
@@ -70,25 +105,20 @@ module ActionDispatch::Routing
       public_send(resource_method, name, except: skip, **kwargs) do
         if controller_class.respond_to?(:extra_member_actions)
           member do
-            actions = controller_class.extra_member_actions || {}
-            actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
-            actions.each do |action, methods|
-              methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
-              methods.each do |m|
-                public_send(m, action)
+            actions = self._parse_extra_actions(controller_class.extra_member_actions)
+            actions.each do |action_config|
+              action_config[:methods].each do |m|
+                public_send(m, action_config[:path], **action_config[:kwargs])
               end
             end
           end
         end
 
         collection do
-          actions = controller_class.extra_actions || {}
-          actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
-          actions.reject! { |k,v| skip.include? k }
-          actions.each do |action, methods|
-            methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
-            methods.each do |m|
-              public_send(m, action)
+          actions = self._parse_extra_actions(controller_class.extra_actions)
+          actions.each do |action_config|
+            action_config[:methods].each do |m|
+              public_send(m, action_config[:path], **action_config[:kwargs])
             end
           end
         end
@@ -112,42 +142,55 @@ module ActionDispatch::Routing
     end
 
     # Route a controller without the default resourceful paths.
-    def rest_route(path=nil, skip_undefined: true, **kwargs, &block)
-      controller = kwargs.delete(:controller) || path
-      path = path.to_s
+    def rest_route(name=nil, **kwargs, &block)
+      controller = kwargs.delete(:controller) || name
+      if controller.is_a?(Class)
+        controller_class = controller
+      else
+        controller_class = self._get_controller_class(controller, pluralize: false)
+      end
 
-      # route actions
-      controller_class = self._get_controller_class(controller, pluralize: false)
-      skip = controller_class.get_skip_actions(skip_undefined: skip_undefined)
-      actions = controller_class.extra_actions || {}
-      actions = actions.select { |k,v| controller_class.method_defined?(k) } if skip_undefined
-      actions.reject! { |k,v| skip.include? k }
-      actions.each do |action, methods|
-        methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
-        methods.each do |m|
-          public_send(m, File.join(path, action.to_s), controller: controller, action: action)
+      # Set controller if it's not explicitly set.
+      kwargs[:controller] = name unless kwargs[:controller]
+
+      # Route actions using the resourceful router, but skip all builtin actions.
+      actions = self._parse_extra_actions(controller_class.extra_actions)
+      public_send(:resource, name, only: [], **kwargs) do
+        actions.each do |action_config|
+          action_config[:methods].each do |m|
+            public_send(m, action_config[:path], **action_config[:kwargs])
+          end
+          yield if block_given?
         end
-        yield if block_given?
       end
     end
 
     # Route a controller's `#root` to '/' in the current scope/namespace, along with other actions.
     # @param label [Symbol] the snake_case name of the controller
-    def rest_root(path=nil, **kwargs, &block)
-      # by default, use RootController#root
+    def rest_root(name=nil, **kwargs, &block)
+      # By default, use RootController#root.
       root_action = kwargs.delete(:action) || :root
-      controller = kwargs.delete(:controller) || path || :root
-      path = path.to_s
+      controller = kwargs.delete(:controller) || name || :root
 
-      # route the root
-      get path, controller: controller, action: root_action
+      # Route the root.
+      get name.to_s, controller: controller, action: root_action
 
-      # route any additional actions
+      # Route any additional actions.
       controller_class = self._get_controller_class(controller, pluralize: false)
-      (controller_class.extra_actions || {}).each do |action, methods|
-        methods = [methods] if methods.is_a?(Symbol) || methods.is_a?(String)
-        methods.each do |m|
-          public_send(m, File.join(path, action.to_s), controller: controller, action: action)
+      actions = self._parse_extra_actions(controller_class.extra_actions)
+      actions.each do |action_config|
+        # Add :action unless kwargs defines it.
+        unless action_config[:kwargs].key?(:action)
+          action_config[:kwargs][:action] = action_config[:path]
+        end
+
+        action_config[:methods].each do |m|
+          public_send(
+            m,
+            File.join(name.to_s, action_config[:path].to_s),
+            controller: controller,
+            **action_config[:kwargs],
+          )
         end
         yield if block_given?
       end

data/lib/rest_framework/serializers.rb

@@ -2,25 +2,30 @@ module RESTFramework
   class BaseSerializer
     attr_reader :errors
 
-    def initialize(object: nil, data: nil, controller: nil, **kwargs)
+    def initialize(object: nil, controller: nil, **kwargs)
       @object = object
-      @data = data
       @controller = controller
     end
   end
 
-  # This serializer uses `.as_json` to serialize objects. Despite the name, `.as_json` is a Rails
-  # method which converts objects to Ruby primitives (with the top-level being either an array or a
-  # hash).
+  # This serializer uses `.as_json` to serialize objects. Despite the name, `.as_json` is an
+  # `ActiveModel` method which converts objects to Ruby primitives (with the top-level being either
+  # an array or a hash).
   class NativeModelSerializer < BaseSerializer
     class_attribute :config
     class_attribute :singular_config
     class_attribute :plural_config
     class_attribute :action_config
 
-    def initialize(model: nil, many: nil, **kwargs)
+    def initialize(many: nil, model: nil, **kwargs)
       super(**kwargs)
-      @many = many
+
+      if many.nil?
+        @many = @object.respond_to?(:count) ? @object.count : nil
+      else
+        @many = many
+      end
+
       @model = model || (@controller ? @controller.send(:get_model) : nil)
     end
 
@@ -34,32 +39,34 @@ module RESTFramework
       action = self.get_action
 
       if action && self.action_config
-        # index action should use :list serializer config if :index is not provided
+        # Index action should use :list serializer config if :index is not provided.
         action = :list if action == :index && !self.action_config.key?(:index)
 
         return self.action_config[action] if self.action_config[action]
       end
 
-      # no action_config, so try singular/plural config
+      # No action_config, so try singular/plural config.
       return self.plural_config if @many && self.plural_config
       return self.singular_config if !@many && self.singular_config
 
-      # lastly, try the default config
+      # Lastly, try returning the default config.
       return self.config
     end
 
-    # Get a configuration passable to `as_json` for the model.
+    # Get a configuration passable to `as_json` for the object.
     def get_serializer_config
-      # return a locally defined serializer config if one is defined
-      local_config = self.get_local_serializer_config
-      return local_config if local_config
+      # Return a locally defined serializer config if one is defined.
+      if local_config = self.get_local_serializer_config
+        return local_config
+      end
 
-      # return a serializer config if one is defined
-      serializer_config = @controller.send(:get_native_serializer_config)
-      return serializer_config if serializer_config
+      # Return a serializer config if one is defined.
+      if serializer_config = @controller.send(:get_native_serializer_config)
+        return serializer_config
+      end
 
-      # otherwise, build a serializer config from fields
-      fields = @controller.send(:get_fields) if @controller
+      # If the config wasn't determined, build a serializer config from model fields.
+      fields = @controller.try(:get_fields) if @controller
       unless fields.blank?
         columns, methods = fields.partition { |f| f.to_s.in?(@model.column_names) }
         return {only: columns, methods: methods}
@@ -68,7 +75,7 @@ module RESTFramework
       return {}
     end
 
-    # Convert the object(s) to Ruby primitives.
+    # Convert the object (record or recordset) to Ruby primitives.
     def serialize
       if @object
         @many = @object.respond_to?(:each) if @many.nil?
@@ -105,4 +112,5 @@ module RESTFramework
       return @_nested_config[key] = value
     end
   end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.0
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-09 00:00:00.000000000 Z
+date: 2021-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,14 +43,16 @@ files:
 - lib/rest_framework/controller_mixins/base.rb
 - lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
+- lib/rest_framework/filters.rb
+- lib/rest_framework/paginators.rb
 - lib/rest_framework/routers.rb
 - lib/rest_framework/serializers.rb
 - lib/rest_framework/version.rb
-homepage: https://github.com/gregschmit/rails-rest-framework
+homepage: https://rails-rest-framework.com
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/gregschmit/rails-rest-framework
+  homepage_uri: https://rails-rest-framework.com
   source_code_uri: https://github.com/gregschmit/rails-rest-framework
 post_install_message:
 rdoc_options: []
@@ -68,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.9
 signing_key:
 specification_version: 4
 summary: A framework for DRY RESTful APIs in Ruby on Rails.