rest_framework 0.0.16 → 0.2.1

data/lib/rest_framework/serializers.rb

@@ -1,125 +1,163 @@
-module RESTFramework
-  class BaseSerializer
-    attr_reader :errors
+class RESTFramework::BaseSerializer
+  def initialize(object: nil, controller: nil, **kwargs)
+    @object = object
+    @controller = controller
+  end
 
-    def initialize(object: nil, controller: nil, **kwargs)
-      @object = object
-      @controller = controller
-    end
+  def serialize
+    raise NotImplementedError
   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).
-  class NativeSerializer < BaseSerializer
-    class_attribute :config
-    class_attribute :singular_config
-    class_attribute :plural_config
-    class_attribute :action_config
-
-    def initialize(many: nil, **kwargs)
-      super(**kwargs)
-      @many = many
-    end
 
-    # Get controller action, if possible.
-    def get_action
-      return @controller&.action_name&.to_sym
+# This serializer uses `.serializable_hash` to convert objects to Ruby primitives (with the
+# top-level being either an array or a hash).
+class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
+  class_attribute :config
+  class_attribute :singular_config
+  class_attribute :plural_config
+  class_attribute :action_config
+
+  def initialize(many: nil, model: nil, **kwargs)
+    super(**kwargs)
+
+    if many.nil?
+      # Determine if we are dealing with many objects or just one.
+      @many = @object.is_a?(Enumerable)
+    else
+      @many = many
     end
 
-    # Get a locally defined configuration, if one is defined.
-    def get_local_serializer_config
-      action = self.get_action
+    # 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[0].is_a?(ActiveRecord::Base)
+    @model ||= @controller.send(:get_model) if @controller
+  end
 
-      if action && self.action_config
-        # Index action should use :list serializer config if :index is not provided.
-        action = :list if action == :index && !self.action_config.key?(:index)
+  # Get controller action, if possible.
+  def get_action
+    return @controller&.action_name&.to_sym
+  end
 
-        return self.action_config[action] if self.action_config[action]
-      end
+  # Get a locally defined native serializer configuration, if one is defined.
+  def get_local_native_serializer_config
+    action = self.get_action
 
-      # 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
+    if action && self.action_config
+      # Index action should use :list serializer config if :index is not provided.
+      action = :list if action == :index && !self.action_config.key?(:index)
 
-      # Lastly, try returning the default config.
-      return self.config
+      return self.action_config[action] if self.action_config[action]
     end
 
-    # Get a configuration passable to `as_json` for the object.
-    def get_serializer_config
-      # Return a locally defined serializer config if one is defined.
-      if local_config = self.get_local_serializer_config
-        return local_config
-      end
+    # No action_config, so try singular/plural config if explicitly instructed to via @many.
+    return self.plural_config if @many == true && self.plural_config
+    return self.singular_config if @many == false && self.singular_config
 
-      # Return a serializer config if one is defined.
-      if serializer_config = @controller.send(:get_native_serializer_config)
-        return serializer_config
-      end
+    # Lastly, try returning the default config, or singular/plural config in that order.
+    return self.config || self.singular_config || self.plural_config
+  end
 
-      return {}
-    end
+  # Helper to get a native serializer configuration from the controller.
+  def get_controller_native_serializer_config
+    return nil unless @controller
 
-    # Convert the object (record or recordset) to Ruby primitives.
-    def serialize
-      if @object
-        @many = @object.respond_to?(:each) if @many.nil?
-        return @object.as_json(self.get_serializer_config)
-      end
-      return nil
+    if @many == true
+      controller_serializer = @controller.try(:native_serializer_plural_config)
+    elsif @many == false
+      controller_serializer = @controller.try(:native_serializer_singular_config)
     end
 
-    # Allow a serializer instance to be used as a hash directly in a nested serializer config.
-    def [](key)
-      unless instance_variable_defined?(:@_nested_config)
-        @_nested_config = self.get_serializer_config
-      end
-      return @_nested_config[key]
+    return controller_serializer || @controller.try(:native_serializer_config)
+  end
+
+  # Get a configuration passable to `serializable_hash` for the object.
+  def get_serializer_config
+    # Return a locally defined serializer config if one is defined.
+    if local_config = self.get_local_native_serializer_config
+      return local_config
     end
-    def []=(key, value)
-      unless instance_variable_defined?(:@_nested_config)
-        @_nested_config = self.get_serializer_config
-      end
-      return @_nested_config[key] = value
+
+    # Return a serializer config if one is defined on the controller.
+    if serializer_config = get_controller_native_serializer_config
+      return serializer_config
     end
 
-    # Allow a serializer class to be used as a hash directly in a nested serializer config.
-    def self.[](key)
-      unless instance_variable_defined?(:@_nested_config)
-        @_nested_config = self.new.get_serializer_config
+    # If the config wasn't determined, build a serializer config from model fields.
+    fields = @controller.send(:get_fields) if @controller
+    if fields
+      if @model
+        columns, methods = fields.partition { |f| f.in?(@model.column_names) }
+      else
+        columns = fields
+        methods = []
       end
-      return @_nested_config[key]
+
+      return {only: columns, methods: methods}
     end
-    def self.[]=(key, value)
-      unless instance_variable_defined?(:@_nested_config)
-        @_nested_config = self.new.get_serializer_config
+
+    # By default, pass an empty configuration, allowing the serialization of all columns.
+    return {}
+  end
+
+  # Convert the object (record or recordset) to Ruby primitives.
+  def serialize
+    if @object
+      begin
+        if @object.is_a?(Enumerable)
+          return @object.map { |r| r.serializable_hash(self.get_serializer_config) }
+        end
+        return @object.serializable_hash(self.get_serializer_config)
+      rescue NoMethodError
       end
-      return @_nested_config[key] = value
     end
+
+    # Raise an error if we cannot serialize the object.
+    raise RESTFramework::UnserializableError.new(@object)
   end
 
-  # `NativeModelSerializer` is similar to `NativeSerializer` but with some customizations to work
-  # with `ActiveModel`.
-  class NativeModelSerializer < NativeSerializer
-    def initialize(model: nil, **kwargs)
-      super(**kwargs)
-      @model = model || (@controller ? @controller.send(:get_model) : nil)
+  # Allow a serializer instance to be used as a hash directly in a nested serializer config.
+  def [](key)
+    unless instance_variable_defined?(:@_nested_config)
+      @_nested_config = self.get_serializer_config
+    end
+    return @_nested_config[key]
+  end
+  def []=(key, value)
+    unless instance_variable_defined?(:@_nested_config)
+      @_nested_config = self.get_serializer_config
     end
+    return @_nested_config[key] = value
+  end
 
-    # Get a configuration passable to `as_json` for the object.
-    def get_serializer_config
-      config = super
-      return config unless config.blank?
+  # Allow a serializer class to be used as a hash directly in a nested serializer config.
+  def self.[](key)
+    unless instance_variable_defined?(:@_nested_config)
+      @_nested_config = self.new.get_serializer_config
+    end
+    return @_nested_config[key]
+  end
+  def self.[]=(key, value)
+    unless instance_variable_defined?(:@_nested_config)
+      @_nested_config = self.new.get_serializer_config
+    end
+    return @_nested_config[key] = value
+  end
+end
 
-      # 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}
-      end
 
-      return {}
-    end
+# :nocov:
+# Alias NativeModelSerializer -> NativeSerializer.
+class RESTFramework::NativeModelSerializer < RESTFramework::NativeSerializer
+  def initialize(**kwargs)
+    super
+    ActiveSupport::Deprecation.warn(
+      <<~MSG.split("\n").join(' ')
+        RESTFramework::NativeModelSerializer is deprecated and will be removed in future versions of
+        REST Framework; you should use RESTFramework::NativeSerializer instead.
+      MSG
+    )
   end
 end
+# :nocov:

data/lib/rest_framework/version.rb

@@ -2,19 +2,21 @@ module RESTFramework
   module Version
     @_version = nil
 
-    def self.get_version
+    def self.get_version(skip_git: false)
       # Return cached @_version, if available.
       return @_version if @_version
 
       # First, attempt to get the version from git.
-      begin
-        version = `git describe 2>/dev/null`.strip
-        raise "blank version" if version.nil? || version.match(/^\w*$/)
-        # Check for local changes.
-        changes = `git status --porcelain 2>/dev/null`
-        version << '.localchanges' if changes.strip.length > 0
-        return version
-      rescue
+      unless skip_git
+        begin
+          version = `git describe 2>/dev/null`.strip
+          raise "blank version" if version.nil? || version.match(/^\w*$/)
+          # Check for local changes.
+          changes = `git status --porcelain 2>/dev/null`
+          version << '.localchanges' if changes.strip.length > 0
+          return version
+        rescue
+        end
       end
 
       # Git failed, so try to find a VERSION_STAMP.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_framework
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.2.1
 platform: ruby
 authors:
 - Gregory N. Schmit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-07 00:00:00.000000000 Z
+date: 2021-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,16 +43,19 @@ files:
 - lib/rest_framework/controller_mixins/base.rb
 - lib/rest_framework/controller_mixins/models.rb
 - lib/rest_framework/engine.rb
+- lib/rest_framework/errors.rb
 - lib/rest_framework/filters.rb
+- lib/rest_framework/generators.rb
+- lib/rest_framework/generators/controller_generator.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: []
@@ -70,7 +73,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.