plucker_serializer 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf134b11d47d300e2df621e5f027ea881cfae344ae1a807eeb8a51b001888720
-  data.tar.gz: 20f2cee76e31ed9d07f69fe41013cc733b1f3194bc940425309b93639763c1aa
+  metadata.gz: 965b22f7307d9bb8930fe6e49e44eed985ad2dabd98970e12e79349855f7d99d
+  data.tar.gz: 1b21385382669c1eb7a6ebb15802a73edaceb8d8f81f9ed0caee8c9f9ade990f
 SHA512:
-  metadata.gz: d2693c8756d65c1a32f5b0be8aa857e9b5b0c77e8574b99de84ddac9289754f8df4f97cb80cd0928c1aa40ca23588366f0433b01ae60c1668081861f29c20c50
-  data.tar.gz: 9a11ff786953fe594b81dea45f4fa883bbb947bae007207c5724ba0c8077cfcdc0329b9f95457379c906ef39bee27d2acd6d4059eb103184b253a9dcdedf16c4
+  metadata.gz: ce2ee569cfc9b2fd4157715efa36c823001f0a4aad122270e41d4752048d8e74867869e3dfb51ca8af08ff6d217a6b692855af7dc657cdccdef689cfb331cad2
+  data.tar.gz: 8cd5c5d6228800fc97429853b3b658ffe12222dca1567b3fea357b475948a4ce23c31cb7c91537b81514fe455c8dccc9b5764540c947d9f0737b92e4317e9687

data/lib/plucker/attribute.rb

@@ -27,7 +27,7 @@ module Plucker
       end
     end
 
-    def is_pluckable?
+    def pluckable?
       @block.blank?
     end
 

data/lib/plucker/base.rb

@@ -14,98 +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_s] = 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_s] = attr.value(self)
+        hash[key] = attr.value(self) if attr.should_include?(self)
       end
     end
 
-    def self.is_pluckable?
-      self._descriptor.is_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)
-      self._descriptor.add_attribute(options.fetch(:key, attr), Plucker::Attribute.new(attr, options, block))
-    end
+      def attributes(*attrs)
+        attrs.each { |attr| attribute(attr) }
+      end
 
-    def self.belongs_to(attr, options = {}, &block)
-      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::BelongsTo.new(attr, options, block))
-    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)
-      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasOne.new(attr, options, block))
-    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)
-      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasMany.new(attr, options, block))
-    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

@@ -57,7 +57,7 @@ module Plucker
     end
 
     def get_collection_json(use_cache: false)
-      if serializer_class.is_pluckable?
+      if serializer_class.pluckable?
         associated_hash
       else
         objects.map do |object|
@@ -67,8 +67,8 @@ module Plucker
     end
 
     def get_hash(use_cache: false)
-      if serializer_class.is_pluckable?
-        associated_hash
+      if serializer_class.pluckable?
+        associated_hash.map(&:symbolize_keys)
       else
         objects.map do |object|
           serializer_class.new(object).serializable_hash(use_cache: use_cache)
@@ -77,9 +77,7 @@ module Plucker
     end
 
     def cache_version
-      return @cache_version if defined?(@cache_version)
-
-      @cache_version = objects.cache_version
+      @cache_version ||= objects.cache_version
     end
 
     def cache_key(adapter: :json)

data/lib/plucker/concerns/caching.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'active_support/all'
 
 module Plucker
@@ -16,7 +17,8 @@ module Plucker
     module ClassMethods
       def _cache_digest
         return @_cache_digest if defined?(@_cache_digest)
-        @_cache_digest = Digest::SHA1.hexdigest(self.name)
+
+        @_cache_digest = Digest::SHA1.hexdigest(name)
       end
 
       def cache(options = {})
@@ -26,15 +28,14 @@ module Plucker
       end
 
       def cache_enabled?
-        self._cache_store.present? && _cache.present?
+        _cache_store.present? && _cache.present?
       end
     end
 
-    def fetch(adapter: :json)
+    def fetch(adapter: :json, &block)
       if serializer_class.cache_enabled?
-        serializer_class._cache_store.fetch(cache_key(adapter: adapter), version: cache_version, options: serializer_class._cache_options) do
-          yield
-        end
+        serializer_class._cache_store.fetch(cache_key(adapter: adapter), version: cache_version,
+                                                                         options: serializer_class._cache_options, &block)
       else
         yield
       end
@@ -42,15 +43,16 @@ module Plucker
 
     def cache_version
       return @cache_version if defined?(@cache_version)
+
       @cache_version = object.cache_version
     end
 
     def cache_key(adapter: :json)
-      object.cache_key + "/" + serializer_class._cache_digest + "/" + adapter.to_s
+      "#{object.cache_key}/#{serializer_class._cache_digest}/#{adapter}"
     end
 
     def serializer_class
       @serializer_class ||= self.class
     end
   end
-end
+end

data/lib/plucker/descriptor.rb

@@ -2,41 +2,43 @@
 
 module Plucker
   class Descriptor
-    attr_accessor :_serialized_model, :_attributes, :_relationships, :_pluckable_columns, :_is_pluckable
+    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._is_pluckable = true
+      @_serialized_model  = get_serialized_model(serializer_class)
+      @_attributes        = {}
+      @_relationships     = {}
+      @_pluckable_columns = Set.new
+      @_pluckable         = true
     end
 
-    def is_pluckable?
-      _is_pluckable
+    def pluckable?
+      @_pluckable
     end
 
     def add_attribute(key, attr)
-      _attributes[key] = attr
-      if attr.is_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._is_pluckable = false
+        @_pluckable = false
       end
     end
 
     def add_relationship(key, relationship)
-      _relationships[key] = relationship
-      self._is_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
-    rescue NameError, LoadError => e
+      model_name = serializer_class.name.split(/Serializer/).first.freeze
+      model_name.constantize
+    rescue NameError, LoadError
       nil
     end
   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.6.0'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plucker_serializer
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Henry Boisgibault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport