plucker_serializer 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b74f3d1f2fee4bfa2fd0fc3e6968f35f6d1bbe852b69c6fda56ad63bdbe8ada
-  data.tar.gz: c9daa990c9d467958e6f30dd2faba3a69aa81dfa0708a6289243026504f88351
+  metadata.gz: bf134b11d47d300e2df621e5f027ea881cfae344ae1a807eeb8a51b001888720
+  data.tar.gz: 20f2cee76e31ed9d07f69fe41013cc733b1f3194bc940425309b93639763c1aa
 SHA512:
-  metadata.gz: f051ad0a434f02690092cdeb7481db0fc606b780574d8109251746f99b3f1888842c906231321f82ba896e9615939461a93ad95245082086235cb670fc27710b
-  data.tar.gz: b05c2e4c4f327a32c0c9faeae82fc017265f316e41f5f111a709577801862a70d481f7545b226b8cb848a8a83d705702a963851e9582ba2fbc72ec670ba3ccb3
+  metadata.gz: d2693c8756d65c1a32f5b0be8aa857e9b5b0c77e8574b99de84ddac9289754f8df4f97cb80cd0928c1aa40ca23588366f0433b01ae60c1668081861f29c20c50
+  data.tar.gz: 9a11ff786953fe594b81dea45f4fa883bbb947bae007207c5724ba0c8077cfcdc0329b9f95457379c906ef39bee27d2acd6d4059eb103184b253a9dcdedf16c4

data/lib/plucker/attribute.rb

@@ -1,48 +1,51 @@
 # frozen_string_literal: true
+
 module Plucker
-    class Attribute
-        attr_reader :name, :block, :condition
-       
-        def initialize(name, options = {}, block)
-            @name = name
-            @block = block
-            @condition = options[:if]
-        end
+  class Attribute
+    attr_reader :name, :block, :condition
 
-        def value(serializer)
-            block_value = instance_exec(serializer.object, &@block) if @block
-            if @block && block_value != :nil
-                block_value
-            else
-                if serializer.respond_to?(@name)
-                    serializer.send(@name)
-                else
-                    serializer.object.send(@name)
-                end
-            end
-        end
+    def initialize(name, options = {}, block)
+      @name = name.to_sym
+      @block = block&.freeze
+      @condition = options[:if]&.freeze
+    end
 
-        def is_pluckable?
-            @block.blank?
-        end
+    def value(serializer)
+      if @block
+        result = if @block.arity.zero?
+                   serializer.object.instance_exec(&@block)
+                 else
+                   @block.call(serializer.object)
+                 end
+        return result unless result == :nil
+      end
+
+      if serializer.respond_to?(@name)
+        serializer.public_send(@name)
+      else
+        serializer.object.public_send(@name)
+      end
+    end
+
+    def is_pluckable?
+      @block.blank?
+    end
 
-        def should_include?(serializer)
-            case @condition
-            when nil
-                true
-            when Symbol
-                serializer.public_send(@condition)
-            when String
-                serializer.instance_eval(@condition)
-            when Proc
-                if @condition.arity.zero?
-                    serializer.instance_exec(&@condition)
-                else
-                    serializer.instance_exec(serializer, &@condition)
-                end
-            else
-                nil
-            end
+    def should_include?(serializer)
+      case @condition
+      when nil
+        true
+      when Symbol
+        serializer.public_send(@condition)
+      when String
+        serializer.instance_eval(@condition)
+      when Proc
+        if @condition.arity.zero?
+          serializer.instance_exec(&@condition)
+        else
+          serializer.instance_exec(serializer, &@condition)
         end
+      end
     end
-end
+  end
+end

data/lib/plucker/base.rb

@@ -1,108 +1,111 @@
 # frozen_string_literal: true
+
 require_relative 'concerns/caching'
 require_relative 'descriptor'
 require_relative 'has_many'
 require_relative 'belongs_to'
 require_relative 'has_one'
-require "oj"
+require 'oj'
 require 'active_support/all'
 
 module Plucker
-    class Base
-        include Caching
+  class Base
+    include Caching
 
-        attr_accessor :object
+    attr_accessor :object
 
-        with_options instance_writer: false, instance_reader: false do |serializer|
-            serializer.class_attribute :_descriptor
-            self._descriptor ||= Plucker::Descriptor.new(self.class)
-        end
+    with_options instance_writer: false, instance_reader: false do |serializer|
+      serializer.class_attribute :_descriptor
+      self._descriptor ||= Plucker::Descriptor.new(self.class)
+    end
 
-        def self.inherited(base)
-            super
-            base._descriptor = Plucker::Descriptor.new(base)
-        end
+    def self.inherited(base)
+      super
+      base._descriptor = Plucker::Descriptor.new(base)
+    end
 
-        def initialize(object, options = {})
-            self.object = object
-        end
+    def initialize(object, options = {})
+      self.object = object
+    end
 
-        def serializable_hash(use_cache: true)
-            if use_cache && self.class.cache_enabled?
-                fetch(adapter: :hash) do
-                    get_hash
-                end
-            else
-                get_hash
-            end
+    def serializable_hash(use_cache: true)
+      if use_cache && self.class.cache_enabled?
+        fetch(adapter: :hash) do
+          get_hash
         end
-        alias to_hash serializable_hash
-        alias to_h serializable_hash
+      else
+        get_hash
+      end
+    end
+    alias to_hash serializable_hash
+    alias to_h serializable_hash
 
-        def as_json(options = nil)
-            serializable_hash
-        end
+    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
-            else
-                Oj.dump(get_hash, mode: :rails)
-            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
+      else
+        Oj.dump(get_hash, mode: :rails)
+      end
+    end
 
-        def get_hash
-            attributes_hash.merge! associations_hash
-        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 if !relationship.should_include?(self)
-                hash[key.to_s] = relationship.value(self)
-            end
-        end
+    def associations_hash
+      self.class._descriptor._relationships.each_with_object({}) do |(key, relationship), hash|
+        next unless relationship.should_include?(self)
 
-        def attributes_hash
-            self.class._descriptor._attributes.each_with_object({}) do |(key, attr), hash|
-                next if !attr.should_include?(self)
-                hash[key.to_s] = attr.value(self)
-            end
-        end
+        hash[key.to_s] = relationship.value(self)
+      end
+    end
 
-        def self.is_pluckable?
-            self._descriptor.is_pluckable?
-        end
+    def attributes_hash
+      self.class._descriptor._attributes.each_with_object({}) do |(key, attr), hash|
+        next unless attr.should_include?(self)
 
-        def self.pluckable_columns
-            self._descriptor._pluckable_columns
-        end
+        hash[key.to_s] = attr.value(self)
+      end
+    end
 
-        def self.attributes(*attrs)
-            attrs.each do |attr|
-                attribute(attr)
-            end
-        end
+    def self.is_pluckable?
+      self._descriptor.is_pluckable?
+    end
 
-        def self.attribute(attr, options = {}, &block)
-            self._descriptor.add_attribute(options.fetch(:key, attr), Plucker::Attribute.new(attr, options, block))
-        end
+    def self.pluckable_columns
+      self._descriptor._pluckable_columns
+    end
 
-        def self.belongs_to(attr, options = {}, &block)
-            self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::BelongsTo.new(attr, options, block))
-        end
+    def self.attributes(*attrs)
+      attrs.each do |attr|
+        attribute(attr)
+      end
+    end
 
-        def self.has_one(attr, options = {}, &block)
-            self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasOne.new(attr, options, block))
-        end
+    def self.attribute(attr, options = {}, &block)
+      self._descriptor.add_attribute(options.fetch(:key, attr), Plucker::Attribute.new(attr, options, block))
+    end
 
-        def self.has_many(attr, options = {}, &block)
-            self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasMany.new(attr, options, block))
-        end
+    def self.belongs_to(attr, options = {}, &block)
+      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::BelongsTo.new(attr, options, block))
+    end
 
-        def self.model(attr)
-            self._descriptor.set_model(attr)
-        end
+    def self.has_one(attr, options = {}, &block)
+      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasOne.new(attr, options, block))
+    end
+
+    def self.has_many(attr, options = {}, &block)
+      self._descriptor.add_relationship(options.fetch(:key, attr), Plucker::HasMany.new(attr, options, block))
+    end
+
+    def self.model(attr)
+      self._descriptor.set_model(attr)
     end
-end
+  end
+end

data/lib/plucker/belongs_to.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
-require_relative "relationship"
+
+require_relative 'relationship'
 
 module Plucker
-    class BelongsTo < Plucker::Relationship
-        def value(serializer)
-            relationship_object = self.associated_object(serializer)
-            return nil if relationship_object.blank?
-            relationship_serializer(serializer, relationship_object).new(relationship_object).serializable_hash
-        end
+  class BelongsTo < Plucker::Relationship
+    def value(serializer)
+      relationship_object = associated_object(serializer)
+      return nil if relationship_object.blank?
+
+      relationship_serializer(serializer, relationship_object).new(relationship_object).serializable_hash
     end
-end
+  end
+end

data/lib/plucker/collection.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 require_relative 'concerns/caching'
-require "oj"
-require "pluck_all"
+require 'oj'
+require 'pluck_all'
 
 module Plucker
   class Collection
@@ -18,22 +19,20 @@ module Plucker
     end
 
     def serializable_hash
-      if (not objects.is_a?(ActiveRecord::Relation))
+      if !objects.is_a?(ActiveRecord::Relation)
         objects.map do |object|
           serializer_class.new(object).serializable_hash
         end.compact
-      else
-        if 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)
+      elsif serializer_class.cache_enabled?
+        if @cache_type == :collection
+          fetch(adapter: :hash) do
+            get_hash(use_cache: false)
           end
-        else
-          get_hash(use_cache: false)
+        elsif @cache_type == :multi
+          get_hash(use_cache: true)
         end
+      else
+        get_hash(use_cache: false)
       end
     end
     alias to_hash serializable_hash
@@ -79,20 +78,22 @@ module Plucker
 
     def cache_version
       return @cache_version if defined?(@cache_version)
+
       @cache_version = objects.cache_version
     end
 
     def cache_key(adapter: :json)
-      objects.cache_key + '/' + serializer_class._cache_digest + "/" + adapter.to_s
+      "#{objects.cache_key}/#{serializer_class._cache_digest}/#{adapter}"
     end
 
     private
+
     def associated_hash
       pluck_to_hash(objects, serializer_class.pluckable_columns.to_a)
     end
 
     def pluck_to_hash(objects, attrs)
-      namespaced_attrs = attrs.map { |attr| objects.model.table_name.to_s + "." + attr.to_s }
+      namespaced_attrs = attrs.map { |attr| "#{objects.model.table_name}.#{attr}" }
       objects.pluck_all(namespaced_attrs.join(','))
     end
 
@@ -104,4 +105,4 @@ module Plucker
       end
     end
   end
-end
+end

data/lib/plucker/configuration.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Plucker
-    class Configuration
-        attr_accessor :cache_store
-  
-        def initialize
-            @cache_store = nil
-        end
+  class Configuration
+    attr_accessor :cache_store
+
+    def initialize
+      @cache_store = nil
     end
-end
+  end
+end

data/lib/plucker/descriptor.rb

@@ -1,44 +1,43 @@
 # frozen_string_literal: true
+
 module Plucker
-    class Descriptor
-        attr_accessor :_serialized_model, :_attributes, :_relationships, :_pluckable_columns, :_is_pluckable
+  class Descriptor
+    attr_accessor :_serialized_model, :_attributes, :_relationships, :_pluckable_columns, :_is_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
-        end
+    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
+    end
 
-        def is_pluckable?
-            self._is_pluckable
-        end
+    def is_pluckable?
+      _is_pluckable
+    end
 
-        def add_attribute(key, attr)
-            self._attributes[key] = attr
-            if attr.is_pluckable? && self._serialized_model && self._serialized_model.column_names.include?(attr.name.to_s)
-                self._pluckable_columns << attr.name
-            else
-                self._is_pluckable = false
-            end
-        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
+      else
+        self._is_pluckable = false
+      end
+    end
 
-        def add_relationship(key, relationship)
-            self._relationships[key] = relationship
-            self._is_pluckable = false
-        end
+    def add_relationship(key, relationship)
+      _relationships[key] = relationship
+      self._is_pluckable = false
+    end
 
-        def set_model(model)
-            self._serialized_model = model
-        end
+    def set_model(model)
+      self._serialized_model = model
+    end
 
-        def get_serialized_model(serializer_class)
-            begin
-                serializer_class.name.split(/Serializer/).first.constantize
-            rescue NameError, LoadError => e
-                nil
-            end
-        end
+    def get_serialized_model(serializer_class)
+      serializer_class.name.split(/Serializer/).first.constantize
+    rescue NameError, LoadError => e
+      nil
     end
-end
+  end
+end

data/lib/plucker/has_many.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
-require_relative "relationship"
-require_relative "collection"
+
+require_relative 'relationship'
+require_relative 'collection'
 
 module Plucker
-    class HasMany < Plucker::Relationship
-        def value(serializer)
-            Plucker::Collection.new(self.associated_object(serializer), serializer: relationship_serializer(serializer)).serializable_hash
-        end
+  class HasMany < Plucker::Relationship
+    def value(serializer)
+      Plucker::Collection.new(associated_object(serializer),
+                              serializer: relationship_serializer(serializer)).serializable_hash
     end
-end
+  end
+end

data/lib/plucker/has_one.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
-require_relative "relationship"
+
+require_relative 'relationship'
 
 module Plucker
-    class HasOne < Plucker::Relationship
-        def value(serializer)
-            relationship_object = self.associated_object(serializer)
-            return nil if relationship_object.blank?
-            relationship_serializer(serializer, relationship_object).new(relationship_object).serializable_hash
-        end
+  class HasOne < Plucker::Relationship
+    def value(serializer)
+      relationship_object = associated_object(serializer)
+      return nil if relationship_object.blank?
+
+      relationship_serializer(serializer, relationship_object).new(relationship_object).serializable_hash
     end
-end
+  end
+end

data/lib/plucker/relationship.rb

@@ -1,61 +1,64 @@
 # frozen_string_literal: true
+
 require_relative 'collection'
 
 module Plucker
-    class Relationship
-        attr_reader :name, :block, :options, :condition
-       
-        def initialize(name, options = {}, block)
-            @name = name
-            @block = block
-            @options = options
-            @condition = options[:if]
-        end
+  class Relationship
+    attr_reader :name, :block, :options, :condition
 
-        def should_include?(serializer)
-            case @condition
-            when nil
-                true
-            when Symbol
-                serializer.public_send(@condition)
-            when String
-                serializer.instance_eval(@condition)
-            when Proc
-                if @condition.arity.zero?
-                    serializer.instance_exec(&@condition)
-                else
-                    serializer.instance_exec(serializer, &@condition)
-                end
-            else
-                nil
-            end
-        end
+    def initialize(name, options = {}, block)
+      @name = name.to_sym
+      @block = block&.freeze
+      @options = options.freeze
+      @condition = options[:if]&.freeze
+    end
 
-        def associated_object(serializer)
-            block_value = instance_exec(serializer.object, &@block) if @block
-            if @block && block_value != :nil
-                block_value
-            else
-                serializer.object.send(@name)
-            end
+    def should_include?(serializer)
+      case @condition
+      when nil
+        true
+      when Symbol
+        serializer.public_send(@condition)
+      when String
+        serializer.instance_eval(@condition)
+      when Proc
+        if @condition.arity.zero?
+          serializer.instance_exec(&@condition)
+        else
+          serializer.instance_exec(serializer, &@condition)
         end
+      end
+    end
 
-        def value(serializer)
-            nil
-        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
+      end
+      serializer.object.public_send(@name)
+    end
 
-        private
-        def relationship_serializer(serializer, relationship_object=nil)
-            if @options[:serializer].blank?
-                if relationship_object.present?
-                    association_class = relationship_object.class.name
-                else
-                    association_class = serializer.object.class.reflect_on_association(@name.to_sym).class_name
-                end
-                "#{association_class.demodulize.camelize}Serializer".constantize
-            else
-                @options[:serializer]
-            end
-        end
+    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
+        "#{association_class.demodulize.camelize}Serializer".constantize
+      else
+        @options[:serializer]
+      end
     end
-end
+  end
+end

data/lib/plucker/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Plucker
-    VERSION = "0.5.0"
-end
+  VERSION = '0.6.0'
+end

data/lib/plucker_serializer.rb

@@ -1,23 +1,23 @@
-require "plucker/version"
-require "plucker/configuration"
-require "plucker/base"
-require "plucker/attribute"
-require "plucker/collection"
-require "plucker/relationship"
-require "plucker/belongs_to"
-require "plucker/has_one"
-require "plucker/has_many"
-require "plucker/descriptor"
-require "plucker/concerns/caching"
+require 'plucker/version'
+require 'plucker/configuration'
+require 'plucker/base'
+require 'plucker/attribute'
+require 'plucker/collection'
+require 'plucker/relationship'
+require 'plucker/belongs_to'
+require 'plucker/has_one'
+require 'plucker/has_many'
+require 'plucker/descriptor'
+require 'plucker/concerns/caching'
 
 module Plucker
-    class << self
-        def config
-            @config ||= Configuration.new
-        end
-  
-        def configure
-            yield(config)
-        end
+  class << self
+    def config
+      @config ||= Configuration.new
     end
-end
+
+    def configure
+      yield(config)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plucker_serializer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Henry Boisgibault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-05 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: A blazing fast JSON serializer for ActiveRecord & Ruby objects