serega 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88e403fa3d489c2c708aca3f9df3734bcfc64f8e61eed4b96b9635cdf1a16622
-  data.tar.gz: 1c7f92f7defa3c2415257e69021ed70f0c07b43b0f468969589a1ed18148507b
+  metadata.gz: 0ca43f185a296a7139890f92ca5b7a8c265f3d9db65a0cc3a5e3fff4390d6ac9
+  data.tar.gz: d295ac90b5481f9ca4ff2e8239c7e43e2548df76cc30d50b8f372934f8f78dfe
 SHA512:
-  metadata.gz: 50aec430bd1d42cccc89c82635700734569ffde5de0780782af0454feae87fbb11fc273b91bb1c936fb3001c26d24db72726928fc8f7d93ccf4b4b846a43147f
-  data.tar.gz: 883c4e0e945663939b75c62e237b0268b9d8fd60ff2f31f7066a72021a9f90c045ca404c725ae787bc7268cf5f5cbd208f626c8f97ec22ebbc4208f0208e8233
+  metadata.gz: f75c90f6156452f49290d11eb5caf322437025c2c43ba471bc5bda32185a7c9b00b9003dc836952b660932c407285483b65e3538c7aebe365b110d47502e0d0b
+  data.tar.gz: 925cb9cc61974ce9524ffec2cd3cf869c230beba1d13ecd71b5b3e8aa4e6415acb64bd75845cab58031b0713b2c8253442d53473eff5b16915e57ad7a2e118b0

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/lib/serega/config.rb

@@ -7,39 +7,81 @@ class Serega
   # Core class that stores serializer configuration
   #
   class SeregaConfig
-    module SeregaConfigInstanceMethods
-      extend Forwardable
+    # :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 = {})
+      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 SeregaConfigInstanceMethods

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/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

@@ -4,24 +4,34 @@ class Serega
   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)

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

@@ -14,23 +14,46 @@ class Serega
       end
 
       def self.load_plugin(serializer_class, **_opts)
+        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
         serializer_class::SeregaConvert.include(SeregaConvertInstanceMethods)
-        serializer_class::CheckSerializeParams.extend(CheckSerializeParamsClassMethods)
+        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]
-          SeregaValidations::SeregaUtils::CheckOptIsHash.call(opts, meta_key)
+          meta_key = self.class.serializer_class.config.context_metadata.key
+          SeregaValidations::Utils::CheckOptIsHash.call(opts, meta_key)
         end
       end
 
@@ -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

@@ -8,13 +8,34 @@ class Serega
       end
 
       def self.load_plugin(serializer_class, **_opts)
+        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
@@ -43,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

@@ -27,7 +27,7 @@ class Serega
       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

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

@@ -61,7 +61,7 @@ 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

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

@@ -8,11 +8,18 @@ class Serega
       end
 
       def self.before_load_plugin(serializer_class, **opts)
-        serializer_class.plugin(:root, **opts) unless serializer_class.plugin_used?(:root)
+        if serializer_class.plugin_used?(:root)
+          root = serializer_class.config.root
+          root.one = opts[:root_one] if opts.key?(:root_one)
+          root.many = opts[:root_many] if opts.key?(:root_many)
+        else
+          serializer_class.plugin(:root, **opts)
+        end
       end
 
       def self.load_plugin(serializer_class, **_opts)
         serializer_class.extend(ClassMethods)
+        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
         serializer_class::SeregaConvert.include(SeregaConvertInstanceMethods)
 
         require_relative "./meta_attribute"
@@ -28,7 +35,25 @@ class Serega
       end
 
       def self.after_load_plugin(serializer_class, **_opts)
-        serializer_class.config[plugin_name] = {attribute_keys: %i[path hide_nil hide_empty]}
+        serializer_class.config.opts[:metadata] = {attribute_keys: %i[path hide_nil hide_empty]}
+      end
+
+      class MetadataConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def attribute_keys
+          opts.fetch(:attribute_keys)
+        end
+      end
+
+      module ConfigInstanceMethods
+        def metadata
+          MetadataConfig.new(opts.fetch(:metadata))
+        end
       end
 
       module ClassMethods

data/lib/serega/plugins/preloads/preloads.rb

@@ -6,6 +6,12 @@ class Serega
     # Plugin adds `.preloads` method to find relations that must be preloaded
     #
     module Preloads
+      DEFAULT_CONFIG = {
+        auto_preload_attributes_with_delegate: false,
+        auto_preload_attributes_with_serializer: false,
+        auto_hide_attributes_with_preload: false
+      }.freeze
+
       # @return [Symbol] plugin name
       def self.plugin_name
         :preloads
@@ -22,6 +28,7 @@ class Serega
       def self.load_plugin(serializer_class, **_opts)
         serializer_class.include(InstanceMethods)
         serializer_class::SeregaAttribute.include(AttributeMethods)
+        serializer_class::SeregaConfig.include(ConfigInstanceMethods)
 
         serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
 
@@ -35,12 +42,14 @@ class Serega
 
       def self.after_load_plugin(serializer_class, **opts)
         config = serializer_class.config
-        config[:attribute_keys] += [:preload, :preload_path]
-        config[:preloads] = {
-          auto_preload_attributes_with_delegate: opts.fetch(:auto_preload_attributes_with_delegate, false),
-          auto_preload_attributes_with_serializer: opts.fetch(:auto_preload_attributes_with_serializer, false),
-          auto_hide_attributes_with_preload: opts.fetch(:auto_hide_attributes_with_preload, false)
-        }
+        config.attribute_keys << :preload << :preload_path
+
+        preloads_opts = DEFAULT_CONFIG.merge(opts.slice(*DEFAULT_CONFIG.keys))
+        config.opts[:preloads] = {}
+        preloads_config = config.preloads
+        preloads_config.auto_preload_attributes_with_delegate = preloads_opts[:auto_preload_attributes_with_delegate]
+        preloads_config.auto_preload_attributes_with_serializer = preloads_opts[:auto_preload_attributes_with_serializer]
+        preloads_config.auto_hide_attributes_with_preload = preloads_opts[:auto_hide_attributes_with_preload]
       end
 
       # Adds #preloads instance method
@@ -51,6 +60,35 @@ class Serega
         end
       end
 
+      class PreloadsConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        %i[
+          auto_preload_attributes_with_delegate
+          auto_preload_attributes_with_serializer
+          auto_hide_attributes_with_preload
+        ].each do |method_name|
+          define_method(method_name) do
+            opts.fetch(method_name)
+          end
+
+          define_method("#{method_name}=") do |value|
+            raise SeregaError, "Must have boolean value, #{value.inspect} provided" if (value != true) && (value != false)
+            opts[method_name] = value
+          end
+        end
+      end
+
+      module ConfigInstanceMethods
+        def preloads
+          PreloadsConfig.new(opts.fetch(:preloads))
+        end
+      end
+
       # Adds #preloads and #preloads_path Attribute instance method
       module AttributeMethods
         def preloads
@@ -75,9 +113,7 @@ class Serega
         private
 
         def auto_hide_attribute_with_preloads?
-          return @auto_hide_attribute_with_preloads if defined?(@auto_hide_attribute_with_preloads)
-
-          auto = self.class.serializer_class.config[:preloads][:auto_hide_attributes_with_preload]
+          auto = self.class.serializer_class.config.preloads.auto_hide_attributes_with_preload
           @auto_hide_attribute_with_preloads = auto && !preloads.nil? && (preloads != false) && (preloads != {})
         end
 
@@ -86,9 +122,9 @@ class Serega
           preloads =
             if preloads_provided
               opts[:preload]
-            elsif relation? && self.class.serializer_class.config[:preloads][:auto_preload_attributes_with_serializer]
+            elsif relation? && self.class.serializer_class.config.preloads.auto_preload_attributes_with_serializer
               key
-            elsif opts.key?(:delegate) && self.class.serializer_class.config[:preloads][:auto_preload_attributes_with_delegate]
+            elsif opts.key?(:delegate) && self.class.serializer_class.config.preloads.auto_preload_attributes_with_delegate
               opts[:delegate].fetch(:to)
             end
 

data/lib/serega/plugins/root/root.rb

@@ -12,12 +12,17 @@ class Serega
 
       def self.load_plugin(serializer_class, **_opts)
         serializer_class.extend(ClassMethods)
+        serializer_class::SeregaConfig.include(SeregaConfigInstanceMethods)
         serializer_class::SeregaConvert.include(SeregaConvertInstanceMethods)
       end
 
       def self.after_load_plugin(serializer_class, **opts)
-        serializer_class.root(opts[:root] || ROOT_DEFAULT, one: opts[:root_one], many: opts[:root_many])
-        serializer_class.config[:serialize_keys] << :root
+        config = serializer_class.config
+        default = opts[:root] || ROOT_DEFAULT
+        one = (opts[:root_one] || default).to_sym
+        many = (opts[:root_many] || default).to_sym
+        config.opts[:root] = {one: one, many: many}
+        config.serialize_keys << :root
       end
 
       module ClassMethods
@@ -37,7 +42,42 @@ class Serega
           one = one.to_sym if one
           many = many.to_sym if many
 
-          config[:root] = {one: one, many: many}
+          config.root = {one: one, many: many}
+        end
+      end
+
+      class RootConfig
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def one
+          opts.fetch(:one)
+        end
+
+        def many
+          opts.fetch(:many)
+        end
+
+        def one=(value)
+          opts[:one] = value
+        end
+
+        def many=(value)
+          opts[:many] = value
+        end
+      end
+
+      module SeregaConfigInstanceMethods
+        def root
+          RootConfig.new(opts.fetch(:root))
+        end
+
+        def root=(value)
+          root.one = value.fetch(:one)
+          root.many = value.fetch(:many)
         end
       end
 
@@ -54,8 +94,8 @@ class Serega
         def build_root(opts)
           return opts[:root] if opts.key?(:root)
 
-          root_config = self.class.serializer_class.config[:root]
-          many? ? root_config[:many] : root_config[:one]
+          root = self.class.serializer_class.config.root
+          many? ? root.many : root.one
         end
       end
     end

data/lib/serega/plugins/string_modifiers/string_modifiers.rb

@@ -16,13 +16,13 @@ class Serega
         private
 
         def prepare_modifiers(opts)
-          opts = {
-            only: ParseStringModifiers.call(opts[:only]),
-            except: ParseStringModifiers.call(opts[:except]),
-            with: ParseStringModifiers.call(opts[:with])
-          }
+          parsed_opts =
+            opts.each_with_object({}) do |(key, value), obj|
+              value = ParseStringModifiers.call(value) if (key == :only) || (key == :except) || (key == :with)
+              obj[key] = value
+            end
 
-          super
+          super(parsed_opts)
         end
       end
     end

data/lib/serega/validations/attribute/check_opt_delegate.rb

@@ -25,7 +25,7 @@ class Serega
           private
 
           def check_opt_delegate(opts)
-            SeregaUtils::CheckOptIsHash.call(opts, :delegate)
+            Utils::CheckOptIsHash.call(opts, :delegate)
 
             delegate_opts = opts[:delegate]
             check_opt_delegate_to(delegate_opts)
@@ -36,13 +36,13 @@ class Serega
             to_exist = delegate_opts.key?(:to)
             raise SeregaError, "Option :delegate must have a :to option" unless to_exist
 
-            SeregaUtils::CheckOptIsStringOrSymbol.call(delegate_opts, :to)
+            Utils::CheckOptIsStringOrSymbol.call(delegate_opts, :to)
           end
 
           def check_opt_delegate_allow_nil(delegate_opts)
             return unless delegate_opts.key?(:allow_nil)
 
-            SeregaUtils::CheckOptIsBool.call(delegate_opts, :allow_nil)
+            Utils::CheckOptIsBool.call(delegate_opts, :allow_nil)
           end
 
           def check_usage_with_other_params(opts, block)

data/lib/serega/validations/attribute/check_opt_hide.rb

@@ -14,7 +14,7 @@ class Serega
         # @return [void]
         #
         def self.call(opts)
-          SeregaUtils::CheckOptIsBool.call(opts, :hide)
+          Utils::CheckOptIsBool.call(opts, :hide)
         end
       end
     end

data/lib/serega/validations/attribute/check_opt_key.rb

@@ -18,7 +18,7 @@ class Serega
             return unless opts.key?(:key)
 
             check_usage_with_other_params(opts, block)
-            SeregaUtils::CheckOptIsStringOrSymbol.call(opts, :key)
+            Utils::CheckOptIsStringOrSymbol.call(opts, :key)
           end
 
           private

data/lib/serega/validations/attribute/check_opt_many.rb

@@ -14,7 +14,7 @@ class Serega
         # @return [void]
         #
         def self.call(opts)
-          SeregaUtils::CheckOptIsBool.call(opts, :many)
+          Utils::CheckOptIsBool.call(opts, :many)
         end
       end
     end

data/lib/serega/validations/check_attribute_params.rb

@@ -25,7 +25,7 @@ class Serega
         end
 
         def check_opts
-          SeregaUtils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+          Utils::CheckAllowedKeys.call(opts, allowed_opts_keys)
 
           Attribute::CheckOptConst.call(opts, block)
           Attribute::CheckOptDelegate.call(opts, block)
@@ -41,7 +41,7 @@ class Serega
         end
 
         def allowed_opts_keys
-          self.class.serializer_class.config[:attribute_keys]
+          self.class.serializer_class.config.attribute_keys
         end
       end
 

data/lib/serega/validations/check_initiate_params.rb

@@ -3,23 +3,36 @@
 class Serega
   module SeregaValidations
     class CheckInitiateParams
-      module ClassMethods
-        def call(opts)
-          check_opts(opts)
+      module InstanceMethods
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def validate
+          check_allowed_keys
+          check_modifiers
         end
 
         private
 
-        def check_opts(opts)
-          SeregaUtils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+        def check_allowed_keys
+          Utils::CheckAllowedKeys.call(opts, serializer_class.config.initiate_keys)
+        end
+
+        def check_modifiers
+          Initiate::CheckModifiers.call(serializer_class, opts[:only])
+          Initiate::CheckModifiers.call(serializer_class, opts[:except])
+          Initiate::CheckModifiers.call(serializer_class, opts[:with])
         end
 
-        def allowed_opts_keys
-          serializer_class.config[:initiate_keys]
+        def serializer_class
+          self.class.serializer_class
         end
       end
 
-      extend ClassMethods
+      include InstanceMethods
       extend Serega::SeregaHelpers::SerializerClassHelper
     end
   end

data/lib/serega/validations/check_serialize_params.rb

@@ -3,26 +3,32 @@
 class Serega
   module SeregaValidations
     class CheckSerializeParams
-      module ClassMethods
-        def call(opts)
-          check_opts(opts)
+      module InstanceMethods
+        attr_reader :opts
+
+        def initialize(opts)
+          @opts = opts
+        end
+
+        def validate
+          check_opts
         end
 
         private
 
-        def check_opts(opts)
-          SeregaUtils::CheckAllowedKeys.call(opts, allowed_opts_keys)
+        def check_opts
+          Utils::CheckAllowedKeys.call(opts, serializer_class.config.serialize_keys)
 
-          SeregaUtils::CheckOptIsHash.call(opts, :context)
-          SeregaUtils::CheckOptIsBool.call(opts, :many)
+          Utils::CheckOptIsHash.call(opts, :context)
+          Utils::CheckOptIsBool.call(opts, :many)
         end
 
-        def allowed_opts_keys
-          serializer_class.config[:serialize_keys]
+        def serializer_class
+          self.class.serializer_class
         end
       end
 
-      extend ClassMethods
+      include InstanceMethods
       extend Serega::SeregaHelpers::SerializerClassHelper
     end
   end

data/lib/serega/{plugins/validate_modifiers/validate.rb → validations/initiate/check_modifiers.rb}

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 
 class Serega
-  class AttributeNotExist < SeregaError
-  end
-
-  module SeregaPlugins
-    module ValidateModifiers
-      class Validate
+  module SeregaValidations
+    module Initiate
+      class CheckModifiers
         class << self
           def call(serializer_class, fields)
             return unless fields

data/lib/serega/validations/utils/check_allowed_keys.rb

@@ -2,7 +2,7 @@
 
 class Serega
   module SeregaValidations
-    module SeregaUtils
+    module Utils
       class CheckAllowedKeys
         def self.call(opts, allowed_keys)
           opts.each_key do |key|

data/lib/serega/validations/utils/check_opt_is_bool.rb

@@ -2,7 +2,7 @@
 
 class Serega
   module SeregaValidations
-    module SeregaUtils
+    module Utils
       class CheckOptIsBool
         def self.call(opts, key)
           return unless opts.key?(key)

data/lib/serega/validations/utils/check_opt_is_hash.rb

@@ -2,7 +2,7 @@
 
 class Serega
   module SeregaValidations
-    module SeregaUtils
+    module Utils
       class CheckOptIsHash
         def self.call(opts, key)
           return unless opts.key?(key)

data/lib/serega/validations/utils/check_opt_is_string_or_symbol.rb

@@ -2,7 +2,7 @@
 
 class Serega
   module SeregaValidations
-    module SeregaUtils
+    module Utils
       class CheckOptIsStringOrSymbol
         def self.call(opts, key)
           return unless opts.key?(key)

data/lib/serega.rb

@@ -4,9 +4,6 @@ require_relative "serega/version"
 
 # Parent class for your serializers
 class Serega
-  # A generic exception Serega uses.
-  class SeregaError < StandardError; end
-
   # @return [Hash] frozen hash
   FROZEN_EMPTY_HASH = {}.freeze
 
@@ -14,11 +11,11 @@ class Serega
   FROZEN_EMPTY_ARRAY = [].freeze
 end
 
+require_relative "serega/errors"
 require_relative "serega/helpers/serializer_class_helper"
 require_relative "serega/utils/enum_deep_dup"
 require_relative "serega/utils/to_hash"
-require_relative "serega/utils/to_json"
-require_relative "serega/utils/as_json"
+require_relative "serega/json/adapter"
 
 require_relative "serega/attribute"
 require_relative "serega/validations/utils/check_allowed_keys"
@@ -34,6 +31,7 @@ require_relative "serega/validations/attribute/check_opt_key"
 require_relative "serega/validations/attribute/check_opt_many"
 require_relative "serega/validations/attribute/check_opt_serializer"
 require_relative "serega/validations/attribute/check_opt_value"
+require_relative "serega/validations/initiate/check_modifiers"
 require_relative "serega/validations/check_attribute_params"
 require_relative "serega/validations/check_initiate_params"
 require_relative "serega/validations/check_serialize_params"
@@ -45,25 +43,19 @@ require_relative "serega/map"
 require_relative "serega/plugins"
 
 class Serega
-  @config = SeregaConfig.new(
-    {
-      plugins: [],
-      initiate_keys: %i[only with except],
-      attribute_keys: %i[key value serializer many hide const delegate],
-      serialize_keys: %i[context many],
-      max_cached_map_per_serializer_count: 50,
-      to_json: ->(data) { SeregaUtils::ToJSON.call(data) }
-    }
-  )
+  @config = SeregaConfig.new
 
+  # Validates `Serializer.attribute` params
   check_attribute_params_class = Class.new(SeregaValidations::CheckAttributeParams)
   check_attribute_params_class.serializer_class = self
   const_set(:CheckAttributeParams, check_attribute_params_class)
 
+  # Validates `Serializer#new` params
   check_initiate_params_class = Class.new(SeregaValidations::CheckInitiateParams)
   check_initiate_params_class.serializer_class = self
   const_set(:CheckInitiateParams, check_initiate_params_class)
 
+  # Validates `serializer#call(obj, PARAMS)` params
   check_serialize_params_class = Class.new(SeregaValidations::CheckSerializeParams)
   check_serialize_params_class.serializer_class = self
   const_set(:CheckSerializeParams, check_serialize_params_class)
@@ -138,7 +130,7 @@ class Serega
       plugin.after_load_plugin(self, **opts) if plugin.respond_to?(:after_load_plugin)
 
       # Store attached plugins, so we can check it is loaded later
-      config[:plugins] << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
+      config.plugins << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
 
       plugin
     end
@@ -157,7 +149,7 @@ class Serega
         else name
         end
 
-      config[:plugins].include?(plugin_name)
+      config.plugins.include?(plugin_name)
     end
 
     #
@@ -184,7 +176,7 @@ class Serega
     end
 
     def call(object, opts = FROZEN_EMPTY_HASH)
-      initiate_keys = config[:initiate_keys]
+      initiate_keys = config.initiate_keys
       new(opts.slice(*initiate_keys)).to_h(object, opts.except(*initiate_keys))
     end
 
@@ -193,13 +185,12 @@ class Serega
     end
 
     def to_json(object, opts = FROZEN_EMPTY_HASH)
-      initiate_keys = config[:initiate_keys]
+      initiate_keys = config.initiate_keys
       new(opts.slice(*initiate_keys)).to_json(object, opts.except(*initiate_keys))
     end
 
     def as_json(object, opts = FROZEN_EMPTY_HASH)
-      initiate_keys = config[:initiate_keys]
-      new(opts.slice(*initiate_keys)).as_json(object, opts.except(*initiate_keys))
+      config.from_json.call(to_json(object, opts))
     end
   end
 
@@ -217,9 +208,8 @@ class Serega
     # @param with [Array, Hash, String, Symbol] Attributes (usually hidden) to serialize additionally
     #
     def initialize(opts = FROZEN_EMPTY_HASH)
-      self.class::CheckInitiateParams.call(opts)
-      opts = prepare_modifiers(opts) if opts && (opts != FROZEN_EMPTY_HASH)
-      @opts = opts
+      @opts = opts == FROZEN_EMPTY_HASH ? opts : prepare_modifiers(opts)
+      self.class::CheckInitiateParams.new(@opts).validate if opts.fetch(:check_initiate_params) { config.check_initiate_params }
     end
 
     #
@@ -231,7 +221,7 @@ class Serega
     # @return [Hash] Serialization result
     #
     def call(object, opts = {})
-      self.class::CheckSerializeParams.call(opts)
+      self.class::CheckSerializeParams.new(opts).validate
       opts[:context] ||= {}
 
       self.class::SeregaConvert.call(object, **opts, map: map)
@@ -249,37 +239,40 @@ class Serega
     #
     # @return [Hash] Serialization result
     #
-    def to_json(object, opts = FROZEN_EMPTY_HASH)
+    def to_json(object, opts = {})
       hash = to_h(object, opts)
-      self.class.config[:to_json].call(hash)
+      config.to_json.call(hash)
     end
 
     #
     # Serializes provided object as json (uses only JSON-compatible types)
-    # When you later serialize/deserialize it from JSON you should receive
+    # When you later serialize/de-serialize it from JSON you should receive
     # equal object
     #
     # @param object [Object] Serialized object
     #
     # @return [Hash] Serialization result
     #
-    def as_json(object, opts = FROZEN_EMPTY_HASH)
-      hash = to_h(object, opts)
-      SeregaUtils::AsJSON.call(hash, to_json: self.class.config[:to_json])
+    def as_json(object, opts = {})
+      json = to_json(object, opts)
+      config.from_json.call(json)
     end
 
     private
 
+    def config
+      self.class.config
+    end
+
     def map
       @map ||= self.class::SeregaMap.call(opts)
     end
 
     def prepare_modifiers(opts)
-      {
-        only: SeregaUtils::ToHash.call(opts[:only]),
-        except: SeregaUtils::ToHash.call(opts[:except]),
-        with: SeregaUtils::ToHash.call(opts[:with])
-      }
+      opts.each_with_object({}) do |(key, value), obj|
+        value = SeregaUtils::ToHash.call(value) if (key == :only) || (key == :except) || (key == :with)
+        obj[key] = value
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-01 00:00:00.000000000 Z
+date: 2022-08-09 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -23,7 +23,11 @@ files:
 - lib/serega/config.rb
 - lib/serega/convert.rb
 - lib/serega/convert_item.rb
+- lib/serega/errors.rb
 - lib/serega/helpers/serializer_class_helper.rb
+- lib/serega/json/adapter.rb
+- lib/serega/json/json.rb
+- lib/serega/json/oj.rb
 - lib/serega/map.rb
 - lib/serega/plugins.rb
 - lib/serega/plugins/activerecord_preloads/activerecord_preloads.rb
@@ -49,12 +53,8 @@ files:
 - lib/serega/plugins/root/root.rb
 - lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
-- lib/serega/plugins/validate_modifiers/validate.rb
-- lib/serega/plugins/validate_modifiers/validate_modifiers.rb
-- lib/serega/utils/as_json.rb
 - lib/serega/utils/enum_deep_dup.rb
 - lib/serega/utils/to_hash.rb
-- lib/serega/utils/to_json.rb
 - lib/serega/validations/attribute/check_block.rb
 - lib/serega/validations/attribute/check_name.rb
 - lib/serega/validations/attribute/check_opt_const.rb
@@ -67,6 +67,7 @@ files:
 - lib/serega/validations/check_attribute_params.rb
 - lib/serega/validations/check_initiate_params.rb
 - lib/serega/validations/check_serialize_params.rb
+- lib/serega/validations/initiate/check_modifiers.rb
 - lib/serega/validations/utils/check_allowed_keys.rb
 - lib/serega/validations/utils/check_opt_is_bool.rb
 - lib/serega/validations/utils/check_opt_is_hash.rb

data/lib/serega/plugins/validate_modifiers/validate_modifiers.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    module ValidateModifiers
-      def self.plugin_name
-        :validate_modifiers
-      end
-
-      def self.load_plugin(serializer_class, **_opts)
-        serializer_class.include(InstanceMethods)
-        require_relative "./validate"
-      end
-
-      def self.after_load_plugin(serializer_class, **opts)
-        serializer_class.config[:validate_modifiers] = {auto: opts.fetch(:auto, true)}
-      end
-
-      module InstanceMethods
-        # Raises error if some modifiers are invalid
-        def validate_modifiers
-          @modifiers_validated ||= begin
-            Validate.call(self.class, opts[:only])
-            Validate.call(self.class, opts[:except])
-            Validate.call(self.class, opts[:with])
-            true
-          end
-        end
-
-        private
-
-        def initialize(opts)
-          super
-          validate_modifiers if self.class.config[:validate_modifiers][:auto]
-        end
-      end
-
-      module InstanceMethods
-      end
-    end
-
-    register_plugin(ValidateModifiers.plugin_name, ValidateModifiers)
-  end
-end

data/lib/serega/utils/as_json.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaUtils
-    class AsJSON
-      DOUBLE_QUOTE = '"'
-
-      class << self
-        def call(data, to_json:)
-          case data
-          when Hash
-            data.each_with_object({}) do |(key, value), new_data|
-              new_key = key.to_s
-              new_value = call(value, to_json: to_json)
-              new_data[new_key] = new_value
-            end
-          when Array
-            data.map { |value| call(value, to_json: to_json) }
-          when NilClass, Integer, Float, String, TrueClass, FalseClass
-            data
-          when Symbol
-            data.to_s
-          else
-            res = to_json.call(data)
-            if res.start_with?(DOUBLE_QUOTE) && res.end_with?(DOUBLE_QUOTE)
-              res.delete_prefix!(DOUBLE_QUOTE)
-              res.delete_suffix!(DOUBLE_QUOTE)
-            end
-            res
-          end
-        end
-      end
-    end
-  end
-end

data/lib/serega/utils/to_json.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaUtils
-    class ToJSON
-      class << self
-        def call(data)
-          json_adapter.dump(data)
-        end
-
-        private
-
-        def json_adapter
-          @json_adapter ||= begin
-            require "json"
-            ::JSON
-          end
-        end
-      end
-    end
-  end
-end