serega 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad827e730d35f4e1805b7a0c59e8a8eeec87a91bb426ada370ea4a632516f40c
-  data.tar.gz: 681deb3a954453740ac3256614684601aeb18027423352ca05cc62c82ff37784
+  metadata.gz: 0ca43f185a296a7139890f92ca5b7a8c265f3d9db65a0cc3a5e3fff4390d6ac9
+  data.tar.gz: d295ac90b5481f9ca4ff2e8239c7e43e2548df76cc30d50b8f372934f8f78dfe
 SHA512:
-  metadata.gz: 6f279fecc4038a162b33d97001fa993758eb4d687c0a7b83f9555f20781e3ece12b1381ba9765993cf5a4d7a31a5dee66f29d3279e1198a6ddf6b6d19b977682
-  data.tar.gz: c1ed8f5f7e06ff2df08f2f5fb8ee587d062e3197399475c55d1383ab0fcb6c4c8f5224363ef202ecccdab063964a9e5cf98581ecdacfa5ac5caafa02277c93c6
+  metadata.gz: f75c90f6156452f49290d11eb5caf322437025c2c43ba471bc5bda32185a7c9b00b9003dc836952b660932c407285483b65e3538c7aebe365b110d47502e0d0b
+  data.tar.gz: 925cb9cc61974ce9524ffec2cd3cf869c230beba1d13ecd71b5b3e8aa4e6415acb64bd75845cab58031b0713b2c8253442d53473eff5b16915e57ad7a2e118b0

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.3.0

data/lib/serega/attribute.rb

@@ -4,7 +4,7 @@ class Serega
   #
   # Stores Attribute data
   #
-  class Attribute
+  class SeregaAttribute
     #
     # Stores Attribute instance methods
     #
@@ -36,7 +36,7 @@ class Serega
         self.class.serializer_class::CheckAttributeParams.new(name, opts, block).validate
 
         @name = name.to_sym
-        @opts = Utils::EnumDeepDup.call(opts)
+        @opts = SeregaUtils::EnumDeepDup.call(opts)
         @block = block
       end
 
@@ -77,7 +77,7 @@ class Serega
       def value_block
         return @value_block if instance_variable_defined?(:@value_block)
 
-        @value_block = block || opts[:value] || const_block || keyword_block
+        @value_block = block || opts[:value] || const_block || delegate_block || keyword_block
       end
 
       #
@@ -123,9 +123,22 @@ class Serega
         key_method_name = key
         proc { |object| object.public_send(key_method_name) }
       end
+
+      def delegate_block
+        return unless opts.key?(:delegate)
+
+        key_method_name = key
+        delegate_to = opts[:delegate][:to]
+
+        if opts[:delegate][:allow_nil]
+          proc { |object| object.public_send(delegate_to)&.public_send(key_method_name) }
+        else
+          proc { |object| object.public_send(delegate_to).public_send(key_method_name) }
+        end
+      end
     end
 
-    extend Serega::Helpers::SerializerClassHelper
+    extend Serega::SeregaHelpers::SerializerClassHelper
     include AttributeInstanceMethods
   end
 end

data/lib/serega/config.rb

@@ -6,43 +6,85 @@ class Serega
   #
   # Core class that stores serializer configuration
   #
-  class Config
-    module ConfigInstanceMethods
-      extend Forwardable
+  class SeregaConfig
+    # :nocov: We can't use both :oj and :json adapters together
+    DEFAULTS = {
+      plugins: [],
+      initiate_keys: %i[only with except check_initiate_params].freeze,
+      attribute_keys: %i[key value serializer many hide const delegate].freeze,
+      serialize_keys: %i[context many].freeze,
+      check_initiate_params: true,
+      max_cached_map_per_serializer_count: 0,
+      to_json: SeregaJSON.adapter == :oj ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
+      from_json: SeregaJSON.adapter == :oj ? SeregaJSON::OjLoad : SeregaJSON::JSONLoad
+    }.freeze
+    # :nocov:
 
-      # @return [Hash] Current config data
+    module SeregaConfigInstanceMethods
       attr_reader :opts
 
       #
-      # Initializes new config instance and deeply duplicates all provided options to
-      # remove possibility of accidental overwriting of parent/nested configs.
+      # Initializes new config instance.
       #
       # @param opts [Hash] Initial config options
       #
-      def initialize(opts = {})
-        @opts = Utils::EnumDeepDup.call(opts)
+      def initialize(opts = nil)
+        opts ||= DEFAULTS
+        @opts = SeregaUtils::EnumDeepDup.call(opts)
       end
 
-      #
-      # @!method [](name)
-      #   Get config option, delegates to opts#[]
-      #   @param name [Symbol] option name
-      #   @return [Object]
-      #
-      # @!method []=(name)
-      #   Set config option, delegates to opts#[]=
-      #   @param name [Symbol] option name
-      #   @return [Object]
-      #
-      # @!method fetch(name)
-      #   Fetch config option, delegates to opts#fetch
-      #   @param name [Symbol] option name
-      #   @return [Object]
-      #
-      def_delegators :opts, :[], :[]=, :fetch, :keys, :has_key?
+      def plugins
+        opts.fetch(:plugins)
+      end
+
+      def initiate_keys
+        opts.fetch(:initiate_keys)
+      end
+
+      def attribute_keys
+        opts.fetch(:attribute_keys)
+      end
+
+      def serialize_keys
+        opts.fetch(:serialize_keys)
+      end
+
+      def check_initiate_params
+        opts.fetch(:check_initiate_params)
+      end
+
+      def check_initiate_params=(value)
+        raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
+        opts[:check_initiate_params] = value
+      end
+
+      def max_cached_map_per_serializer_count
+        opts.fetch(:max_cached_map_per_serializer_count)
+      end
+
+      def max_cached_map_per_serializer_count=(value)
+        raise SeregaError, "Must have Integer value, #{value.inspect} provided" unless value.is_a?(Integer)
+        opts[:max_cached_map_per_serializer_count] = value
+      end
+
+      def to_json
+        opts.fetch(:to_json)
+      end
+
+      def to_json=(value)
+        opts[:to_json] = value
+      end
+
+      def from_json
+        opts.fetch(:from_json)
+      end
+
+      def from_json=(value)
+        opts[:from_json] = value
+      end
     end
 
-    include ConfigInstanceMethods
-    extend Serega::Helpers::SerializerClassHelper
+    include SeregaConfigInstanceMethods
+    extend Serega::SeregaHelpers::SerializerClassHelper
   end
 end

data/lib/serega/convert.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 class Serega
-  class Convert
-    module ConvertClassMethods
+  class SeregaConvert
+    module SeregaConvertClassMethods
       def call(object, **opts)
         new(object, **opts).to_h
       end
     end
 
-    module ConvertInstanceMethods
+    module SeregaConvertInstanceMethods
       attr_reader :object, :opts
 
       def initialize(object, **opts)
@@ -27,7 +27,7 @@ class Serega
       end
 
       def one(object)
-        self.class.serializer_class::ConvertItem.call(object, opts[:context], opts[:map])
+        self.class.serializer_class::SeregaConvertItem.call(object, opts[:context], opts[:map])
       end
 
       def many?
@@ -38,8 +38,8 @@ class Serega
       end
     end
 
-    extend Serega::Helpers::SerializerClassHelper
-    extend ConvertClassMethods
-    include ConvertInstanceMethods
+    extend Serega::SeregaHelpers::SerializerClassHelper
+    extend SeregaConvertClassMethods
+    include SeregaConvertInstanceMethods
   end
 end

data/lib/serega/convert_item.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Serega
-  class ConvertItem
-    module ConvertItemClassMethods
+  class SeregaConvertItem
+    module SeregaConvertItemClassMethods
       def call(object, context, map)
         return unless object
 
@@ -31,7 +31,7 @@ class Serega
       end
     end
 
-    extend Serega::Helpers::SerializerClassHelper
-    extend ConvertItemClassMethods
+    extend Serega::SeregaHelpers::SerializerClassHelper
+    extend SeregaConvertItemClassMethods
   end
 end

data/lib/serega/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Serega
+  # A generic exception Serega uses.
+  class SeregaError < StandardError; end
+
+  # AttributeNotExist is raised when serializer is initiated using not existing attribute
+  # Example:
+  #    UserSerializer.new(only: 'FOO', except: 'FOO', with: 'FOO')
+  #    UserSerializer.to_h(user, only: 'FOO', except: 'FOO', with: 'FOO' )
+  class AttributeNotExist < SeregaError; end
+end

data/lib/serega/helpers/serializer_class_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Serega
-  module Helpers
+  module SeregaHelpers
     # Stores link to current serializer class
     module SerializerClassHelper
       # @return [Class<Serega>] Serializer class that current class is namespaced under.

data/lib/serega/json/adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaJSON
+    def self.adapter
+      @adapter ||=
+        if defined?(::Oj)
+          require_relative "oj"
+          :oj
+        else
+          require "json"
+          require_relative "json"
+          :json
+        end
+    end
+  end
+end

data/lib/serega/json/json.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaJSON
+    class JSONDump
+      def self.call(data)
+        ::JSON.dump(data)
+      end
+    end
+
+    class JSONLoad
+      def self.call(json_string)
+        ::JSON.parse(json_string)
+      end
+    end
+  end
+end

data/lib/serega/json/oj.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaJSON
+    class OjDump
+      def self.call(data)
+        ::Oj.dump(data, mode: :compat)
+      end
+    end
+
+    class OjLoad
+      def self.call(json_string)
+        ::Oj.load(json_string)
+      end
+    end
+  end
+end

data/lib/serega/map.rb

@@ -1,27 +1,37 @@
 # frozen_string_literal: true
 
 class Serega
-  class Map
+  class SeregaMap
     module ClassMethods
       def call(opts)
-        @cache ||= {}
-        cache_key = opts.to_s
-
-        @cache[cache_key] ||= begin
-          modifiers = {
-            only: opts&.[](:only) || FROZEN_EMPTY_HASH,
-            except: opts&.[](:except) || FROZEN_EMPTY_HASH,
-            with: opts&.[](:with) || FROZEN_EMPTY_HASH
-          }
+        max_cache_size = serializer_class.config.max_cached_map_per_serializer_count
+        return map_for(opts) if max_cache_size.zero?
 
-          construct_map(serializer_class, **modifiers).tap do
-            @cache.shift if @cache.length >= serializer_class.config[:max_cached_map_per_serializer_count]
-          end
-        end
+        cached_map_for(opts, max_cache_size)
       end
 
       private
 
+      def map_for(opts)
+        construct_map(serializer_class, **modifiers(opts))
+      end
+
+      def cached_map_for(opts, max_cache_size)
+        @cache ||= {}
+        cache_key = opts.to_s
+        map = @cache[cache_key] ||= map_for(opts)
+        @cache.shift if @cache.length > max_cache_size
+        map
+      end
+
+      def modifiers(opts)
+        {
+          only: opts[:only] || FROZEN_EMPTY_HASH,
+          except: opts[:except] || FROZEN_EMPTY_HASH,
+          with: opts[:with] || FROZEN_EMPTY_HASH
+        }
+      end
+
       def construct_map(serializer_class, only:, except:, with:)
         serializer_class.attributes.each_with_object([]) do |(name, attribute), map|
           next unless attribute.visible?(only: only, except: except, with: with)
@@ -44,6 +54,6 @@ class Serega
     end
 
     extend ClassMethods
-    extend Serega::Helpers::SerializerClassHelper
+    extend Serega::SeregaHelpers::SerializerClassHelper
   end
 end

data/lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     #
     # Plugin that checks used plugins and loads correct Preloader for selected response type
-    # @see Serega::Plugins::JsonApiActiverecordPreloader
-    # @see Serega::Plugins::SimpleApiActiverecordPreloader
+    # @see Serega::SeregaPlugins::JsonApiActiverecordPreloader
+    # @see Serega::SeregaPlugins::SimpleApiActiverecordPreloader
     #
     module ActiverecordPreloads
       # @return [Symbol] plugin name

data/lib/serega/plugins/activerecord_preloads/lib/preloader.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     module ActiverecordPreloads
       class Preloader
         module ClassMethods
           def preload(object, preloads)
             preload_handler = handlers.find { |handler| handler.fit?(object) }
-            raise Error, "Can't preload #{preloads.inspect} to #{object.inspect}" unless preload_handler
+            raise SeregaError, "Can't preload #{preloads.inspect} to #{object.inspect}" unless preload_handler
 
             preload_handler.preload(object, preloads)
           end

data/lib/serega/plugins/context_metadata/context_metadata.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     module ContextMetadata
       DEFAULT_CONTEXT_METADATA_KEY = :meta
 
@@ -14,27 +14,50 @@ class Serega
       end
 
       def self.load_plugin(serializer_class, **_opts)
-        serializer_class::Convert.include(ConvertInstanceMethods)
-        serializer_class::CheckSerializeParams.extend(CheckSerializeParamsClassMethods)
+        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
+        serializer_class::SeregaConvert.include(SeregaConvertInstanceMethods)
+        serializer_class::CheckSerializeParams.include(CheckSerializeParamsInstanceMethods)
       end
 
       def self.after_load_plugin(serializer_class, **opts)
         config = serializer_class.config
         meta_key = opts[:context_metadata_key] || DEFAULT_CONTEXT_METADATA_KEY
-        config[plugin_name] = {key: meta_key}
-        config[:serialize_keys] << meta_key
+        config.opts[:context_metadata] = {key: meta_key}
+        config.serialize_keys << meta_key
       end
 
-      module CheckSerializeParamsClassMethods
-        def check_opts(opts)
+      class ContextMetadataConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def key
+          opts.fetch(:key)
+        end
+
+        def key=(value)
+          opts[:key] = value
+        end
+      end
+
+      module ConfigInstanceMethods
+        def context_metadata
+          ContextMetadataConfig.new(opts.fetch(:context_metadata))
+        end
+      end
+
+      module CheckSerializeParamsInstanceMethods
+        def check_opts
           super
 
-          meta_key = serializer_class.config[:context_metadata][:key]
-          Validations::Utils::CheckOptIsHash.call(opts, meta_key)
+          meta_key = self.class.serializer_class.config.context_metadata.key
+          SeregaValidations::Utils::CheckOptIsHash.call(opts, meta_key)
         end
       end
 
-      module ConvertInstanceMethods
+      module SeregaConvertInstanceMethods
         def to_h
           super.tap do |hash|
             add_context_metadata(hash)
@@ -44,7 +67,7 @@ class Serega
         private
 
         def add_context_metadata(hash)
-          context_metadata_key = self.class.serializer_class.config[:context_metadata][:key]
+          context_metadata_key = self.class.serializer_class.config.context_metadata.key
           return unless context_metadata_key
 
           metadata = opts[context_metadata_key]

data/lib/serega/plugins/formatters/formatters.rb

@@ -1,20 +1,41 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     module Formatters
       def self.plugin_name
         :formatters
       end
 
       def self.load_plugin(serializer_class, **_opts)
-        serializer_class::Attribute.include(AttributeInstanceMethods)
+        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
+        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
       end
 
       def self.after_load_plugin(serializer_class, **_opts)
         config = serializer_class.config
-        config[plugin_name] = {}
-        config[:attribute_keys] << :format
+        config.opts[:formatters] = {}
+        config.attribute_keys << :format
+      end
+
+      class FormattersConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def add(formatters)
+          formatters.each_pair do |key, value|
+            opts[key] = value
+          end
+        end
+      end
+
+      module ConfigInstanceMethods
+        def formatters
+          FormattersConfig.new(opts.fetch(:formatters))
+        end
       end
 
       module AttributeInstanceMethods
@@ -25,7 +46,15 @@ class Serega
           formatter = opts[:format]
           return original_block unless formatter
 
-          @value_block = formatted_block(formatter, original_block)
+          new_value_block = formatted_block(formatter, original_block)
+
+          # Detect formatted :const value in advance
+          if opts.key?(:const)
+            const_value = new_value_block.call
+            new_value_block = proc { const_value }
+          end
+
+          @value_block = new_value_block
         end
 
         private
@@ -35,7 +64,7 @@ class Serega
             value = original_block.call(object, context)
 
             if formatter.is_a?(Symbol)
-              self.class.serializer_class.config.fetch(:formatters).fetch(formatter).call(value)
+              self.class.serializer_class.config.formatters.opts.fetch(formatter).call(value)
             else
               formatter.call(value)
             end

data/lib/serega/plugins/hide_nil/hide_nil.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     #
     # Plugin adds `:hide_nil` option to attributes to delete them from final result
     # if value is nil
@@ -21,13 +21,13 @@ class Serega
       # @return [void]
       #
       def self.load_plugin(serializer_class, **_opts)
-        serializer_class::Attribute.include(AttributeMethods)
+        serializer_class::SeregaAttribute.include(AttributeMethods)
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-        serializer_class::ConvertItem.extend(ConvertItemClassMethods)
+        serializer_class::SeregaConvertItem.extend(SeregaConvertItemClassMethods)
       end
 
       def self.after_load_plugin(serializer_class, **opts)
-        serializer_class.config[:attribute_keys] << :hide_nil
+        serializer_class.config.attribute_keys << :hide_nil
       end
 
       # Adds #hide_nil? Attribute instance method
@@ -52,7 +52,7 @@ class Serega
         #
         # @param opts [Hash] Attribute options
         #
-        # @raise [Serega::Error] Error that option has invalid value
+        # @raise [Serega::SeregaError] SeregaError that option has invalid value
         #
         # @return [void]
         #
@@ -62,11 +62,11 @@ class Serega
           value = opts[:hide_nil]
           return if (value == true) || (value == false)
 
-          raise Error, "Invalid option :hide_nil => #{value.inspect}. Must have a boolean value"
+          raise SeregaError, "Invalid option :hide_nil => #{value.inspect}. Must have a boolean value"
         end
       end
 
-      module ConvertItemClassMethods
+      module SeregaConvertItemClassMethods
         private
 
         def attach_value(value, *args)

data/lib/serega/plugins/metadata/meta_attribute.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Serega
-  module Plugins
+  module SeregaPlugins
     module Metadata
       #
       # Stores Attribute data
@@ -36,8 +36,8 @@ class Serega
             check(path, opts, block)
 
             @name = path.join(".").to_sym
-            @path = Utils::EnumDeepDup.call(path)
-            @opts = Utils::EnumDeepDup.call(opts)
+            @path = SeregaUtils::EnumDeepDup.call(path)
+            @opts = SeregaUtils::EnumDeepDup.call(opts)
             @block = block
           end
 
@@ -61,12 +61,12 @@ class Serega
 
           def check(path, opts, block)
             CheckPath.call(path)
-            CheckOpts.call(opts, self.class.serializer_class.config[:metadata][:attribute_keys])
+            CheckOpts.call(opts, self.class.serializer_class.config.metadata.attribute_keys)
             CheckBlock.call(block)
           end
         end
 
-        extend Serega::Helpers::SerializerClassHelper
+        extend Serega::SeregaHelpers::SerializerClassHelper
         include InstanceMethods
       end
     end