plucker_serializer 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5944e6c05d1bab433f405984a62980c72501367bcddae6c91164aaf412eab4fc
-  data.tar.gz: c3d20b80b2d9759239d1b35b669a6a1ea09bad571c952b9a3c768330937af866
+  metadata.gz: 965b22f7307d9bb8930fe6e49e44eed985ad2dabd98970e12e79349855f7d99d
+  data.tar.gz: 1b21385382669c1eb7a6ebb15802a73edaceb8d8f81f9ed0caee8c9f9ade990f
 SHA512:
-  metadata.gz: d402fd1eebbd1b62394292f11b57a04e02e4d90dd2402272b239da98fe504900d9164dba7dc94c4fc13c8bc5b4db7350b1841021977ebe69c77d187c06b9fc0d
-  data.tar.gz: fdd3db583cb2d0cee54ae0a96b137657d977a21477d8ea13550ca388162f0a5636108690166f34ce88c10ea5764730985858d9b71f9173422ededaaeb289e359
+  metadata.gz: ce2ee569cfc9b2fd4157715efa36c823001f0a4aad122270e41d4752048d8e74867869e3dfb51ca8af08ff6d217a6b692855af7dc657cdccdef689cfb331cad2
+  data.tar.gz: 8cd5c5d6228800fc97429853b3b658ffe12222dca1567b3fea357b475948a4ce23c31cb7c91537b81514fe455c8dccc9b5764540c947d9f0737b92e4317e9687

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/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.1'
 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.1
 platform: ruby
 authors:
 - Henry Boisgibault