plucker_serializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c5ce3615a6b455cef96024d0dd6d9cfadf30e1af519f88e03496927956a378aa
+  data.tar.gz: ba1b98c83f64a135f9043d92e8ec0b9a5ff785144b774f2f6c78e915b589b75c
+SHA512:
+  metadata.gz: 11751d1facbd07d422144a931b2e9487495ba294880dd064b754e3526bfa9212da5d73c3f9d65fff061a281ce9b4d63504167d66bfb02c4f0fa8305984823d6a
+  data.tar.gz: c7e5ceabff25a46edac6e3a2c72b79b1f9f2c92c20bb32486b995de4e3d2ae6ebd608818201c6722514363b390b6978e9b1409f2a5606dbf9ac66b440c2e0c45

data/lib/plucker/attribute.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Plucker
+    class Attribute < Plucker::Field
+    end
+end

data/lib/plucker/base.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+require_relative 'caching'
+require_relative 'descriptor'
+require_relative 'has_many'
+require_relative 'belongs_to'
+require_relative 'has_one'
+require 'active_support/all'
+
+module Plucker
+    class Base
+        include Caching
+
+        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
+
+        def self.inherited(base)
+            super
+            base._descriptor = Plucker::Descriptor.new(base)
+        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
+        end
+        alias to_hash serializable_hash
+        alias to_h serializable_hash
+
+        def get_hash
+            attributes_hash.merge! associations_hash
+        end
+
+        def as_json(options = nil)
+            to_h.as_json(options)
+        end
+
+        def associations_hash
+            hash = {}
+            self.class._descriptor._relationships.each do |(key, relationship)|
+                next if relationship.excluded?(self)
+                hash[key] = relationship.value(self)
+            end
+            hash
+        end
+
+        def attributes_hash
+            self.class._descriptor._attributes.each_with_object({}) do |(key, attr), hash|
+                next if attr.excluded?(self)
+                hash[key] = attr.value(self)
+            end
+        end
+
+        def self.is_pluckable?
+            self._descriptor.is_pluckable?
+        end
+
+        def self.pluckable_columns
+            self._descriptor._pluckable_columns
+        end
+
+        def self.attributes(*attrs)
+            attrs.each do |attr|
+                attribute(attr)
+            end
+        end
+
+        def self.attribute(attr, options = {}, &block)
+            self._descriptor.add_attribute(options.fetch(:key, attr), Plucker::Attribute.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.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

data/lib/plucker/belongs_to.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+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
+    end
+end

data/lib/plucker/caching.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'active_support/all'
+
+module Plucker
+  module Caching
+    extend ActiveSupport::Concern
+
+    included do
+      with_options instance_writer: false, instance_reader: false do |serializer|
+        serializer.class_attribute :_cache
+        serializer.class_attribute :_cache_options
+      end
+    end
+
+    module ClassMethods
+      def _cache_digest
+        return @_cache_digest if defined?(@_cache_digest)
+        @_cache_digest = Digest::SHA1.hexdigest(self.name)
+      end
+
+      def cache(options = {})
+        self._cache = true
+        self._cache_options = options.blank? ? {} : options
+      end
+
+      def cache_store
+        defined?(Rails) && Rails.cache
+      end
+
+      def cache_enabled?
+        cache_store.present? && _cache.present?
+      end
+    end
+
+    ### INSTANCE METHODS
+    def fetch
+      if serializer_class.cache_enabled?
+        serializer_class.cache_store.fetch(cache_key, version: cache_version, options: serializer_class._cache_options) do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def cache_version
+      return @cache_version if defined?(@cache_version)
+      @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
+    end
+
+    def serializer_class
+      @serializer_class ||= self.class
+    end
+  end
+end

data/lib/plucker/collection.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module Plucker
+  class Collection
+    include Enumerable
+    include Caching
+
+    attr_reader :objects, :serializer_class, :options
+
+    def initialize(objects, options = {})
+      @objects = objects
+      @options = options
+      @serializer_class = get_serialized_model(objects)
+    end
+
+    def serializable_hash
+      if (not objects.is_a?(ActiveRecord::Relation))
+        objects.map do |object|
+          serializer_class.new(object).serializable_hash
+        end.compact
+      else
+        if serializer_class.cache_enabled?
+          fetch do
+            if serializer_class.is_pluckable?
+              associated_hash
+            else
+              objects.map do |object|
+                serializer_class.new(object).serializable_hash
+              end.compact
+            end
+          end
+        else
+          if serializer_class.is_pluckable?
+            associated_hash
+          else
+            objects.map do |object|
+              serializer_class.new(object).serializable_hash
+            end.compact
+          end
+        end
+      end
+    end
+    alias to_hash serializable_hash
+    alias to_h serializable_hash
+
+    def as_json(options = nil)
+      to_h.as_json(options)
+    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
+    end
+
+    private
+    def associated_hash
+      pluck_to_hash(objects, serializer_class.pluckable_columns.to_a)
+    end
+
+    def pluck_to_hash(object, attrs)
+      namespaced_attrs = attrs.map { |attr| object.model.table_name.to_s + "." + attr.to_s }
+      object.pluck(Arel.sql(namespaced_attrs.join(','))).map { |el| attrs.zip(el).to_h }
+    end
+
+    def get_serialized_model(objects)
+      if options[:serializer].blank?
+        "#{objects.klass.name.demodulize.camelize}Serializer".constantize
+      else
+        options[:serializer]
+      end
+    end
+  end
+end

data/lib/plucker/descriptor.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Plucker
+    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([:updated_at])
+            self._is_pluckable = true
+        end
+
+        def is_pluckable?
+            self._is_pluckable && !self._relationships.present?
+        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_relationship(key, relationship)
+            self._relationships[key] = relationship
+            self._is_pluckable = false
+        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
+    end
+end

data/lib/plucker/field.rb

@@ -0,0 +1,81 @@
+# 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

data/lib/plucker/has_many.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+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
+    end
+end

data/lib/plucker/has_one.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+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
+    end
+end

data/lib/plucker/relationship.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require_relative 'collection'
+require_relative "field"
+
+module Plucker
+    class Relationship < Plucker::Field
+        def associated_object(serializer)
+            serializer.object.send(name)
+        end
+
+        def value(serializer)
+            nil
+        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
+        end
+    end
+end

data/lib/plucker/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Plucker
+    VERSION = "0.1.0"
+end

data/lib/plucker_serializer.rb

@@ -0,0 +1,11 @@
+require "plucker/version"
+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/caching"

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: plucker_serializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Henry Boisgibault
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A blazing fast JSON serializer
+email: henry@logora.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/plucker/attribute.rb
+- lib/plucker/base.rb
+- lib/plucker/belongs_to.rb
+- lib/plucker/caching.rb
+- lib/plucker/collection.rb
+- lib/plucker/descriptor.rb
+- lib/plucker/field.rb
+- lib/plucker/has_many.rb
+- lib/plucker/has_one.rb
+- lib/plucker/relationship.rb
+- lib/plucker/version.rb
+- lib/plucker_serializer.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A blazing fast JSON serializer with an easy-to-use API
+test_files: []