lazier 3.5.7 → 4.0.0

data/lib/lazier/exceptions.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 #
 # This file is part of the lazier gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
@@ -11,14 +10,23 @@ module Lazier
     class Debug < ::RuntimeError
     end
 
-    # This exception is raised from {I18n I18n} if no valid translation are found in the specified path.
+    # This is the handler for the core I18n gem.
+    class TranslationExceptionHandler < ::I18n::ExceptionHandler
+      # :nodoc:
+      def call(exception, locale, key, options)
+        exception.is_a?(::I18n::MissingTranslation) ? raise(exception.to_exception) : super
+      end
+    end
+
+    # This exception is raised from {I18n I18n} if a string is not translatable.
     class MissingTranslation < RuntimeError
       # Creates a new missing translation exception.
       #
-      # @param locales [Array] The locales that was requested to load.
-      # @param path [String] The path where was request to search for translations.
-      def initialize(locales, path)
-        super("Unable to load any of the following translation in #{path}: #{locales.join(", ")}.")
+      # @param locale [Array] The locale that was requested to use.
+      # @param message [String] The message that was requested to translate.
+      def initialize(locale, message = nil)
+        locale, message = locale if message.nil?
+        super("Unable to load the translation \"#{message}\" for the locale \"#{locale}\".")
       end
     end
   end

data/lib/lazier/hash.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 #
 # This file is part of the lazier gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
@@ -38,11 +37,8 @@ module Lazier
     # @param accesses [Array] The requested access for the keys. Can be `:strings`, `:symbols` or `:indifferent`. If `nil` the keys are not modified.
     # @return [Hash] The current hash with keys modified.
     def ensure_access(*accesses)
-      accesses.compact.reduce(self) do |rv, access|
-        method = VALID_ACCESSES.fetch(access.ensure_string.to_sym, nil)
-        rv = rv.send(method) if method
-        rv
-      end
+      methods = accesses.ensure_array(compact: true, no_duplicates: true, flatten: true) { |m| VALID_ACCESSES[m.ensure_string.to_sym] }.compact
+      methods.reduce(self) { |a, e| a.send(e) }
     end
 
     # Makes sure that the hash is accessible using dotted notation. This is also applied to every embedded hash.
@@ -54,22 +50,18 @@ module Lazier
       extend(Hashie::Extensions::MethodQuery)
       extend(Hashie::Extensions::MethodWriter) unless readonly
 
-      each do |_, value|
-        enable_dotted_access_for_value(value, readonly)
-      end
+      each { |_, value| enable_dotted_access_for_value(value, readonly) }
 
       self
     end
 
-    # Makes sure that the value is accessible using dotted notation. This is also applied to every embedded hash.
-    #
-    # @param value [Object] The value to manipulate.
-    # @param readonly [Boolean] If the dotted notation is only enable for reading. `true` by default.
-    # @return [Hash] The current value enabled for dotted access.
+    private
+
+    # :nodoc:
     def enable_dotted_access_for_value(value, readonly)
       if value.is_a?(Hash)
         value.enable_dotted_access(readonly)
-      elsif value.respond_to?(:each) then
+      elsif value.respond_to?(:each)
         value.each do |element|
           element.enable_dotted_access(readonly) if element.is_a?(Hash)
         end

data/lib/lazier/i18n.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 #
 # This file is part of the lazier gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
@@ -7,79 +6,162 @@
 module Lazier
   # Provides an easy way to localized messages in a class.
   #
-  # @attribute [r] i18n_locale
+  # @attribute locale
   #   @return [String|Symbol|nil] The current locale.
-  # @attribute [r] i18n_root
+  # @attribute [r] root
   #   @return [Symbol] The root level of the translation.
-  # @attribute [r] i18n_locales_path
+  # @attribute [r] path
   #   @return [String] The path where the translations are stored.
-  module I18n
-    attr_reader :i18n_locale
-    attr_reader :i18n_root
-    attr_reader :i18n_locales_path
+  # @attribute [r] backend
+  #   @return [I18n::Backend] The backend used for translations.
+  class I18n
+    attr_accessor :locale
+    attr_reader :root, :path, :backend
 
-    # Setup all I18n translations.
+    # The default locale for new instances.
+    mattr_accessor :default_locale
+
+    # Returns the singleton instance of the settings.
     #
+    # @param locale [Symbol] The locale to use for translations. Default is the current system locale.
     # @param root [Symbol] The root level of the translation.
     # @param path [String] The path where the translations are stored.
-    def i18n_setup(root, path)
-      ::I18n.enforce_available_locales = true
-      @i18n_root = root.to_sym
-      @i18n_locales_path = path
+    # @param force [Boolean] If to force recreation of the instance.
+    # @return [I18n] The singleton instance of the i18n.
+    def self.instance(locale = nil, root: :lazier, path: nil, force: false)
+      @instance = nil if force
+      @instance ||= new(locale, root: root, path: path)
     end
 
-    # Get the list of available translation for the current locale.
+    # Creates a new I18n object.
     #
-    # @return [R18N::Translation] The translation object.
-    def i18n
-      @i18n ||= i18n_load_locale(nil)
+    # @param locale [Symbol] The locale to use. Defaults to the current locale.
+    # @param root [Symbol] The root level of the translation.
+    # @param path [String] The path where the translations are stored.
+    def initialize(locale = nil, root: :lazier, path: nil)
+      path ||= Lazier::ROOT + "/locales"
+      @root = root.to_sym
+      @path = File.absolute_path(path.to_s)
+
+      setup_backend
+
+      self.locale = (locale || Lazier::I18n.default_locale || system_locale).to_sym
+    end
+
+    # Reloads all the I18n translations.
+    def reload
+      # Extract the backend to an attribute
+      ::I18n.backend.load_translations
     end
 
-    # Set the current locale for messages.
+    # Gets the list of available translation for a locale.
     #
-    # @param locale [String|Symbol|nil] The new locale. Default is the current system locale.
-    # @return [R18n::Translation] The new translation object.
-    def i18n=(locale)
-      @i18n_locale = locale
-      @i18n = i18n_load_locale(locale)
+    # @param locale [Symbol] The locale to list. Defaults to the current locale.
+    # @return [Hash] The available translations for the specified locale.
+    def translations(locale = nil)
+      locale ||= @locale
+      @backend.send(:translations)[locale.to_sym] || {}
     end
 
-    private
+    # Sets the current locale.
+    #
+    # @param value [Symbol] The locale to use for translations. Default is the current system locale.
+    def locale=(value)
+      @locale = value.to_sym
+      ::I18n.locale = @locale
+    end
+
+    # Get the list of available translation for a locale.
+    #
+    # @return [Array] The list of available locales.
+    def locales
+      ::I18n.available_locales
+    end
 
-    # Loads a locale for messages.
+    # Localize a message.
     #
-    # @param locale [Symbol] The new locale. Default is the current system locale.
-    # @return [R18n::Translation] The new translation object.
-    def i18n_load_locale(locale)
-      path = @i18n_locales_path || ""
-      locales = validate_locales([locale], path)
+    # @param message [String|Symbol] The message to localize.
+    # @param args [Array] Optional arguments to localize the message.
+    # @return [String] The localized message.
+    def translate(message, **args)
+      # PI: Ignore reek on this.
+      message = "#{root}.#{message}" if message !~ /^(\.|::)/
 
       begin
-        tokens = @i18n_root.to_s.split(/[:.]/)
-        translation = tokens.reduce(R18n::I18n.new(locales, path).t) { |a, e| a.send(e) }
-        raise ArgumentError if translation.is_a?(R18n::Untranslated)
-        translation
-      rescue
-        raise Lazier::Exceptions::MissingTranslation.new(locales, path)
+        ::I18n.translate(message, **(args.merge(raise: true)))
+      rescue ::I18n::MissingTranslationData
+        raise Lazier::Exceptions::MissingTranslation, [locale, message]
       end
     end
+    alias_method :t, :translate
 
-    # Validates locales for messages.
+    # Localize a message in a specific locale.
     #
-    # @param locales [Array] The list of locales to validate. English is added as fallback.
-    # @param path [String] The path where look into.
-    # @return [Array] The list of valid locales.
-    def validate_locales(locales, path)
-      (locales + [ENV["LANG"], R18n::I18n.system_locale, "en"]).select { |l| find_locale_in_path(l, path) }.uniq.map(&:to_s)
+    # @param message [String|Symbol] The message to localize.
+    # @param locale [String|Symbol] The new locale to use for localization.
+    # @param args [Array] Optional arguments to localize the message.
+    # @return [String] The localized message.
+    def translate_in_locale(locale, message, *args)
+      with_locale(locale) { translate(message, *args) }
     end
+    alias_method :tl, :translate_in_locale
 
-    # Find a locale file in a path.
+    # Temporary sets a different locale and execute the given block.
     #
-    # @param locale [String] The locale to find.
-    # @param path [String] The path where look into.
-    # @return [String|nil] The version of the locale found or `nil`, if nothing was found.
-    def find_locale_in_path(locale, path)
-      locale ? [locale, locale[0, 5], locale[0, 2]].select { |l| File.exist?("#{path}/#{l}.yml") }.first : nil
+    # @param locale [String|Symbol] The new locale to use for localization.
+    def with_locale(locale)
+      old_locale = self.locale
+
+      begin
+        self.locale = locale
+        return yield
+      ensure
+        self.locale = old_locale
+      end
+    end
+
+    private
+
+    # :nodoc:
+    OSX_DETECTION = "defaults read .GlobalPreferences AppleLanguages | awk 'NR==2{gsub(/[ ,]/, \"\");print}'"
+
+    # :nodoc:
+    def system_locale
+      platform = Lazier.platform
+
+      if [:java, :osx, :posix].include?(platform)
+        send("system_locale_#{Lazier.platform}")
+      else
+        raise(RuntimeError)
+      end
+    rescue
+      "en"
+    end
+
+    # :nodoc:
+    def system_locale_java
+      Java.java.util.Locale.getDefault.toString
+    end
+
+    # :nodoc:
+    def system_locale_osx
+      `#{OSX_DETECTION}`.strip
+    end
+
+    # :nodoc:
+    def system_locale_posix
+      ENV["LANG"]
+    end
+
+    # :nodoc:
+    def setup_backend
+      ::I18n.enforce_available_locales = true
+      ::I18n.load_path += Dir["#{@path}/*.yml"]
+      ::I18n.load_path.uniq!
+      ::I18n.exception_handler = ::Lazier::Exceptions::TranslationExceptionHandler.new
+      reload
+
+      @backend = ::I18n.backend
     end
   end
 end

data/lib/lazier/math.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 #
 # This file is part of the lazier gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
@@ -13,18 +12,18 @@ module Lazier
     module ClassMethods
       # Returns the minimum value in the arguments
       #
-      # @param args [Array] A mapion of object to compare (with the `<` operator).
-      # @return [Object] The minimum value or `nil` (if the mapion is empty).
+      # @param args [Array] A list of objects to compare (with the `<` operator).
+      # @return [Object] The minimum value or `nil` (if the list is empty).
       def min(*args)
-        args.ensure_array.flatten.min
+        args.ensure_array(default: [], no_duplicates: true, compact: true, flatten: true).min
       end
 
       # Returns the maximum value in the arguments
       #
-      # @param args [Array] A mapion of object to compare (with the `>` operator).
-      # @return [Object] The maximum value or `nil` (if the mapion is empty).
+      # @param args [Array] A list of objects to compare (with the `>` operator).
+      # @return [Object] The maximum value or `nil` (if the list is empty).
       def max(*args)
-        args.ensure_array.flatten.max
+        args.ensure_array(default: [], no_duplicates: true, compact: true, flatten: true).max
       end
     end
   end

data/lib/lazier/object.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 #
 # This file is part of the lazier gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
 # Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
@@ -25,42 +24,36 @@ module Lazier
     #
     # @return [String] The normalized number.
     def normalize_number
-      is_boolean? ? to_i.to_s : ensure_string.strip.gsub(/[\.,](?=(.*[\.,]))/, "").gsub(",", ".")
+      boolean? ? to_i.to_s : ensure_string.strip.gsub(/[\.,](?=(.*[\.,]))/, "").gsub(",", ".")
+    end
+
+    # Checks if the object is of a numeric class of matches a numeric string expression.
+    #
+    # @return [Boolean] `true` is a valid numeric object, `false` otherwise.
+    def number?(klass = Integer, matcher = ::Lazier::Object::FLOAT_MATCHER)
+      nil? || is_a?(klass) || boolean? || normalize_number =~ matcher
     end
 
     # Checks if the object is a valid integer.
     #
     # @return [Boolean] `true` is a valid integer, `false` otherwise.
     def integer?
-      numeric?(Integer, ::Lazier::Object::INTEGER_MATCHER)
+      number?(Integer, ::Lazier::Object::INTEGER_MATCHER)
     end
-    alias_method :is_integer?, :integer?
 
     # Checks if the object is a valid float.
     #
     # @return [Boolean] `true` is a valid float, `false` otherwise.
     def float?
-      numeric?(Numeric, ::Lazier::Object::FLOAT_MATCHER)
-    end
-    alias_method :number?, :float?
-    alias_method :is_float?, :float?
-    alias_method :is_number?, :float?
-
-    # Checks if the object is of a numeric class of matches a numeric string expression.
-    #
-    # @return [Boolean] `true` is a valid numeric object, `false` otherwise.
-    def numeric?(klass = Integer, matcher = ::Lazier::Object::INTEGER_MATCHER)
-      is_a?(klass) || is_a?(::TrueClass) || !self || normalize_number =~ matcher
+      number?(Numeric, ::Lazier::Object::FLOAT_MATCHER)
     end
-    alias_method :is_numeric?, :numeric?
 
     # Checks if the object is a valid boolean value.
     #
     # @return [Boolean] `true` is a valid boolean value, `false` otherwise.
     def boolean?
-      is_a?(::TrueClass) || !self || to_s =~ ::Lazier::Object::BOOLEAN_MATCHER
+      nil? || is_a?(::TrueClass) || is_a?(::FalseClass) || to_s =~ ::Lazier::Object::BOOLEAN_MATCHER
     end
-    alias_method :is_boolean?, :boolean?
 
     # Sends a method to the object. If the objects doesn't not respond to the method, it returns `nil` instead of raising an exception.
     #
@@ -69,70 +62,71 @@ module Lazier
     # @param block [Proc] The block to pass to the method.
     # @return [Object|nil] The return value of the method or `nil`, if the object does not respond to the method.
     def safe_send(method, *args, &block)
-      respond_to?(method) ? send(method, *args, &block) : nil
+      send(method, *args, &block)
+    rescue NoMethodError
+      nil
     end
 
     # Makes sure that the object is set to something meaningful.
     #
-    # @param default_value [String] The default value to return if the `verifier` or the block returns true.
+    # @param default [String] The default value to return if the `verifier` or the block returns true.
     # @param verifier [Symbol] The method used to verify if the object is NOT meaningful. *Ignored if a block is passed.*
     # @return [String] The current object or the `default_value`.
-    def ensure(default_value, verifier = :blank?)
+    def ensure(default, verifier = :blank?)
       valid = block_given? ? yield(self) : send(verifier)
-      !valid ? self : default_value
+      !valid ? self : default
     end
 
     # Makes sure that the object is a string.
     #
-    # @param default_value [String] The default value to return if the object is `nil`. It is also passed to the block stringifier.
-    # @param stringifier [Symbol] The method used to convert the object to a string. *Ignored if a block is passed.*
+    # @param default [String] The default value to return if the object is `nil`. It is also passed to the block stringifier.
+    # @param conversion_method [Symbol] The method used to convert the object to a string. *Ignored if a block is passed.*
     # @return [String] The string representation of the object.
-    def ensure_string(default_value = "", stringifier = :to_s)
+    def ensure_string(default = "", conversion_method = :to_s)
       if is_a?(NilClass)
-        default_value
+        default
       else
-        block_given? ? yield(self, default_value) : send(stringifier)
+        block_given? ? yield(self, default) : send(conversion_method)
       end
     end
 
     # Makes sure that the object is an array. For non array objects, return a single element array containing the object.
     #
-    # @param default_value [Array|NilClass] The default array to use. If not specified, an array containing the object is returned.
-    # @param uniq [Boolean] If to remove duplicates from the array before sanitizing.
+    # @param default [Array|NilClass] The default array to use. If not specified, an array containing the object is returned.
+    # @param no_duplicates [Boolean] If to remove duplicates from the array before sanitizing.
     # @param compact [Boolean] If to compact the array before sanitizing.
     # @param flatten [Boolean] If to flatten the array before sanitizing.
     # @param sanitizer [Symbol|nil] If not `nil`, the method to use to sanitize entries of the array. *Ignored if a block is present.*
     # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
     # @return [Array] If the object is an array, then the object itself, a single element array containing the object otherwise.
-    def ensure_array(default_value = nil, uniq = false, compact = false, flatten = false, sanitizer = nil, &block)
+    def ensure_array(default: nil, no_duplicates: false, compact: false, flatten: false, sanitizer: nil, &block)
       rv =
         if is_a?(::Array)
-          dup
+          self
         else
-          default_value || (self.is_a?(NilClass) ? [] : [self])
+          default || [self].compact
         end
 
-      rv = manipulate_array(rv, uniq, compact, flatten).map(&(block || sanitizer)) if block_given? || sanitizer
-      manipulate_array(rv, uniq, compact, flatten)
+      rv = manipulate_array(rv, no_duplicates, compact, flatten).map(&(block || sanitizer)) if block_given? || sanitizer
+      manipulate_array(rv, no_duplicates, compact, flatten)
     end
 
     # Makes sure that the object is an hash. For non hash objects, return an hash basing on the `default_value` parameter.
     #
-    # @param access [Symbol|NilClass] The requested access for the keys of the returned object. Can be `:strings`, `:symbols` or `indifferent`.
-    #   If `nil` the keys are not modified.
-    # @param default_value [Hash|String|Symbol|NilClass] The default value to use. If it is an `Hash`, it is returned as value otherwise it is used to build
+    # @see Lazier::Hash#ensure_access
+    #
+    # @param accesses [Symbol|NilClass|Array] The requested access for the keys of the returned object.
+    # @param default [Hash|String|Symbol|NilClass] The default value to use. If it is an `Hash`, it is returned as value otherwise it is used to build
     #   as a key to build an hash with the current object as only value (everything but strings and symbols are mapped to `key`).
     #   Passing `nil` is equal to pass an empty Hash.
     # @param sanitizer [Symbol|nil] If not `nil`, the method to use to sanitize values of the hash. *Ignored if `block` is present.*
     # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
     # @return [Hash] If the object is an hash, then the object itself, a hash with the object as single value otherwise.
-    def ensure_hash(access = nil, default_value = nil, sanitizer = nil, &block)
-      default_value = {} if default_value.is_a?(NilClass)
-
-      rv = convert_to_hash(default_value)
+    def ensure_hash(accesses: nil, default: {}, sanitizer: nil, &block)
+      rv = convert_to_hash(default)
       rv = sanitize_hash(rv, sanitizer, block) if block || sanitizer
 
-      rv.respond_to?(:ensure_access) ? rv.ensure_access(access) : rv
+      rv.respond_to?(:ensure_access) ? rv.ensure_access(accesses.ensure_array) : rv
     end
 
     # Converts the object to a boolean.
@@ -144,30 +138,47 @@ module Lazier
 
     # Converts the object to a integer.
     #
-    # @param default_value [Fixnum] The value to return if the conversion is not possible.
+    # @param default [Fixnum] The value to return if the conversion is not possible.
     # @return [Fixnum] The integer representation of the object.
-    def to_integer(default_value = 0)
-      to_float(default_value).to_i
+    def to_integer(default = 0)
+      to_float(default).to_i
     end
 
     # Converts the object to a float.
     #
-    # @param default_value [Float] The value to return if the conversion is not possible.
+    # @param default [Float] The value to return if the conversion is not possible.
     # @return [Float] The float representation of the object.
-    def to_float(default_value = 0.0)
-      if is_float?
+    def to_float(default = 0.0)
+      if float?
         ::Kernel.Float(is_a?(::Numeric) ? self : normalize_number)
       else
-        default_value
+        default
       end
     end
 
+    # Converts an object to a pretty formatted JSON string.
+    #
+    # @return [String] The object as a pretty JSON string.
+    def to_pretty_json
+      Lazier.platform != :java ? Oj.dump(self, mode: :compat, indent: 2) : ::JSON.pretty_generate(self)
+    end
+
+    # Inspects an object.
+    #
+    # @param format The format to use. If different from `:pretty_json`, the object must respond to the `to_#{format}` method.
+    # @param as_exception [Boolean] If raise an exception.
+    # @return [String] The object inspected and formatted.
+    def to_debug(format: :pretty_json, as_exception: true)
+      rv = send("to_#{format}")
+      as_exception ? raise(::Lazier::Exceptions::Debug, rv) : rv
+    end
+
     # Returns the rounded float representaton of the object.
     #
     # @param precision [Fixnum] The precision to keep.
     # @return [Float] The rounded float representaton of the object.
     def round_to_precision(precision = 2)
-      is_number? ? to_float.round([precision, 0].max) : nil
+      number? ? to_float.round([precision, 0].max) : nil
     end
 
     # Formats a number.
@@ -178,8 +189,8 @@ module Lazier
     # @param add_string [String] The string to append to the number.
     # @param k_separator [String] The string to use as thousands separator.
     # @return [String] The string representation of the object.
-    def format_number(precision = nil, decimal_separator = nil, add_string = nil, k_separator = nil)
-      if is_number?
+    def format_number(precision: nil, decimal_separator: nil, add_string: nil, k_separator: nil)
+      if number?
         settings = ::Lazier.settings.format_number
         add_string ||= settings[:add_string]
 
@@ -198,7 +209,7 @@ module Lazier
     # @param true_name [String] The string representation of `true`. Defaults to `Yes`.
     # @param false_name [String] The string representation of `false`. Defaults to `No`.
     # @return [String] The string representation of the object.
-    def format_boolean(true_name = nil, false_name = nil)
+    def format_boolean(true_name: nil, false_name: nil)
       settings = ::Lazier.settings.boolean_names
       to_boolean ? (true_name || settings[true]) : (false_name || settings[false])
     end
@@ -209,67 +220,38 @@ module Lazier
     # @param filler [String] The minimum length of the label.
     # @param formatter [Symbol] The method to use to format the label. Must accept the `length` and the `filler arguments.
     # @return [String] The object inspected and formatted.
-    def indexize(length = 2, filler = "0", formatter = :rjust)
+    def indexize(length: 2, filler: "0", formatter: :rjust)
       ensure_string.send(formatter, length, filler)
     end
 
-    # Inspects an object.
-    #
-    # @param format The format to use.
-    # @param as_exception [Boolean] If raise an exception.
-    # @return [String] The object inspected and formatted.
-    def for_debug(format = :yaml, as_exception = true)
-      rv =
-        case format
-        when :pretty_json then ::JSON.pretty_generate(self)
-        else send("to_#{format}")
-        end
-
-      as_exception ? raise(::Lazier::Exceptions::Debug, rv) : rv
-    end
-
     private
 
-    # Performs manipulation on an array.
-    #
-    # @param rv [Array] The input array.
-    # @param uniq [Boolean] If to remove duplicates from the array.
-    # @param compact [Boolean] If to compact the array.
-    # @param flatten [Boolean] If to flatten the array.
-    # @return [Array] The manipulated array.
-    def manipulate_array(rv, uniq, compact, flatten)
+    # :nodoc:
+    def manipulate_array(rv, no_duplicates, compact, flatten)
       rv = rv.flatten if flatten
-      rv = rv.uniq if uniq
+      rv = rv.uniq if no_duplicates
       rv = rv.compact if compact
       rv
     end
 
-    # Converts the object to a hash.
-    #
-    # @param default_value [Hash|String|Symbol|NilClass] The default value to use. If it is an `Hash`, it is returned as value otherwise it is used to build
-    #   as a key to build an hash with the current object as only value (everything but strings and symbols are mapped to `key`).
-    #   Passing `nil` is equal to pass an empty Hash.
-    # @return [Hash] An hash.
-    def convert_to_hash(default_value)
-      if is_a?(::Hash)
+    # :nodoc:
+    def convert_to_hash(value)
+      if self.is_a?(::Hash)
         self
-      elsif default_value.is_a?(::Hash)
-        default_value
+      elsif value.is_a?(::Hash)
+        value
       else
-        key = default_value.is_a?(::String) || default_value.is_a?(::Symbol) ? default_value : :key
+        key = value.is_a?(::String) || value.is_a?(::Symbol) ? value : :key
         {key => self}
       end
     end
 
-    # Sanitizes an hash
-    #
-    # @param hash [Hash] The hash to sanitize.
-    # @param sanitizer [Symbol|nil] If not `nil`, the method to use to sanitize values of the hash. *Ignored if `block` is present.*
-    # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
-    # @return [Hash] The sanitized hash.
+    # :nodoc:
     def sanitize_hash(hash, sanitizer, block)
-      hash.reduce({}) { |h, (k, v)|
-        h[k] = block ? block.call(v) : v.send(sanitizer)
+      operator = block ? block : ->(v) { v.send(sanitizer) }
+
+      hash.reduce(hash.class.new) { |h, (k, v)|
+        h[k] = operator.call(v)
         h
       }
     end