plucker_serializer 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1afbdbecad2e29b9ee1e5cc59f143597f8995ad851b2d4a7b28ddcab61349de
-  data.tar.gz: 6a4bbd5de3a4d833833030fa8c2e35f43fc3ed56c2b2bfaeb435352495a904d0
+  metadata.gz: bf134b11d47d300e2df621e5f027ea881cfae344ae1a807eeb8a51b001888720
+  data.tar.gz: 20f2cee76e31ed9d07f69fe41013cc733b1f3194bc940425309b93639763c1aa
 SHA512:
-  metadata.gz: d06fa3ebe3216c2aef19f60eb42887f8d4190111ce6f6d2d07010d2e0401965d9a5968e01e1da0915fd4dea468f727b2d05df323dda072351559e590c851cb04
-  data.tar.gz: 2ee3ef45ca3635bdf8400ec8b988a7d6ee2fc0bc524a9ee957287f8f59a8713ffcc04b5ec91195fa7f546b261152e395b107d22d25e6b756ca656fff5f5c0c16
+  metadata.gz: d2693c8756d65c1a32f5b0be8aa857e9b5b0c77e8574b99de84ddac9289754f8df4f97cb80cd0928c1aa40ca23588366f0433b01ae60c1668081861f29c20c50
+  data.tar.gz: 9a11ff786953fe594b81dea45f4fa883bbb947bae007207c5724ba0c8077cfcdc0329b9f95457379c906ef39bee27d2acd6d4059eb103184b253a9dcdedf16c4

data/lib/plucker/attribute.rb

@@ -1,5 +1,51 @@
 # frozen_string_literal: true
+
 module Plucker
-    class Attribute < Plucker::Field
+  class Attribute
+    attr_reader :name, :block, :condition
+
+    def initialize(name, options = {}, block)
+      @name = name.to_sym
+      @block = block&.freeze
+      @condition = options[:if]&.freeze
     end
-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
+      end
+    end
+  end
+end

data/lib/plucker/base.rb

@@ -1,104 +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
-            if self.class.cache_enabled?
-                fetch 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 = {})
-            Oj.dump(serializable_hash, mode: :rails)
+    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
-            hash = {}
-            self.class._descriptor._relationships.each do |(key, relationship)|
-                next if relationship.excluded?(self)
-                hash[key.to_s] = relationship.value(self)
-            end
-            hash
-        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.excluded?(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,18 +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 @cache_type == :collection && serializer_class.cache_enabled?
-          fetch do
-            get_hash
+      elsif serializer_class.cache_enabled?
+        if @cache_type == :collection
+          fetch(adapter: :hash) do
+            get_hash(use_cache: false)
           end
-        else
-          get_hash
+        elsif @cache_type == :multi
+          get_hash(use_cache: true)
         end
+      else
+        get_hash(use_cache: false)
       end
     end
     alias to_hash serializable_hash
@@ -40,36 +43,57 @@ module Plucker
     end
 
     def to_json(options = {})
-      Oj.dump(serializable_hash, mode: :rails)
+      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
+          Oj.dump(get_collection_json(use_cache: true), mode: :rails)
+        end
+      else
+        Oj.dump(get_collection_json(use_cache: false), mode: :rails)
+      end
     end
 
-    def get_hash
+    def get_collection_json(use_cache: false)
       if serializer_class.is_pluckable?
         associated_hash
       else
         objects.map do |object|
-          serializer_class.new(object).serializable_hash
+          Oj.load(serializer_class.new(object).to_json(use_cache: use_cache))
+        end
+      end
+    end
+
+    def get_hash(use_cache: false)
+      if serializer_class.is_pluckable?
+        associated_hash
+      else
+        objects.map do |object|
+          serializer_class.new(object).serializable_hash(use_cache: use_cache)
         end.compact
       end
     end
 
     def cache_version
       return @cache_version if defined?(@cache_version)
+
       @cache_version = objects.cache_version
     end
 
-    def cache_key
-      return @cache_key if defined?(@cache_key)
-      @cache_key = objects.cache_key + '/' + serializer_class._cache_digest
+    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)
     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
 
@@ -81,4 +105,4 @@ module Plucker
       end
     end
   end
-end
+end

data/lib/plucker/concerns/caching.rb

@@ -30,9 +30,9 @@ module Plucker
       end
     end
 
-    def fetch
+    def fetch(adapter: :json)
       if serializer_class.cache_enabled?
-        serializer_class._cache_store.fetch(cache_key, version: cache_version, options: serializer_class._cache_options) do
+        serializer_class._cache_store.fetch(cache_key(adapter: adapter), version: cache_version, options: serializer_class._cache_options) do
           yield
         end
       else
@@ -45,9 +45,8 @@ module Plucker
       @cache_version = object.cache_version
     end
 
-    def cache_key
-      return @cache_key if defined?(@cache_key)
-      @cache_key = object.cache_key + "/" + serializer_class._cache_digest
+    def cache_key(adapter: :json)
+      object.cache_key + "/" + serializer_class._cache_digest + "/" + adapter.to_s
     end
 
     def serializer_class

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,34 +1,64 @@
 # frozen_string_literal: true
+
 require_relative 'collection'
-require_relative "field"
 
 module Plucker
-    class Relationship < Plucker::Field
-        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
-        end
+  class Relationship
+    attr_reader :name, :block, :options, :condition
 
-        def value(serializer)
-            nil
-        end
+    def initialize(name, options = {}, block)
+      @name = name.to_sym
+      @block = block&.freeze
+      @options = options.freeze
+      @condition = options[:if]&.freeze
+    end
 
-        private
-        def relationship_serializer(serializer, relationship_object=nil)
-            if self.options[:serializer].blank?
-                if relationship_object.present?
-                    association_class = relationship_object.class.name
-                else
-                    association_class = serializer.object.class.reflect_on_association(self.name.to_sym).class_name
-                end
-                "#{association_class.demodulize.camelize}Serializer".constantize
-            else
-                self.options[:serializer]
-            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 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
+
+    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.4.0"
-end
+  VERSION = '0.6.0'
+end

data/lib/plucker_serializer.rb

@@ -1,24 +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/field"
-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.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Henry Boisgibault
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-03 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -65,7 +65,6 @@ files:
 - lib/plucker/concerns/caching.rb
 - lib/plucker/configuration.rb
 - lib/plucker/descriptor.rb
-- lib/plucker/field.rb
 - lib/plucker/has_many.rb
 - lib/plucker/has_one.rb
 - lib/plucker/relationship.rb
@@ -94,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

data/lib/plucker/field.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-module Plucker
-    Field = Struct.new(:name, :options, :block) do
-        def initialize(*)
-            super
-            validate_condition!
-        end
-
-        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 is_pluckable?
-            block.blank?
-        end
-
-        def excluded?(serializer)
-            case condition_type
-            when :if
-                !evaluate_condition(serializer)
-            when :unless
-                evaluate_condition(serializer)
-            else
-                false
-            end
-        end
-
-        private
-        def validate_condition!
-            return if condition_type == :none
-
-            case condition
-            when Symbol, String, Proc
-                # noop
-            else
-                fail TypeError, "#{condition_type.inspect} should be a Symbol, String or Proc"
-            end
-        end
-
-        def evaluate_condition(serializer)
-            case condition
-            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 condition_type
-            @condition_type ||=
-                if options.key?(:if)
-                    :if
-                elsif options.key?(:unless)
-                    :unless
-                else
-                    :none
-                end
-        end
-
-        def condition
-            options[condition_type]
-        end
-    end
-end