plucker_serializer 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5944e6c05d1bab433f405984a62980c72501367bcddae6c91164aaf412eab4fc
-  data.tar.gz: c3d20b80b2d9759239d1b35b669a6a1ea09bad571c952b9a3c768330937af866
+  metadata.gz: e84cbc970b672503e92f8825f69e898d886d513a9a19a8bd04998b358889bf4a
+  data.tar.gz: 8fae9558248c250b5414b72630c6637d4ab0215ec95db08e060e16804d036874
 SHA512:
-  metadata.gz: d402fd1eebbd1b62394292f11b57a04e02e4d90dd2402272b239da98fe504900d9164dba7dc94c4fc13c8bc5b4db7350b1841021977ebe69c77d187c06b9fc0d
-  data.tar.gz: fdd3db583cb2d0cee54ae0a96b137657d977a21477d8ea13550ca388162f0a5636108690166f34ce88c10ea5764730985858d9b71f9173422ededaaeb289e359
+  metadata.gz: ef153929e8bfaf8c9ae3243f8d99fc7526b93720b0efb06cf720f3f9f58c6e46ec2054c5ade7795c3ad5e1d315563966374bffb1a27ffbea352f9a9e46fb74dd
+  data.tar.gz: 57ccf7fac652350f672aae10f617d86976b543d31a7f65f0c78ae2d7a0f4d34ea31bc5e284567dd661af1221ca1a2cbfa83cd06226d86a38bfe1136e1fdd3288

data/lib/plucker/base.rb

@@ -14,106 +14,101 @@ module Plucker
 
     attr_accessor :object
 
-    with_options instance_writer: false, instance_reader: false do |serializer|
-      serializer.class_attribute :_descriptor
-      self._descriptor ||= Plucker::Descriptor.new(self.class)
+    class << self
+      attr_accessor :_descriptor
     end
 
+    self._descriptor ||= Descriptor.new(self)
+
     def self.inherited(base)
       super
       base._descriptor = Plucker::Descriptor.new(base)
     end
 
     def initialize(object, options = {})
-      self.object = object
+      @object = object
     end
 
     def serializable_hash(use_cache: true)
       if use_cache && self.class.cache_enabled?
-        fetch(adapter: :hash) do
-          get_hash
-        end
+        fetch(adapter: :hash) { compute_hash }
       else
-        get_hash
+        compute_hash
       end
     end
     alias to_hash serializable_hash
     alias to_h serializable_hash
 
-    def as_json(options = nil)
+    def as_json(_options = nil)
       serializable_hash
     end
 
     def to_json(options = {}, use_cache: true)
       if use_cache && self.class.cache_enabled?
-        fetch(adapter: :json) do
-          Oj.dump(get_hash, mode: :rails)
-        end
+        fetch(adapter: :json) { Oj.dump(compute_hash, mode: :rails) }
       else
-        Oj.dump(get_hash, mode: :rails)
+        Oj.dump(compute_hash, mode: :rails)
       end
     end
 
-    def get_hash
-      attributes_hash.merge! associations_hash
-    end
-
-    def associations_hash
-      self.class._descriptor._relationships.each_with_object({}) do |(key, relationship), hash|
-        next unless relationship.should_include?(self)
+    private
 
-        hash[key.to_sym] = relationship.value(self)
-      end
+    def compute_hash
+      @compute_hash ||= attributes_hash.merge(associations_hash)
     end
 
     def attributes_hash
       self.class._descriptor._attributes.each_with_object({}) do |(key, attr), hash|
-        next unless attr.should_include?(self)
-
-        hash[key.to_sym] = attr.value(self)
+        hash[key] = attr.value(self) if attr.should_include?(self)
       end
     end
 
-    def self.pluckable?
-      self._descriptor.pluckable?
+    def associations_hash
+      self.class._descriptor._relationships.each_with_object({}) do |(key, relationship), hash|
+        hash[key] = relationship.value(self) if relationship.should_include?(self)
+      end
     end
 
-    def self.pluckable_columns
-      self._descriptor._pluckable_columns
-    end
+    class << self
+      def pluckable?
+        _descriptor.pluckable?
+      end
 
-    def self.attributes(*attrs)
-      attrs.each do |attr|
-        attribute(attr)
+      def pluckable_columns
+        _descriptor._pluckable_columns
       end
-    end
 
-    def self.attribute(attr, options = {}, &block)
-      key = options.fetch(:key, attr)
-      attribute = Plucker::Attribute.new(attr, options, block)
-      self._descriptor.add_attribute(key.to_sym, attribute)
-    end
+      def attributes(*attrs)
+        attrs.each { |attr| attribute(attr) }
+      end
 
-    def self.belongs_to(attr, options = {}, &block)
-      key = options.fetch(:key, attr)
-      belongs_to = Plucker::BelongsTo.new(attr, options, block)
-      self._descriptor.add_relationship(key.to_sym, belongs_to)
-    end
+      def attribute(attr, options = {}, &block)
+        key       = options.fetch(:key, attr)
+        attribute = Plucker::Attribute.new(attr, options, block)
+        _descriptor.add_attribute(key.to_sym, attribute)
+      end
 
-    def self.has_one(attr, options = {}, &block)
-      key = options.fetch(:key, attr)
-      has_one = Plucker::HasOne.new(attr, options, block)
-      self._descriptor.add_relationship(key.to_sym, has_one)
-    end
+      def belongs_to(attr, options = {}, &block)
+        key = options.fetch(:key, attr)
+        relationship = BelongsTo.new(attr, options, block)
+        _descriptor.add_relationship(key.to_sym, relationship)
+      end
 
-    def self.has_many(attr, options = {}, &block)
-      key = options.fetch(:key, attr)
-      has_many = Plucker::HasMany.new(attr, options, block)
-      self._descriptor.add_relationship(key.to_sym, has_many)
-    end
+      def has_one(attr, options = {}, &block)
+        key = options.fetch(:key, attr)
+        relationship = HasOne.new(attr, options, block)
+        _descriptor.add_relationship(key.to_sym, relationship)
+      end
 
-    def self.model(attr)
-      self._descriptor.set_model(attr)
+      def has_many(attr, options = {}, &block)
+        key = options.fetch(:key, attr)
+        relationship = HasMany.new(attr, options, block)
+        _descriptor.add_relationship(key.to_sym, relationship)
+      end
+
+      def model(attr)
+        _descriptor.set_model(attr)
+      end
     end
   end
 end

data/lib/plucker/collection.rb

@@ -13,42 +13,40 @@ module Plucker
 
     def initialize(objects, options = {})
       @objects = objects
-      @options = options
+      @options = options.freeze
       @cache_type = options[:cache] == :multi ? :multi : :collection
-      @serializer_class = get_serialized_model(objects)
+      @serializer_class = determine_serializer_class(objects)
     end
 
     def serializable_hash
-      if !objects.is_a?(ActiveRecord::Relation)
-        objects.map do |object|
+      unless objects.is_a?(ActiveRecord::Relation)
+        return objects.map do |object|
           serializer_class.new(object).serializable_hash
         end.compact
-      elsif serializer_class.cache_enabled?
-        if @cache_type == :collection
-          fetch(adapter: :hash) do
-            get_hash(use_cache: false)
-          end
-        elsif @cache_type == :multi
-          get_hash(use_cache: true)
+      end
+
+      if serializer_class.cache_enabled?
+        if cache_type == :collection
+          fetch(adapter: :hash) { compute_hash(use_cache: false) }
+        elsif cache_type == :multi
+          compute_hash(use_cache: true)
         end
       else
-        get_hash(use_cache: false)
+        compute_hash(use_cache: false)
       end
     end
     alias to_hash serializable_hash
     alias to_h serializable_hash
 
-    def as_json(options = nil)
+    def as_json(_options = nil)
       serializable_hash
     end
 
-    def to_json(options = {})
+    def to_json(_options = {})
       if serializer_class.cache_enabled?
-        if @cache_type == :collection
-          fetch(adapter: :json) do
-            Oj.dump(get_collection_json(use_cache: false), mode: :rails)
-          end
-        elsif @cache_type == :multi
+        if cache_type == :collection
+          fetch(adapter: :json) { Oj.dump(get_collection_json(use_cache: false), mode: :rails) }
+        elsif cache_type == :multi
           Oj.dump(get_collection_json(use_cache: true), mode: :rails)
         end
       else
@@ -56,46 +54,44 @@ module Plucker
       end
     end
 
+    def cache_version
+      @cache_version ||= objects.cache_version
+    end
+
+    def cache_key(adapter: :json)
+      "#{objects.cache_key}/#{serializer_class._cache_digest}/#{adapter}"
+    end
+
+    private
+
     def get_collection_json(use_cache: false)
       if serializer_class.pluckable?
         associated_hash
       else
-        objects.map do |object|
-          Oj.load(serializer_class.new(object).to_json(use_cache: use_cache))
-        end
+        objects.map { |object| Oj.load(serializer_class.new(object).to_json(use_cache: use_cache)) }
       end
     end
 
-    def get_hash(use_cache: false)
+    def compute_hash(use_cache: false)
       if serializer_class.pluckable?
         associated_hash.map(&:symbolize_keys)
       else
-        objects.map do |object|
-          serializer_class.new(object).serializable_hash(use_cache: use_cache)
-        end.compact
+        objects.map { |object| serializer_class.new(object).serializable_hash(use_cache: use_cache) }.compact
       end
     end
 
-    def cache_version
-      @cache_version ||= objects.cache_version
-    end
-
-    def cache_key(adapter: :json)
-      "#{objects.cache_key}/#{serializer_class._cache_digest}/#{adapter}"
-    end
-
-    private
-
     def associated_hash
-      pluck_to_hash(objects, serializer_class.pluckable_columns.to_a)
+      objects.pluck_all(namespaced_columns)
     end
 
-    def pluck_to_hash(objects, attrs)
-      namespaced_attrs = attrs.map { |attr| "#{objects.model.table_name}.#{attr}" }
-      objects.pluck_all(namespaced_attrs.join(','))
+    def namespaced_columns
+      @namespaced_columns ||= begin
+        cols = serializer_class.pluckable_columns.to_a.map { |attr| "#{objects.model.table_name}.#{attr}" }
+        cols.join(',').freeze
+      end
     end
 
-    def get_serialized_model(objects)
+    def determine_serializer_class(objects)
       if options[:serializer].blank?
         "#{objects.klass.name.demodulize.camelize}Serializer".constantize
       else

data/lib/plucker/descriptor.rb

@@ -5,37 +5,39 @@ module Plucker
     attr_accessor :_serialized_model, :_attributes, :_relationships, :_pluckable_columns, :_pluckable
 
     def initialize(serializer_class)
-      self._serialized_model = get_serialized_model(serializer_class)
-      self._attributes = {}
-      self._relationships = {}
-      self._pluckable_columns = Set.new
-      self._pluckable = true
+      @_serialized_model  = get_serialized_model(serializer_class)
+      @_attributes        = {}
+      @_relationships     = {}
+      @_pluckable_columns = Set.new
+      @_pluckable         = true
     end
 
     def pluckable?
-      _pluckable
+      @_pluckable
     end
 
     def add_attribute(key, attr)
-      _attributes[key] = attr
-      if attr.pluckable? && _serialized_model&.column_names&.include?(attr.name.to_s)
-        _pluckable_columns << attr.name
+      @_attributes[key] = attr
+
+      if attr.pluckable? && @_serialized_model&.column_names&.include?(attr.name.to_s)
+        @_pluckable_columns << attr.name
       else
-        self._pluckable = false
+        @_pluckable = false
       end
     end
 
     def add_relationship(key, relationship)
-      _relationships[key] = relationship
-      self._pluckable = false
+      @_relationships[key] = relationship
+      @_pluckable = false
     end
 
     def set_model(model)
-      self._serialized_model = model
+      @_serialized_model = model
     end
 
     def get_serialized_model(serializer_class)
-      serializer_class.name.split(/Serializer/).first.constantize
+      model_name = serializer_class.name.split(/Serializer/).first.freeze
+      model_name.constantize
     rescue NameError, LoadError
       nil
     end

data/lib/plucker/relationship.rb

@@ -14,50 +14,45 @@ module Plucker
     end
 
     def should_include?(serializer)
-      case @condition
-      when nil
-        true
-      when Symbol
-        serializer.public_send(@condition)
-      when String
-        serializer.instance_eval(@condition)
+      return true unless condition
+
+      case condition
+      when Symbol then serializer.public_send(condition)
+      when String then serializer.instance_eval(condition)
       when Proc
-        if @condition.arity.zero?
-          serializer.instance_exec(&@condition)
-        else
-          serializer.instance_exec(serializer, &@condition)
-        end
+        condition.arity.zero? ? serializer.instance_exec(&condition) : serializer.instance_exec(serializer, &condition)
+      else
+        true
       end
     end
 
     def associated_object(serializer)
-      if @block
-        result = if @block.arity.zero?
-                   serializer.object.instance_exec(&@block)
-                 else
-                   @block.call(serializer.object)
-                 end
-        return result if result != :nil
+      if block
+        result = block.arity.zero? ? serializer.object.instance_exec(&block) : block.call(serializer.object)
+        return result unless result == :nil
       end
-      serializer.object.public_send(@name)
+
+      serializer.object.public_send(name)
     end
 
-    def value(serializer)
+    # This method is intended to be overridden by subclasses (such as HasOne, HasMany, etc.)
+    def value(_serializer)
       nil
     end
 
     private
 
     def relationship_serializer(serializer, relationship_object = nil)
-      if @options[:serializer].blank?
-        association_class = if relationship_object.present?
-                              relationship_object.class.name
-                            else
-                              serializer.object.class.reflect_on_association(@name.to_sym).class_name
-                            end
+      if options[:serializer].blank?
+        association_class =
+          if relationship_object.present?
+            relationship_object.class.name
+          else
+            serializer.object.class.reflect_on_association(name)&.class_name
+          end
         "#{association_class.demodulize.camelize}Serializer".constantize
       else
-        @options[:serializer]
+        options[:serializer]
       end
     end
   end

data/lib/plucker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plucker
-  VERSION = '0.7.0'
+  VERSION = '0.7.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plucker_serializer
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Henry Boisgibault