serega 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 116b00d5c709f65a90899a9eda49f6e2c95cc9a47781a1cddf2499057553f427
-  data.tar.gz: 5f8fe19470218be68c09704964228be0381e677f5bd3cbcf9688f92974e9392d
+  metadata.gz: 6b6c3672a4fc40557f4fef3e650de56c84bf23d96defabd3f3f04aa5f273aa90
+  data.tar.gz: 79bcc2c3526b0ae141de69003e0834c94f9b7bade028cbc85bed20c3f3ba1757
 SHA512:
-  metadata.gz: 047de5335017cf65ee0f887124f81a755b94e19eea0e53a56ae24cb81698e7bdcc7e8eb6eba9256b5160a24bb011a5c0a1c1628cca77c7e7951b8883629ad96f
-  data.tar.gz: 5836df28c6e1cf2238d8c8471280dc806dd41a0cbbe474a101118d801e460830cda97dcb419e0885f9106d1e4e5ae795776ff5cc475555bdab6cb4c5408c1c94
+  metadata.gz: edcc6856f212848b721af517bb0f77695e6e7f2adbc7bb687e4573a62efe84e02266301cc3e70647b7cd8385b96901436ce1ded9446e9712f3884d8d6348c855
+  data.tar.gz: e0fec25bc4471ebbf3b6fbfb1967101af7f8cd7e703cb56eba935fd51bc6de0efe87d802be8257a950648afc633ed3ceb3bfc78f67b3905197ffa0a6e39ada32

data/README.md

@@ -20,6 +20,7 @@ It has some great features:
 - Built-in object presenter ([presenter][presenter] plugin)
 - Adding custom metadata (via [metadata][metadata] or [context_metadata][context_metadata] plugins)
 - Attributes formatters ([formatters][formatters] plugin)
+- Conditional attributes ([if][if] plugin)
 
 ## Installation
 
@@ -94,9 +95,11 @@ class UserSerializer < Serega
   # It allows to specify associations to preload to attribute value
   attribute :email, preload: :emails, value: proc { |user| user.emails.find(&:verified?) }
 
-  # Option `:hide_nil` can be specified when enabled `:hide_nil` plugin
-  # It is literally hides attribute if its value is nil
-  attribute :email, hide_nil: true
+  # Options `:if`, `:unless`, `:if_value`, `:unless_value` can be specified when enabled `:if` plugin
+  # They hide attribute key and value from response when conditions satisfied
+  # See more usage examples in :if plugin section.
+  attribute :email, if: proc { |user, ctx| user == ctx[:current_user] }
+  attribute :email, if_value: :present?
 
   # Option `:format` can be specified when enabled `:formatters` plugin
   # It changes attribute value
@@ -600,16 +603,45 @@ PostSerializer.new(with: "user(email)").to_h(post)
 PostSerializer.new(with: {user: %i[email, username]}).to_h(post)
 ```
 
-### Plugin :hide_nil
+### Plugin :if
 
-Allows to hide attributes with `nil` values
+Plugin adds `:if`, `:unless`, `:if_value`, `:unless_value` options to
+attributes so we can remove attributes from response in various ways.
 
-```ruby
-class UserSerializer < Serega
-  plugin :hide_nil
+Use `:if` and `:unless` when you want to hide attributes before finding attribute value,
+and use `:if_value` and `:unless_value` to hide attributes after we find final value.
 
-  attribute :email, hide_nil: true
-end
+Options `:if` and `:unless` accept currently serialized object and context as parameters.
+Options `:if_value` and `:unless_value` accept already found serialized value and context as parameters.
+
+Options `:if_value` and `:unless_value` cannot be used with :serializer option, as
+serialized objects have no "serialized value". Use `:if` and `:unless` in this case.
+
+See also a `:hide` option that is available without any plugins to hide
+attribute without conditions. Look at [select serialized fields](#selecting-fields) for `:hide` usage examples.
+
+```ruby
+ class UserSerializer < Serega
+   attribute :email, if: :active? # if user.active?
+   attribute :email, if: proc {|user| user.active?} # same
+   attribute :email, if: proc {|user, ctx| user == ctx[:current_user]} # using context
+   attribute :email, if: CustomPolicy.method(:view_email?) # You can provide own callable object
+
+   attribute :email, unless: :hidden? # unless user.hidden?
+   attribute :email, unless: proc {|user| user.hidden?} # same
+   attribute :email, unless: proc {|user, context| context[:show_emails]} # using context
+   attribute :email, unless: CustomPolicy.method(:hide_email?) # You can provide own callable object
+
+   attribute :email, if_value: :present? # if email.present?
+   attribute :email, if_value: proc {|email| email.present?} # same
+   attribute :email, if_value: proc {|email, ctx| ctx[:show_emails]} # using context
+   attribute :email, if_value: CustomPolicy.method(:view_email?) # You can provide own callable object
+
+   attribute :email, unless_value: :blank? # unless email.blank?
+   attribute :email, unless_value: proc {|email| email.blank?} # same
+   attribute :email, unless_value: proc {|email, context| context[:show_emails]} # using context
+   attribute :email, unless_value: CustomPolicy.method(:hide_email?) # You can provide own callable object
+ end
 ```
 
 ## Errors
@@ -648,3 +680,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [presenter]: #plugin-presenter
 [root]: #plugin-root
 [string_modifiers]: #plugin-string_modifiers
+[if]: #plugin-if

data/VERSION

@@ -1 +1 @@
-0.8.3
+0.9.0

data/lib/serega/object_serializer.rb

@@ -43,10 +43,14 @@ class Serega
 
       def serialize_object(object)
         points.each_with_object({}) do |point, container|
-          attach_value(object, point, container)
+          serialize_point(object, point, container)
         end
       end
 
+      def serialize_point(object, point, container)
+        attach_value(object, point, container)
+      end
+
       def attach_value(object, point, container)
         value = point.value(object, context)
         final_value = final_value(value, point)

data/lib/serega/plugins/batch/batch.rb

@@ -264,13 +264,17 @@ class Serega
           batch = point.batch
 
           if batch
-            key = batch.key.call(object, context)
-            opts[:batch_loaders].get(point, self).remember(key, container)
-            container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
+            remember_key_for_batch_loading(batch, object, point, container)
           else
             super
           end
         end
+
+        def remember_key_for_batch_loading(batch, object, point, container)
+          key = batch.key.call(object, context)
+          opts[:batch_loaders].get(point, self).remember(key, container)
+          container[point.name] = nil # Reserve attribute place in resulted hash. We will set correct value later
+        end
       end
     end
 

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    #
+    # Plugin adds `:if`, `:unless`, `:if_value`, `:unless_value` options to
+    # attributes so we can remove attributes from response in various ways.
+    #
+    # Use `:if` and `:unless` when you want to hide attributes before finding attribute value,
+    # and use `:if_value` and `:unless_value` to hide attributes after we find final value.
+    #
+    # Options `:if` and `:unless` accept currently serialized object and context as parameters.
+    # Options `:if_value` and `:unless_value` accept already found serialized value and context as parameters.
+    #
+    # Options `:if_value` and `:unless_value` cannot be used with :serializer option, as
+    # serialized objects have no "serialized value". Use `:if` and `:unless` in this case.
+    #
+    # See also a `:hide` option that is available without any plugins to hide
+    # attribute without conditions. Look at README.md#selecting-fields for `:hide` usage examples.
+    #
+    # Examples:
+    #  class UserSerializer < Serega
+    #    attribute :email, if: :active? # if user.active?
+    #    attribute :email, if: proc {|user| user.active?} # same
+    #    attribute :email, if: proc {|user, ctx| user == ctx[:current_user]} # using context
+    #    attribute :email, if: CustomPolicy.method(:view_email?) # You can provide own callable object
+    #
+    #    attribute :email, unless: :hidden? # unless user.hidden?
+    #    attribute :email, unless: proc {|user| user.hidden?} # same
+    #    attribute :email, unless: proc {|user, context| context[:show_emails]} # using context
+    #    attribute :email, unless: CustomPolicy.method(:hide_email?) # You can provide own callable object
+    #
+    #    attribute :email, if_value: :present? # if email.present?
+    #    attribute :email, if_value: proc {|email| email.present?} # same
+    #    attribute :email, if_value: proc {|email, ctx| ctx[:show_emails]} # using context
+    #    attribute :email, if_value: CustomPolicy.method(:view_email?) # You can provide own callable object
+    #
+    #    attribute :email, unless_value: :blank? # unless email.blank?
+    #    attribute :email, unless_value: proc {|email| email.blank?} # same
+    #    attribute :email, unless_value: proc {|email, context| context[:show_emails]} # using context
+    #    attribute :email, unless_value: CustomPolicy.method(:hide_email?) # You can provide own callable object
+    #  end
+    #
+    module If
+      # @return [Symbol] Plugin name
+      def self.plugin_name
+        :if
+      end
+
+      #
+      # Applies plugin code to specific serializer
+      #
+      # @param serializer_class [Class<Serega>] Current serializer class
+      # @param _opts [Hash] Loaded plugins options
+      #
+      # @return [void]
+      #
+      def self.load_plugin(serializer_class, **_opts)
+        require_relative "./validations/check_opt_if"
+        require_relative "./validations/check_opt_if_value"
+        require_relative "./validations/check_opt_unless"
+        require_relative "./validations/check_opt_unless_value"
+
+        serializer_class::SeregaMapPoint.include(MapPointInstanceMethods)
+        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
+        serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
+      end
+
+      # Checks requirements and loads additional plugins
+      #
+      # @param serializer_class [Class<Serega>] Current serializer class
+      # @param opts [Hash] loaded plugins opts
+      #
+      # @return [void]
+      #
+      def self.before_load_plugin(serializer_class, **opts)
+        if serializer_class.plugin_used?(:batch)
+          raise SeregaError, "Plugin `#{plugin_name}` must be loaded before `batch`"
+        end
+      end
+
+      #
+      # Adds config options and runs other callbacks after plugin was loaded
+      #
+      # @param serializer_class [Class<Serega>] Current serializer class
+      # @param opts [Hash] loaded plugins opts
+      #
+      # @return [void]
+      #
+      def self.after_load_plugin(serializer_class, **opts)
+        serializer_class.config.attribute_keys << :if << :if_value << :unless << :unless_value
+      end
+
+      #
+      # Serega::SeregaMapPoint additional/patched instance methods
+      #
+      # @see Serega::SeregaMapPoint::InstanceMethods
+      #
+      module MapPointInstanceMethods
+        #
+        # @return [Boolean] Should we show attribute or not
+        #   Conditions for this checks are specified by :if and :unless attribute options.
+        #
+        def satisfy_if_conditions?(obj, ctx)
+          check_if_unless(obj, ctx, :if, :unless)
+        end
+
+        #
+        # @return [Boolean] Should we show attribute with specific value or not.
+        #   Conditions for this checks are specified by :if_value and :unless_value attribute options.
+        #
+        def satisfy_if_value_conditions?(value, ctx)
+          check_if_unless(value, ctx, :if_value, :unless_value)
+        end
+
+        private
+
+        def check_if_unless(obj, ctx, opt_if_name, opt_unless_name)
+          opt_if = attribute.opts[opt_if_name]
+          opt_unless = attribute.opts[opt_unless_name]
+          return true if opt_if.nil? && opt_unless.nil?
+
+          res_if =
+            case opt_if
+            when NilClass then true
+            when Symbol then obj.public_send(opt_if)
+            else opt_if.call(obj, ctx)
+            end
+
+          res_unless =
+            case opt_unless
+            when NilClass then true
+            when Symbol then !obj.public_send(opt_unless)
+            else !opt_unless.call(obj, ctx)
+            end
+
+          res_if && res_unless
+        end
+      end
+
+      #
+      # Serega::SeregaValidations::CheckAttributeParams additional/patched class methods
+      #
+      # @see Serega::SeregaValidations::CheckAttributeParams
+      #
+      module CheckAttributeParamsInstanceMethods
+        private
+
+        def check_opts
+          super
+
+          CheckOptIf.call(opts)
+          CheckOptUnless.call(opts)
+          CheckOptIfValue.call(opts)
+          CheckOptUnlessValue.call(opts)
+        end
+      end
+
+      #
+      # SeregaObjectSerializer additional/patched class methods
+      #
+      # @see Serega::SeregaObjectSerializer
+      #
+      module SeregaObjectSerializerInstanceMethods
+        private
+
+        def serialize_point(object, point, _container)
+          return unless point.satisfy_if_conditions?(object, context)
+          super
+        end
+
+        def attach_final_value(value, point, _container)
+          return unless point.satisfy_if_value_conditions?(value, context)
+          super
+        end
+      end
+    end
+
+    register_plugin(If.plugin_name, If)
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module If
+      #
+      # Validator for attribute :if option
+      #
+      class CheckOptIf
+        class << self
+          #
+          # Checks attribute :if option that must be [nil, Symbol, Proc, #call]
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:if)
+
+            check_type(opts[:if])
+          end
+
+          private
+
+          def check_type(value)
+            return if value.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
+
+            if value.is_a?(Proc)
+              check_block(value)
+            else
+              check_callable(value)
+            end
+          end
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..2)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid attribute option :if. When it is a Proc it can have maximum two regular parameters (object, context)"
+          end
+
+          def callable_parameters_error
+            "Invalid attribute option :if. When it is a callable object it must have two regular parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid attribute option :if. It must be a Symbol, a Proc or respond to :call"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module If
+      #
+      # Validator for attribute :if_value option
+      #
+      class CheckOptIfValue
+        class << self
+          #
+          # Checks attribute :if_value option that must be [nil, Symbol, Proc, #call]
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:if_value)
+
+            check_usage_with_other_params(opts)
+            check_type(opts[:if_value])
+          end
+
+          private
+
+          def check_type(value)
+            return if value.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
+
+            if value.is_a?(Proc)
+              check_block(value)
+            else
+              check_callable(value)
+            end
+          end
+
+          def check_usage_with_other_params(opts)
+            raise SeregaError, "Option :if_value can not be used together with option :serializer" if opts.key?(:serializer)
+          end
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..2)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid attribute option :if_value. When it is a Proc it can have maximum two regular parameters (object, context)"
+          end
+
+          def callable_parameters_error
+            "Invalid attribute option :if_value. When it is a callable object it must have two regular parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid attribute option :if_value. It must be a Symbol, a Proc or respond to :call"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module If
+      #
+      # Validator for attribute :unless option
+      #
+      class CheckOptUnless
+        class << self
+          #
+          # Checks attribute :unless option that must be [nil, Symbol, Proc, #call]
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:unless)
+
+            check_type(opts[:unless])
+          end
+
+          private
+
+          #
+          # Checks attribute :unless option
+          #
+          # @param value [nil, Symbol, Proc, #call] Attribute :unless option
+          #
+          # @raise [SeregaError] validation error
+          #
+          # @return [void]
+          #
+          def check_type(value)
+            return if value.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
+
+            if value.is_a?(Proc)
+              check_block(value)
+            else
+              check_callable(value)
+            end
+          end
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..2)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid attribute option :unless. When it is a Proc it can have maximum two regular parameters (object, context)"
+          end
+
+          def callable_parameters_error
+            "Invalid attribute option :unless. When it is a callable object it must have two regular parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid attribute option :unless. It must be a Symbol, a Proc or respond to :call"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaPlugins
+    module If
+      #
+      # Validator for attribute :unless_value option
+      #
+      class CheckOptUnlessValue
+        class << self
+          #
+          # Checks attribute :unless_value option that must be [nil, Symbol, Proc, #call]
+          #
+          # @param opts [Hash] Attribute options
+          #
+          # @raise [SeregaError] Attribute validation error
+          #
+          # @return [void]
+          #
+          def call(opts)
+            return unless opts.key?(:unless_value)
+
+            check_usage_with_other_params(opts)
+            check_type(opts[:unless_value])
+          end
+
+          private
+
+          def check_type(value)
+            return if value.is_a?(Symbol)
+
+            raise SeregaError, must_be_callable unless value.respond_to?(:call)
+
+            if value.is_a?(Proc)
+              check_block(value)
+            else
+              check_callable(value)
+            end
+          end
+
+          def check_usage_with_other_params(opts)
+            raise SeregaError, "Option :unless_value can not be used together with option :serializer" if opts.key?(:serializer)
+          end
+
+          def check_block(block)
+            return if valid_parameters?(block, accepted_count: 0..2)
+
+            raise SeregaError, block_parameters_error
+          end
+
+          def check_callable(callable)
+            return if valid_parameters?(callable.method(:call), accepted_count: 2..2)
+
+            raise SeregaError, callable_parameters_error
+          end
+
+          def valid_parameters?(data, accepted_count:)
+            params = data.parameters
+            accepted_count.include?(params.count) && valid_parameters_types?(params)
+          end
+
+          def valid_parameters_types?(params)
+            params.all? do |param|
+              type = param[0]
+              (type == :req) || (type == :opt)
+            end
+          end
+
+          def block_parameters_error
+            "Invalid attribute option :unless_value. When it is a Proc it can have maximum two regular parameters (object, context)"
+          end
+
+          def callable_parameters_error
+            "Invalid attribute option :unless_value. When it is a callable object it must have two regular parameters (object, context)"
+          end
+
+          def must_be_callable
+            "Invalid attribute option :unless_value. It must be a Symbol, a Proc or respond to :call"
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.9.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-14 00:00:00.000000000 Z
+date: 2023-03-22 00:00:00.000000000 Z
 dependencies: []
 description: |
   JSON Serializer
@@ -53,7 +53,11 @@ files:
 - lib/serega/plugins/batch/lib/validations/check_opt_batch.rb
 - lib/serega/plugins/context_metadata/context_metadata.rb
 - lib/serega/plugins/formatters/formatters.rb
-- lib/serega/plugins/hide_nil/hide_nil.rb
+- lib/serega/plugins/if/if.rb
+- lib/serega/plugins/if/validations/check_opt_if.rb
+- lib/serega/plugins/if/validations/check_opt_if_value.rb
+- lib/serega/plugins/if/validations/check_opt_unless.rb
+- lib/serega/plugins/if/validations/check_opt_unless_value.rb
 - lib/serega/plugins/metadata/meta_attribute.rb
 - lib/serega/plugins/metadata/metadata.rb
 - lib/serega/plugins/metadata/validations/check_block.rb
@@ -115,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.7
 signing_key: 
 specification_version: 4
 summary: JSON Serializer

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-class Serega
-  module SeregaPlugins
-    #
-    # Plugin adds `:hide_nil` option to attributes to delete them from final result
-    # if value is nil
-    #
-    module HideNil
-      # @return [Symbol] Plugin name
-      def self.plugin_name
-        :hide_nil
-      end
-
-      #
-      # Applies plugin code to specific serializer
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param _opts [Hash] Loaded plugins options
-      #
-      # @return [void]
-      #
-      def self.load_plugin(serializer_class, **_opts)
-        serializer_class::SeregaAttribute.include(AttributeInstanceMethods)
-        serializer_class::CheckAttributeParams.include(CheckAttributeParamsInstanceMethods)
-        serializer_class::SeregaObjectSerializer.include(SeregaObjectSerializerInstanceMethods)
-      end
-
-      #
-      # Adds config options and runs other callbacks after plugin was loaded
-      #
-      # @param serializer_class [Class<Serega>] Current serializer class
-      # @param opts [Hash] loaded plugins opts
-      #
-      # @return [void]
-      #
-      def self.after_load_plugin(serializer_class, **opts)
-        serializer_class.config.attribute_keys << :hide_nil
-      end
-
-      #
-      # Serega::SeregaAttribute additional/patched instance methods
-      #
-      # @see Serega::SeregaValidations::CheckAttributeParams
-      #
-      module AttributeInstanceMethods
-        # Check hide_nil is specified
-        def hide_nil?
-          !!opts[:hide_nil]
-        end
-      end
-
-      #
-      # Serega::SeregaValidations::CheckAttributeParams additional/patched class methods
-      #
-      # @see Serega::SeregaValidations::CheckAttributeParams
-      #
-      module CheckAttributeParamsInstanceMethods
-        private
-
-        def check_opts
-          super
-          CheckOptHideNil.call(opts)
-        end
-      end
-
-      #
-      # Validator class for :hide_nil attribute option
-      #
-      class CheckOptHideNil
-        #
-        # Checks attribute :hide_nil option
-        #
-        # @param opts [Hash] Attribute options
-        #
-        # @raise [Serega::SeregaError] SeregaError that option has invalid value
-        #
-        # @return [void]
-        #
-        def self.call(opts)
-          return unless opts.key?(:hide_nil)
-
-          value = opts[:hide_nil]
-          return if (value == true) || (value == false)
-
-          raise SeregaError, "Invalid option :hide_nil => #{value.inspect}. Must have a boolean value"
-        end
-      end
-
-      #
-      # SeregaObjectSerializer additional/patched class methods
-      #
-      # @see Serega::SeregaObjectSerializer
-      #
-      module SeregaObjectSerializerInstanceMethods
-        private
-
-        def attach_final_value(final_value, *)
-          super unless final_value.nil?
-        end
-      end
-    end
-
-    register_plugin(HideNil.plugin_name, HideNil)
-  end
-end