serega 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d467016ac66fcd328919f3d7068dd556ac5a7768f657adb30948c2c316480a1
-  data.tar.gz: 3ae0c46dc6760cdf94299c0edc34b41a8b195cea92dff13b91a4017bb21653f7
+  metadata.gz: 6b6c3672a4fc40557f4fef3e650de56c84bf23d96defabd3f3f04aa5f273aa90
+  data.tar.gz: 79bcc2c3526b0ae141de69003e0834c94f9b7bade028cbc85bed20c3f3ba1757
 SHA512:
-  metadata.gz: 9f2a9f714be636a26f4ca2de8a5f692455080354f495dc5cc2d69dd874d207ddd0bc3286b47ea600ebf5a0ba2ddfd774d6876da67e82906d35319f4a54614caa
-  data.tar.gz: 766931dbb8aaa415dcc008a477258ba6f63ca35b664267278ee31ab0becc91f124e16eb1f57bd5968df03e333bb59c98a8396f796be84c254a76e674a472d6e1
+  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.2
+0.9.0

data/lib/serega/json/oj.rb

@@ -6,6 +6,9 @@ class Serega
     # JSON dump adapter for ::Oj
     #
     class OjDump
+      # Default Oj serialization options
+      OPTS = {mode: :compat}.freeze
+
       #
       # Dumps data to JSON string
       #
@@ -14,7 +17,7 @@ class Serega
       # @return [String] Data serialized to JSON
       #
       def self.call(data)
-        ::Oj.dump(data, mode: :compat)
+        ::Oj.dump(data, OPTS)
       end
     end
 

data/lib/serega/map.rb

@@ -35,7 +35,8 @@ class Serega
 
       def cached_map_for(opts, max_cache_size)
         @cache ||= {}
-        cache_key = opts.to_s
+        cache_key = construct_cache_key(opts)
+
         map = @cache[cache_key] ||= map_for(opts)
         @cache.shift if @cache.length > max_cache_size
         map
@@ -50,7 +51,8 @@ class Serega
       end
 
       def construct_map(serializer_class, only:, except:, with:)
-        serializer_class.attributes.each_with_object([]) do |(name, attribute), map|
+        map = []
+        serializer_class.attributes.each do |name, attribute|
           next unless attribute.visible?(only: only, except: except, with: with)
 
           nested_points =
@@ -65,6 +67,21 @@ class Serega
 
           map << serializer_class::SeregaMapPoint.new(attribute, nested_points)
         end
+        map
+      end
+
+      def construct_cache_key(opts, cache_key = nil)
+        return nil if opts.empty?
+
+        cache_key ||= +""
+
+        opts.each do |key, nested_opts|
+          cache_key.insert(-1, SeregaUtils::SymbolName.call(key))
+          cache_key.insert(-1, "-")
+          construct_cache_key(nested_opts, cache_key)
+        end
+
+        cache_key
       end
     end
 

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

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 class Serega
   module SeregaPlugins
     #
@@ -14,7 +16,7 @@ class Serega
     #   PostSerializer.new(only: "id,user(id,username)").to_h(post)
     #   PostSerializer.new(except: "user(username,email)").to_h(post)
     #   PostSerializer.new(with: "user(email)").to_h(post)
-
+    #
     #   # Modifiers can still be provided old way with nested hashes or arrays.
     #   PostSerializer.new(with: {user: %i[email, username]}).to_h(post)
     #
@@ -52,9 +54,11 @@ class Serega
         def parse(fields)
           res = {}
           attribute = +""
+          char = +""
           path_stack = nil
+          fields = StringIO.new(fields)
 
-          fields.each_char do |char|
+          while fields.read(1, char)
             case char
             when ","
               add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)

data/lib/serega/utils/symbol_name.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Serega
+  module SeregaUtils
+    #
+    # Utility to get frozen string from symbol in any ruby version
+    #
+    class SymbolName
+      class << self
+        #
+        # Returns frozen string corresponding to provided symbol
+        #
+        # @param key [Symbol]
+        #
+        # @return [String] frozen string corresponding to provided symbol
+        #
+        def call(key)
+          key.is_a?(String) ? key : to_frozen_string(key)
+        end
+
+        private
+
+        # :nocov:
+        if RUBY_VERSION < "3"
+          def to_frozen_string(key)
+            key.to_s.freeze
+          end
+        else
+          def to_frozen_string(key)
+            key.name
+          end
+        end
+        # :nocov:
+      end
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ class Serega
           # @return [void]
           #
           def call(name)
-            name = name.to_s
+            name = SeregaUtils::SymbolName.call(name)
 
             valid =
               case name.size

data/lib/serega.rb

@@ -16,6 +16,7 @@ end
 require_relative "serega/errors"
 require_relative "serega/helpers/serializer_class_helper"
 require_relative "serega/utils/enum_deep_dup"
+require_relative "serega/utils/symbol_name"
 require_relative "serega/utils/to_hash"
 require_relative "serega/json/adapter"
 
@@ -184,7 +185,7 @@ class Serega
     # Serializes provided object to Hash
     #
     # @param object [Object] Serialized object
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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
@@ -194,13 +195,23 @@ class Serega
     #
     # @return [Hash] Serialization result
     #
-    def call(object, opts = FROZEN_EMPTY_HASH)
+    def call(object, opts = nil)
+      opts ||= FROZEN_EMPTY_HASH
       initiate_keys = config.initiate_keys
-      new(opts.slice(*initiate_keys)).to_h(object, opts.except(*initiate_keys))
+
+      if opts.empty?
+        modifiers_opts = FROZEN_EMPTY_HASH
+        serialize_opts = nil
+      else
+        serialize_opts = opts.except(*initiate_keys)
+        modifiers_opts = opts.slice(*initiate_keys)
+      end
+
+      new(modifiers_opts).to_h(object, serialize_opts)
     end
 
     # @see #call
-    def to_h(object, opts = FROZEN_EMPTY_HASH)
+    def to_h(object, opts = nil)
       call(object, opts)
     end
 
@@ -208,7 +219,7 @@ class Serega
     # Serializes provided object to JSON string
     #
     # @param object [Object] Serialized object
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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
@@ -218,16 +229,15 @@ class Serega
     #
     # @return [String] Serialization result
     #
-    def to_json(object, opts = FROZEN_EMPTY_HASH)
-      initiate_keys = config.initiate_keys
-      new(opts.slice(*initiate_keys)).to_json(object, opts.except(*initiate_keys))
+    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] Serializer modifiers and other instantiating options
+    # @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
@@ -237,7 +247,7 @@ class Serega
     #
     # @return [Hash] Serialization result
     #
-    def as_json(object, opts = FROZEN_EMPTY_HASH)
+    def as_json(object, opts = nil)
       config.from_json.call(to_json(object, opts))
     end
   end
@@ -249,36 +259,37 @@ class Serega
     #
     # Instantiates new Serega class
     #
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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)
     #
-    def initialize(opts = FROZEN_EMPTY_HASH)
-      @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 }
+    def initialize(opts = nil)
+      @opts = (opts.nil? || opts.empty?) ? FROZEN_EMPTY_HASH : prepare_modifiers(opts)
+      self.class::CheckInitiateParams.new(@opts).validate if opts&.fetch(:check_initiate_params) { config.check_initiate_params }
     end
 
     #
     # Serializes provided object to Hash
     #
     # @param object [Object] Serialized object
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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 call(object, opts = {})
-      self.class::CheckSerializeParams.new(opts).validate
+    def call(object, opts = nil)
+      self.class::CheckSerializeParams.new(opts).validate if opts&.any?
+      opts ||= {}
       opts[:context] ||= {}
 
       serialize(object, opts)
     end
 
     # @see #call
-    def to_h(object, opts = {})
+    def to_h(object, opts = nil)
       call(object, opts)
     end
 
@@ -286,13 +297,13 @@ class Serega
     # Serializes provided object to JSON string
     #
     # @param object [Object] Serialized object
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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 = {})
+    def to_json(object, opts = nil)
       hash = to_h(object, opts)
       config.to_json.call(hash)
     end
@@ -301,13 +312,13 @@ class Serega
     # Serializes provided object as JSON
     #
     # @param object [Object] Serialized object
-    # @param opts [Hash] Serializer modifiers and other instantiating options
+    # @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 = {})
+    def as_json(object, opts = nil)
       json = to_json(object, opts)
       config.from_json.call(json)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: serega
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-20 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
@@ -73,6 +77,7 @@ files:
 - lib/serega/plugins/string_modifiers/parse_string_modifiers.rb
 - lib/serega/plugins/string_modifiers/string_modifiers.rb
 - lib/serega/utils/enum_deep_dup.rb
+- lib/serega/utils/symbol_name.rb
 - lib/serega/utils/to_hash.rb
 - lib/serega/validations/attribute/check_block.rb
 - lib/serega/validations/attribute/check_name.rb
@@ -114,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.15
+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