serega 0.1.4 → 0.3.0

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 Error < 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"
@@ -29,10 +26,12 @@ require_relative "serega/validations/attribute/check_block"
 require_relative "serega/validations/attribute/check_name"
 require_relative "serega/validations/attribute/check_opt_const"
 require_relative "serega/validations/attribute/check_opt_hide"
+require_relative "serega/validations/attribute/check_opt_delegate"
 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"
@@ -44,55 +43,49 @@ require_relative "serega/map"
 require_relative "serega/plugins"
 
 class Serega
-  @config = Config.new(
-    {
-      plugins: [],
-      initiate_keys: %i[only with except],
-      attribute_keys: %i[key value serializer many hide const],
-      serialize_keys: %i[context many],
-      max_cached_map_per_serializer_count: 50,
-      to_json: ->(data) { Utils::ToJSON.call(data) }
-    }
-  )
-
-  check_attribute_params_class = Class.new(Validations::CheckAttributeParams)
+  @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)
 
-  check_initiate_params_class = Class.new(Validations::CheckInitiateParams)
+  # 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)
 
-  check_serialize_params_class = Class.new(Validations::CheckSerializeParams)
+  # 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)
 
   # Core serializer class methods
   module ClassMethods
-    # @return [Config] current serializer config
+    # @return [SeregaConfig] current serializer config
     attr_reader :config
 
     private def inherited(subclass)
-      config_class = Class.new(self::Config)
+      config_class = Class.new(self::SeregaConfig)
       config_class.serializer_class = subclass
-      subclass.const_set(:Config, config_class)
-      subclass.instance_variable_set(:@config, subclass::Config.new(config.opts))
+      subclass.const_set(:SeregaConfig, config_class)
+      subclass.instance_variable_set(:@config, subclass::SeregaConfig.new(config.opts))
 
-      attribute_class = Class.new(self::Attribute)
+      attribute_class = Class.new(self::SeregaAttribute)
       attribute_class.serializer_class = subclass
-      subclass.const_set(:Attribute, attribute_class)
+      subclass.const_set(:SeregaAttribute, attribute_class)
 
-      map_class = Class.new(self::Map)
+      map_class = Class.new(self::SeregaMap)
       map_class.serializer_class = subclass
-      subclass.const_set(:Map, map_class)
+      subclass.const_set(:SeregaMap, map_class)
 
-      convert_class = Class.new(self::Convert)
+      convert_class = Class.new(self::SeregaConvert)
       convert_class.serializer_class = subclass
-      subclass.const_set(:Convert, convert_class)
+      subclass.const_set(:SeregaConvert, convert_class)
 
-      convert_item_class = Class.new(self::ConvertItem)
+      convert_item_class = Class.new(self::SeregaConvertItem)
       convert_item_class.serializer_class = subclass
-      subclass.const_set(:ConvertItem, convert_item_class)
+      subclass.const_set(:SeregaConvertItem, convert_item_class)
 
       check_attribute_params_class = Class.new(self::CheckAttributeParams)
       check_attribute_params_class.serializer_class = subclass
@@ -123,9 +116,9 @@ class Serega
     # @return [class<Module>] Loaded plugin module
     #
     def plugin(name, **opts)
-      raise Error, "This plugin is already loaded" if plugin_used?(name)
+      raise SeregaError, "This plugin is already loaded" if plugin_used?(name)
 
-      plugin = Plugins.find_plugin(name)
+      plugin = SeregaPlugins.find_plugin(name)
 
       # We split loading of plugin to three parts - before_load, load, after_load:
       #
@@ -137,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
@@ -156,7 +149,7 @@ class Serega
         else name
         end
 
-      config[:plugins].include?(plugin_name)
+      config.plugins.include?(plugin_name)
     end
 
     #
@@ -175,29 +168,15 @@ class Serega
     # @param opts [Hash] Options to serialize attribute
     # @param block [Proc] Custom block to find attribute value. Accepts object and context.
     #
-    # @return [Serega::Attribute] Added attribute
+    # @return [Serega::SeregaAttribute] Added attribute
     #
     def attribute(name, **opts, &block)
-      attribute = self::Attribute.new(name: name, opts: opts, block: block)
+      attribute = self::SeregaAttribute.new(name: name, opts: opts, block: block)
       attributes[attribute.name] = attribute
     end
 
-    #
-    # Adds attribute with forced :serializer option
-    #
-    # @param name [Symbol] Attribute name. Attribute value will be found by executing `object.<name>`
-    # @param serializer [Serega, Proc] Specifies nested serializer for relationship
-    # @param opts [Hash] Options for attribute serialization
-    # @param block [Proc] Custom block to find attribute value. Accepts object and context.
-    #
-    # @return [Serega::Attribute] Added attribute
-    #
-    def relation(name, serializer:, **opts, &block)
-      attribute(name, serializer: serializer, **opts, &block)
-    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
 
@@ -206,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
 
@@ -230,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
 
     #
@@ -244,10 +221,10 @@ 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::Convert.call(object, **opts, map: map)
+      self.class::SeregaConvert.call(object, **opts, map: map)
     end
 
     # @see #call
@@ -262,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)
-      Utils::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::Map.call(opts)
+      @map ||= self.class::SeregaMap.call(opts)
     end
 
     def prepare_modifiers(opts)
-      {
-        only: Utils::ToHash.call(opts[:only]),
-        except: Utils::ToHash.call(opts[:except]),
-        with: Utils::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.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-25 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
@@ -43,20 +47,18 @@ files:
 - lib/serega/plugins/preloads/lib/main_preload_path.rb
 - lib/serega/plugins/preloads/lib/preloads_constructor.rb
 - lib/serega/plugins/preloads/preloads.rb
+- lib/serega/plugins/preloads/validations/check_opt_preload.rb
 - lib/serega/plugins/preloads/validations/check_opt_preload_path.rb
 - lib/serega/plugins/presenter/presenter.rb
 - 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
+- lib/serega/validations/attribute/check_opt_delegate.rb
 - lib/serega/validations/attribute/check_opt_hide.rb
 - lib/serega/validations/attribute/check_opt_key.rb
 - lib/serega/validations/attribute/check_opt_many.rb
@@ -65,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 Plugins
-    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 Utils
-    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 Utils
-    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