serega 0.32.0 → 0.33.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06b324510e423bf61c19d440e522246d6d2223a5228a415a1fd5fcdbd87fd147
-  data.tar.gz: 5a31066675d38ad2c10032a6d9d7fdd9921db001a11e7b3916887a5215d1ab51
+  metadata.gz: 94fe2e370dea04c0bedcb7bed7f7f3b6f9ad9ff49a4c39367429929b5bc68e7e
+  data.tar.gz: 65cbab835785d14d8c17aba1ba6eff21b8abb9689eba2e4f15e28d68ee60cea9
 SHA512:
-  metadata.gz: 2da3083d578120365246d6b912777dc3d0c36a0dac1a09d4a0af0c5eeea6b398510b5f9dd5f7ca016c3d8d196c58f6990c39cee627646601d44682585b23e7de
-  data.tar.gz: e0389486ffdbf381d2db837bc7157a87224374abe8402f2b6d5bcd32e75a6cca72111bb38cb9b0955323af9774395a117d2e660725cbb1017e5a496390d7a923
+  metadata.gz: 9600ce857e2f2fd0836da34cec422eda2472e945a9c3fd94d4e4c9de7fb95e3ddb147b5ac59dc3c575695787fcb9634b9c1fc7cc512590b2da17e6ec492e9271
+  data.tar.gz: 7fa17d2686eb63a64b38cd7fea6a006de17497425a77f17a8619d112de8ca7b361549bcc5c0b03fd06c2bf842aec04f366d3aa5c63ae3b40b5e794b666a3a327

data/README.md

@@ -2,8 +2,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/serega.svg)](https://badge.fury.io/rb/serega)
 [![GitHub Actions](https://github.com/aglushkov/serega/actions/workflows/main.yml/badge.svg?event=push)](https://github.com/aglushkov/serega/actions/workflows/main.yml)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/f10c0659e16e25e49faa/test_coverage)](https://codeclimate.com/github/aglushkov/serega/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/f10c0659e16e25e49faa/maintainability)](https://codeclimate.com/github/aglushkov/serega/maintainability)
 
 The Serega Ruby Serializer provides easy and powerful DSL to describe your
 objects and serialize them to Hash or JSON.
@@ -143,9 +141,8 @@ end
 
 ### Serializing
 
-We can serialize objects using class methods `.to_h`, `.to_json`, `.as_json` and
-same instance methods `#to_h`, `#to_json`, `#as_json`.
-The `to_h` method is also aliased as `call`.
+We can serialize objects using class method `.call` aliased ad `.to_h` and
+same instance methods `#call` and its alias `#to_h`.
 
 ```ruby
 user = OpenStruct.new(username: 'serega')
@@ -156,12 +153,6 @@ end
 
 UserSerializer.to_h(user) # => {username: "serega"}
 UserSerializer.to_h([user]) # => [{username: "serega"}]
-
-UserSerializer.to_json(user) # => '{"username":"serega"}'
-UserSerializer.to_json([user]) # => '[{"username":"serega"}]'
-
-UserSerializer.as_json(user) # => {"username":"serega"}
-UserSerializer.as_json([user]) # => [{"username":"serega"}]
 ```
 
 If serialized fields are constant, then it's a good idea to initiate the
@@ -333,8 +324,8 @@ Named loaders can be defined using the `batch_loader` class method and reused ac
 ```ruby
 class UserSerializer < Serega
   # Define named loaders
-  batch_loader :comments_count, ->(users) { Comment.where(user: users).group(:user_id).count }
-  batch_loader :comments_count, CommentsCountLoader # Example with callable class
+  batch :comments_count, ->(users) { Comment.where(user: users).group(:user_id).count }
+  batch :comments_count, CommentsCountLoader # Example with callable class
 
   # Full attribute example
   attribute :comments_count, batch: { use: :comments_count },
@@ -373,8 +364,8 @@ Custom loaders can be provided directly using the `:use` option with any callabl
 ```ruby
 class UserSerializer < Serega
   # Define named loaders
-  batch_loader :facebook_likes, FacebookLikesLoader
-  batch_loader :twitter_likes, TwitterLikesLoader
+  batch :facebook_likes, FacebookLikesLoader
+  batch :twitter_likes, TwitterLikesLoader
 
   # Summarize likes
   attribute :likes_count,
@@ -389,16 +380,22 @@ Here are the default options. Other options can be added with plugins.
 
 ```ruby
 class AppSerializer < Serega
-  # Configure adapter to serialize to JSON.
-  # It is `JSON.dump` by default. But if the Oj gem is loaded, then the default
-  # is changed to `Oj.dump(data, mode: :compat)`
-  config.to_json = ->(data) { Oj.dump(data, mode: :compat) }
-
-  # Configure adapter to de-serialize JSON.
-  # De-serialization is used only for the `#as_json` method.
-  # It is `JSON.parse` by default.
-  # When the Oj gem is loaded, then the default is `Oj.load(data)`
-  config.from_json = ->(data) { Oj.load(data) }
+  # With `activerecord_preloads` plugin it automatically adds `preload` option
+  # to attributes with `:delegate` or `:serializer` option.
+  # It helps to preload associations automatically, omitting N+1 requests.
+  config.auto_preload = false
+
+  # Automatically marks as hidden attributes with `:preload` or `:batch` options.
+  # By default is false. Useful option to not make extra DB requests if attribute
+  # was not requested
+  config.auto_hide = false
+
+  # Default method used on serialized object to resolve batch value
+  # For example:
+  #   attribute :counter, batch: CounterBatchLoader
+  #   # Attribute values will be resolved as:
+  #   proc { |object, batches:| batches[:counter][object.id] }
+  config.batch_id_option = :id
 
   # Disable/enable validation of modifiers (`:with, :except, :only`)
   # By default, this validation is enabled.

data/VERSION

@@ -1 +1 @@
-0.32.0
+0.33.1

data/lib/serega/attribute_normalizer.rb

@@ -191,22 +191,18 @@ class Serega
       def prepare_const_block
         return unless init_opts.key?(:const)
 
-        const = init_opts[:const]
-        proc { const }
+        AttributeValueResolvers::ConstResolver.get(init_opts[:const])
       end
 
       def prepare_keyword_block
-        key_method_name = method_name
-        proc do |object|
-          object.public_send(key_method_name)
-        end
+        AttributeValueResolvers::KeywordResolver.get(method_name)
       end
 
       def prepare_batch_loader_block
         batch_opt = init_opts[:batch]
         return unless batch_opt
 
-        SeregaBatch::AutoResolverFactory.get(self.class.serializer_class, name, batch_opt)
+        AttributeValueResolvers::BatchResolver.get(self.class.serializer_class, name, batch_opt)
       end
 
       def prepare_batch_loaders
@@ -238,16 +234,7 @@ class Serega
         delegate_to = delegate[:to]
 
         allow_nil = delegate.fetch(:allow_nil) { config.delegate_default_allow_nil }
-
-        if allow_nil
-          proc do |object|
-            object.public_send(delegate_to)&.public_send(key_method_name)
-          end
-        else
-          proc do |object|
-            object.public_send(delegate_to).public_send(key_method_name)
-          end
-        end
+        AttributeValueResolvers::DelegateResolver.get(delegate_to, key_method_name, allow_nil)
       end
 
       # Prepares preloads

data/lib/serega/attribute_value_resolvers/batch.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Attribute value resolvers
+  #
+  module AttributeValueResolvers
+    #
+    # Builds value resolver class for attributes with :batch option
+    #
+    class BatchResolver
+      #
+      # Generates callable block to find attribute value when attribute with :batch
+      # option has no block or manual :value option.
+      #
+      # In other cases we should never get here as attribute value/block option must be manually defined.
+      #
+      # It handles this cases:
+      # - `attribute :foo, batch: true`
+      # - `attribute :foo, batch: FooLoader`
+      # - `attribute :foo, batch: { id: :foo_id }`
+      # - `attribute :foo, batch: { use: FooLoader, id: foo_id }`
+      # - `attribute :foo, batch: { use: :foo_loader, id: foo_id }`
+      #
+      def self.get(serializer_class, attribute_name, batch_opt)
+        default_method = serializer_class.config.batch_id_option
+
+        if batch_opt == true                        # ex: `batch: true`
+          batch_name = attribute_name
+          batch_id_method = default_method
+        elsif batch_opt.respond_to?(:call)          # ex: `batch: FooLoader`
+          serializer_class.batch(attribute_name, batch_opt)
+          batch_name = attribute_name
+          batch_id_method = default_method
+        else
+          use = batch_opt[:use]
+          batch_id_method = batch_opt[:id] || default_method
+
+          if use.respond_to?(:call)                 # ex: `batch: { use: FooLoader }`
+            batch_name = attribute_name
+            serializer_class.batch(batch_name, use)
+          else                                      # ex: `batch: { use: :foo }` || batch: { id: :some_id }
+            batch_name = use || attribute_name
+          end
+        end
+
+        Batch.new(batch_name, batch_id_method)
+      end
+    end
+
+    #
+    # Builds value resolver class for attributes with :batch option
+    #
+    class Batch
+      def initialize(loader_name, id_method)
+        @loader_name = loader_name
+        @id_method = id_method
+      end
+
+      # Finds object attribute value from hash of batch_loaded values
+      def call(obj, batches:)
+        batches.fetch(@loader_name)[obj.public_send(@id_method)]
+      end
+    end
+  end
+end

data/lib/serega/attribute_value_resolvers/const.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Attribute value resolvers
+  #
+  module AttributeValueResolvers
+    #
+    # Builds value resolver class for attributes with :const option
+    #
+    class ConstResolver
+      #
+      # Creates resolver that returns constant value
+      #
+      # @param const_value [Object] constant value to return
+      # @return [Const] resolver instance
+      #
+      def self.get(const_value)
+        Const.new(const_value)
+      end
+    end
+
+    #
+    # Value resolver class for attributes with :const option
+    #
+    class Const
+      def initialize(const_value)
+        @const_value = const_value
+      end
+
+      #
+      # Returns the constant value
+      #
+      # @return [Object] the constant value
+      #
+      def call
+        @const_value
+      end
+    end
+  end
+end

data/lib/serega/attribute_value_resolvers/delegate.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Attribute value resolvers
+  #
+  module AttributeValueResolvers
+    #
+    # Builds value resolver class for attributes with :delegate option
+    #
+    class DelegateResolver
+      #
+      # Creates resolver that delegates method call to another object
+      #
+      # @param delegate_to [Symbol] method to call on object to get delegated object
+      # @param method_name [Symbol] method to call on delegated object
+      # @param allow_nil [Boolean] whether to use safe navigation when delegated object is nil
+      # @return [Delegate, DelegateAllowNil] resolver instance
+      #
+      def self.get(delegate_to, method_name, allow_nil)
+        allow_nil ? DelegateAllowNil.new(delegate_to, method_name) : Delegate.new(delegate_to, method_name)
+      end
+    end
+
+    #
+    # Value resolver class for attributes with :delegate (with :allow_nil) option
+    #
+    class DelegateAllowNil
+      def initialize(delegate_to, method_name)
+        @delegate_to = delegate_to
+        @method_name = method_name
+      end
+
+      #
+      # Delegates method call to another object with safe navigation
+      #
+      # @param object [Object] the object to delegate from
+      # @return [Object, nil] result of delegated method call or nil if delegated object is nil
+      #
+      def call(object)
+        object.public_send(delegate_to)&.public_send(method_name)
+      end
+
+      private
+
+      attr_reader :delegate_to, :method_name
+    end
+
+    #
+    # Value resolver class for attributes with :delegate (without :allow_nil) option
+    #
+    class Delegate
+      def initialize(delegate_to, method_name)
+        @delegate_to = delegate_to
+        @method_name = method_name
+      end
+
+      #
+      # Delegates method call to another object
+      #
+      # @param object [Object] the object to delegate from
+      # @return [Object] result of delegated method call
+      #
+      def call(object)
+        object.public_send(@delegate_to).public_send(@method_name)
+      end
+    end
+  end
+end

data/lib/serega/attribute_value_resolvers/keyword.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Serega
+  #
+  # Attribute value resolvers
+  #
+  module AttributeValueResolvers
+    #
+    # Builds value resolver class for attributes with :keyword option
+    #
+    class KeywordResolver
+      #
+      # Creates resolver that calls method on object
+      #
+      # @param keyword [Symbol] method name to call on object
+      # @return [Keyword] resolver instance
+      #
+      def self.get(keyword)
+        Keyword.new(keyword)
+      end
+    end
+
+    #
+    # Value resolver class for attributes with :keyword option
+    #
+    class Keyword
+      def initialize(keyword)
+        @keyword = keyword
+      end
+
+      #
+      # Calls the keyword method on the object
+      #
+      # @param object [Object] the object to call method on
+      # @return [Object] result of method call
+      #
+      def call(object)
+        object.public_send(@keyword)
+      end
+    end
+  end
+end

data/lib/serega/batch/attribute_loader.rb

@@ -13,7 +13,7 @@ class Serega
         def initialize(point)
           @point = point
           @objects = []
-          @serialized_object_attachers = {}
+          @serialized_object_attachers = []
         end
 
         # Stores object with attacher to find and attach attribute values in batch later.
@@ -22,7 +22,7 @@ class Serega
         # @return [void]
         def store(object, attacher)
           objects << object
-          serialized_object_attachers[object] = attacher
+          serialized_object_attachers << [object, attacher]
         end
 
         # Loads serialized values for all stored objects for current attribute

data/lib/serega/config.rb

@@ -33,12 +33,7 @@ class Serega
       max_cached_plans_per_serializer_count: 0,
       auto_preload: {has_delegate_option: false, has_serializer_option: false},
       auto_hide: {has_preload_option: false, has_batch_option: false},
-      # auto_preload_attributes_with_delegate: false,
-      # auto_preload_attributes_with_serializer: false,
-      # auto_hide_attributes_with_preload: false,
-      # hide_batch_attributes: false,
-      to_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjDump : SeregaJSON::JSONDump,
-      from_json: (SeregaJSON.adapter == :oj) ? SeregaJSON::OjLoad : SeregaJSON::JSONLoad
+      batch_id_option: :id
     }.freeze
     # :nocov:
 
@@ -82,7 +77,7 @@ class Serega
         opts.fetch(:attribute_keys)
       end
 
-      # Returns options names allowed in `to_h, to_json, as_json` methods
+      # Returns options names allowed in `call, to_h` methods
       # @return [Array<Symbol>] Allowed options keys for serialization
       def serialize_keys
         opts.fetch(:serialize_keys)
@@ -191,30 +186,19 @@ class Serega
         opts[:check_attribute_name] = value
       end
 
-      # Returns current `to_json` adapter
-      # @return [#call] Callable that used to construct JSON
-      def to_json
-        opts.fetch(:to_json)
+      # Returns current batch_id_option
+      def batch_id_option
+        opts.fetch(:batch_id_option)
       end
 
-      # Sets current `to_json` adapter
-      # @param value [#call] Callable that used to construct JSON
-      # @return [#call] Provided callable object
-      def to_json=(value)
-        opts[:to_json] = value
-      end
-
-      # Returns current `from_json` adapter
-      # @return [#call] Callable that used to parse JSON
-      def from_json
-        opts.fetch(:from_json)
-      end
-
-      # Sets current `from_json` adapter
-      # @param value [#call] Callable that used to parse JSON
-      # @return [#call] Provided callable object
-      def from_json=(value)
-        opts[:from_json] = value
+      # Sets :batch_id_option config option
+      #
+      # @param value [Symbol] Set :batch_id_option config option
+      #
+      # @return [Symbol] New :check_attribute_name config option
+      def batch_id_option=(value)
+        raise SeregaError, "Must have Symbol value, #{value.inspect} provided" unless value.is_a?(Symbol)
+        opts[:batch_id_option] = value
       end
     end
 

data/lib/serega/plugins/if/if.rb

@@ -128,12 +128,31 @@ class Serega
 
         def prepare_if_option(if_option)
           return unless if_option
-          return proc { |val| val.public_send(if_option) } if if_option.is_a?(Symbol)
+          return KeywordConditionResolver.new(if_option) if if_option.is_a?(Symbol)
 
           if_option
         end
       end
 
+      #
+      # Resolves keyword-based conditions for if/unless options
+      #
+      class KeywordConditionResolver
+        def initialize(keyword)
+          @keyword = keyword
+        end
+
+        #
+        # Calls the keyword method on the object
+        #
+        # @param object [Object] the object to call method on
+        # @return [Object] result of method call
+        #
+        def call(object)
+          object.public_send(@keyword)
+        end
+      end
+
       #
       # SeregaAttribute additional/patched instance methods
       #

data/lib/serega.rb

@@ -23,14 +23,14 @@ require_relative "serega/utils/preload_paths"
 require_relative "serega/utils/preloads_constructor"
 require_relative "serega/utils/symbol_name"
 require_relative "serega/utils/to_hash"
-require_relative "serega/json/adapter"
-
+require_relative "serega/attribute_value_resolvers/batch"
+require_relative "serega/attribute_value_resolvers/const"
+require_relative "serega/attribute_value_resolvers/delegate"
+require_relative "serega/attribute_value_resolvers/keyword"
 require_relative "serega/attribute"
 require_relative "serega/attribute_normalizer"
 require_relative "serega/batch/attribute_loader"
 require_relative "serega/batch/attribute_loaders"
-require_relative "serega/batch/auto_resolver"
-require_relative "serega/batch/auto_resolver_factory"
 require_relative "serega/batch/loader"
 require_relative "serega/validations/utils/check_allowed_keys"
 require_relative "serega/validations/utils/check_opt_is_bool"
@@ -78,7 +78,7 @@ class Serega
   check_serialize_params_class.serializer_class = self
   const_set(:CheckSerializeParams, check_serialize_params_class)
 
-  # Validates `Serializer.batch_loader` params
+  # Validates `Serializer.batch` params
   check_batch_loader_params_class = Class.new(SeregaValidations::CheckBatchLoaderParams)
   check_batch_loader_params_class.serializer_class = self
   const_set(:CheckBatchLoaderParams, check_batch_loader_params_class)
@@ -155,7 +155,7 @@ class Serega
     end
 
     #
-    # Lists batch loaders
+    # Lists defined batch loaders
     #
     # @return [Hash] batch loaders list
     #
@@ -184,7 +184,7 @@ class Serega
     # Defines a batch loader
     #
     # @example
-    #   batch_loader :tags, PostTagsLoader
+    #   batch :tags, PostTagsLoader
     #
     # @example with block
     #   batch_loader(:tags) do |posts|
@@ -208,7 +208,7 @@ class Serega
     #
     # @return [#call] Batch loader
     #
-    def batch_loader(name, value = nil, &block)
+    def batch(name, value = nil, &block)
       raise SeregaError, "Batch loader must be defined with a callable value or block" if (value && block) || (!value && !block)
 
       batch_loader = self::SeregaBatchLoader.new(name: name, block: value || block)
@@ -245,59 +245,7 @@ class Serega
       new(modifiers_opts).to_h(object, serialize_opts)
     end
 
-    #
-    # Serializes provided object to Hash
-    #
-    # @param object [Object] Serialized object
-    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
-    # @option opts [Array, Hash, String, Symbol] :only The only attributes to serialize
-    # @option opts [Array, Hash, String, Symbol] :except Attributes to hide
-    # @option opts [Array, Hash, String, Symbol] :with Attributes (usually hidden) to serialize additionally
-    # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
-    # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
-    #
-    # @return [Hash] Serialization result
-    #
-    def to_h(object, opts = nil)
-      call(object, opts)
-    end
-
-    #
-    # Serializes provided object to JSON string
-    #
-    # @param object [Object] Serialized object
-    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
-    # @option opts [Array, Hash, String, Symbol] :only The only attributes to serialize
-    # @option opts [Array, Hash, String, Symbol] :except Attributes to hide
-    # @option opts [Array, Hash, String, Symbol] :with Attributes (usually hidden) to serialize additionally
-    # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
-    # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
-    #
-    # @return [String] Serialization result
-    #
-    def to_json(object, opts = nil)
-      config.to_json.call(to_h(object, opts))
-    end
-
-    #
-    # Serializes provided object as JSON
-    #
-    # @param object [Object] Serialized object
-    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
-    # @option opts [Array, Hash, String, Symbol] :only The only attributes to serialize
-    # @option opts [Array, Hash, String, Symbol] :except Attributes to hide
-    # @option opts [Array, Hash, String, Symbol] :with Attributes (usually hidden) to serialize additionally
-    # @option opts [Boolean] :validate Validates provided modifiers (Default is true)
-    # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
-    #
-    # @return [Hash] Serialization result
-    #
-    def as_json(object, opts = nil)
-      config.from_json.call(to_json(object, opts))
-    end
+    alias_method :to_h, :call
 
     private
 
@@ -362,7 +310,7 @@ class Serega
 
       # Assign same batch loaders
       batch_loaders.each_value do |loader|
-        subclass.batch_loader(loader.name, loader.block)
+        subclass.batch(loader.name, loader.block)
       end
 
       super
@@ -431,36 +379,6 @@ class Serega
       @preloads ||= SeregaUtils::PreloadsConstructor.call(plan)
     end
 
-    #
-    # Serializes provided object to JSON string
-    #
-    # @param object [Object] Serialized object
-    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
-    # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
-    #
-    # @return [Hash] Serialization result
-    #
-    def to_json(object, opts = nil)
-      hash = to_h(object, opts)
-      config.to_json.call(hash)
-    end
-
-    #
-    # Serializes provided object as JSON
-    #
-    # @param object [Object] Serialized object
-    # @param opts [Hash, nil] Serializer modifiers and other instantiating options
-    # @option opts [Hash] :context Serialization context
-    # @option opts [Boolean] :many Set true if provided multiple objects (Default `object.is_a?(Enumerable)`)
-    #
-    # @return [Hash] Serialization result
-    #
-    def as_json(object, opts = nil)
-      json = to_json(object, opts)
-      config.from_json.call(json)
-    end
-
     private
 
     attr_reader :opts

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.33.1
 platform: ruby
 authors:
 - Andrey Glushkov
@@ -29,17 +29,16 @@ files:
 - lib/serega.rb
 - lib/serega/attribute.rb
 - lib/serega/attribute_normalizer.rb
+- lib/serega/attribute_value_resolvers/batch.rb
+- lib/serega/attribute_value_resolvers/const.rb
+- lib/serega/attribute_value_resolvers/delegate.rb
+- lib/serega/attribute_value_resolvers/keyword.rb
 - lib/serega/batch/attribute_loader.rb
 - lib/serega/batch/attribute_loaders.rb
-- lib/serega/batch/auto_resolver.rb
-- lib/serega/batch/auto_resolver_factory.rb
 - lib/serega/batch/loader.rb
 - lib/serega/config.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/object_serializer.rb
 - lib/serega/plan.rb
 - lib/serega/plan_point.rb
@@ -122,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.7.2
 specification_version: 4
 summary: JSON Serializer
 test_files: []

data/lib/serega/batch/auto_resolver.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaBatch
-    #
-    # Automatically generated resolver for batch_loader
-    #
-    class AutoResolver
-      attr_reader :loader_name
-      attr_reader :id_method
-
-      def initialize(loader_name, id_method)
-        @loader_name = loader_name
-        @id_method = id_method
-      end
-
-      # Finds object attribute value from hash of batch_loaded values for all
-      # serialized objects
-      def call(obj, batches:)
-        batches.fetch(loader_name)[obj.public_send(id_method)]
-      end
-    end
-  end
-end

data/lib/serega/batch/auto_resolver_factory.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaBatch
-    #
-    # Factory generates callable object that should be able to take
-    # batch loaded results, current object, and find attribute value for this
-    # object
-    #
-    class AutoResolverFactory
-      #
-      # Generates callable block to find attribute value when attribute with :batch
-      # option has no block or manual :value option.
-      #
-      # It handles this cases:
-      # - `attribute :foo, batch: true`
-      # - `attribute :foo, batch: FooLoader`
-      # - `attribute :foo, batch: { id: :foo_id }`
-      # - `attribute :foo, batch: { use: FooLoader, id: foo_id }`
-      # - `attribute :foo, batch: { use: :foo_loader, id: foo_id }`
-      #
-      # In other cases we should never call tis method here.
-      #
-      def self.get(serializer_class, attribute_name, batch_opt)
-        if batch_opt == true                        # ex: `batch: true`
-          loader_name = attribute_name
-          loader_id_method = :id
-        elsif batch_opt.respond_to?(:call)          # ex: `batch: FooLoader`
-          serializer_class.batch_loader(attribute_name, batch_opt)
-          loader_name = attribute_name
-          loader_id_method = :id
-        else
-          use = batch_opt[:use]
-          loader_id_method = batch_opt[:id] || :id
-
-          if use.respond_to?(:call)                 # ex: `batch: { use: FooLoader }`
-            loader_name = attribute_name
-            serializer_class.batch_loader(loader_name, use)
-          else                                      # ex: `batch: { use: :foo }` || batch: { id: :some_id }
-            loader_name = use || attribute_name
-          end
-        end
-
-        AutoResolver.new(loader_name, loader_id_method)
-      end
-    end
-  end
-end

data/lib/serega/json/adapter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  #
-  # JSON adapters
-  #
-  module SeregaJSON
-    # Current JSON adapter
-    #
-    # @return [Symbol] Current JSON adapter name - :oj or :json
-    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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaJSON
-    #
-    # JSON dump adapter for ::JSON
-    #
-    class JSONDump
-      #
-      # Dumps data to JSON string
-      #
-      # @param data [Object] Anything
-      #
-      # @return [String] Data serialized to JSON
-      #
-      def self.call(data)
-        ::JSON.dump(data)
-      end
-    end
-
-    #
-    # JSON parse adapter for ::JSON
-    #
-    class JSONLoad
-      #
-      # Loads object from JSON string
-      #
-      # @param json_string [String] JSON String
-      #
-      # @return [Object] Deserialized data
-      #
-      def self.call(json_string)
-        ::JSON.parse(json_string)
-      end
-    end
-  end
-end

data/lib/serega/json/oj.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaJSON
-    #
-    # JSON dump adapter for ::Oj
-    #
-    class OjDump
-      # Default Oj serialization options
-      OPTS = {mode: :compat}.freeze
-
-      #
-      # Dumps data to JSON string
-      #
-      # @param data [Object] Anything
-      #
-      # @return [String] Data serialized to JSON
-      #
-      def self.call(data)
-        ::Oj.dump(data, OPTS)
-      end
-    end
-
-    #
-    # JSON parse adapter for ::Oj
-    #
-    class OjLoad
-      #
-      # Loads object from JSON string
-      #
-      # @param json_string [String] JSON String
-      #
-      # @return [Object] Deserialized data
-      #
-      def self.call(json_string)
-        ::Oj.load(json_string)
-      end
-    end
-  end
-end