lazier 3.5.1 → 3.5.2

data/lib/lazier/hash.rb

@@ -22,8 +22,7 @@ module Lazier
     # @param validator [Proc], if present all the keys which evaluates to true will be removed. Otherwise all blank values will be removed.
     # @return [Hash] The hash with all blank values removed.
     def compact(&validator)
-      validator ||= ->(_, v) { v.blank? }
-      reject(&validator)
+      dup.compact!(&validator)
     end
 
     # Compacts the current hash, removing all keys which values are blank.
@@ -39,7 +38,7 @@ 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.inject(self) do |rv, access|
+      accesses.compact.reduce(self) do |rv, access|
         method = VALID_ACCESSES.fetch(access.ensure_string.to_sym, nil)
         rv = rv.send(method) if method
         rv
@@ -53,19 +52,28 @@ module Lazier
     def enable_dotted_access(readonly = true)
       extend(Hashie::Extensions::MethodReader)
       extend(Hashie::Extensions::MethodQuery)
-      extend(Hashie::Extensions::MethodWriter) if !readonly
+      extend(Hashie::Extensions::MethodWriter) unless readonly
 
       each do |_, value|
-        if value.is_a?(Hash) then
-          value.enable_dotted_access(readonly)
-        elsif value.respond_to?(:each) then
-          value.each do |element|
-            element.enable_dotted_access(readonly) if element.is_a?(Hash)
-          end
-        end
+        enable_dotted_access_for_value(value, readonly)
       end
 
       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.
+    def enable_dotted_access_for_value(value, readonly)
+      if value.is_a?(Hash)
+        value.enable_dotted_access(readonly)
+      elsif value.respond_to?(:each) then
+        value.each do |element|
+          element.enable_dotted_access(readonly) if element.is_a?(Hash)
+        end
+      end
+    end
   end
-end
+end

data/lib/lazier/i18n.rb

@@ -45,40 +45,41 @@ module Lazier
     end
 
     private
-      # Loads a locale for messages.
-      #
-      # @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)
 
-        begin
-          tokens = @i18n_root.to_s.split(/[:.]/)
-          translation = tokens.reduce(R18n::I18n.new(locales, path).t) {|accu, token| accu.send(token) }
-          raise ArgumentError if translation.is_a?(R18n::Untranslated)
-          translation
-        rescue
-          raise Lazier::Exceptions::MissingTranslation.new(locales, path)
-        end
-      end
+    # Loads a locale for messages.
+    #
+    # @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)
 
-      # Validates locales for messages.
-      #
-      # @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)
+      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)
       end
+    end
 
-      # Find a locale file in a path.
-      #
-      # @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.exists?("#{path}/#{l}.yml") }.first : nil
-      end
+    # Validates locales for messages.
+    #
+    # @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)
+    end
+
+    # Find a locale file in a path.
+    #
+    # @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
+    end
   end
-end
+end

data/lib/lazier/math.rb

@@ -28,4 +28,4 @@ module Lazier
       end
     end
   end
-end
+end

data/lib/lazier/object.rb

@@ -31,24 +31,36 @@ module Lazier
     # Checks if the object is a valid integer.
     #
     # @return [Boolean] `true` is a valid integer, `false` otherwise.
-    def is_integer?
-      is_a?(::Integer) || is_a?(::TrueClass) || !self || normalize_number =~ ::Lazier::Object::INTEGER_MATCHER
+    def integer?
+      numeric?(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 is_float?
-      is_a?(::Numeric) || is_a?(::TrueClass) || !self || normalize_number =~ ::Lazier::Object::FLOAT_MATCHER
+    def float?
+      numeric?(Numeric, ::Lazier::Object::FLOAT_MATCHER)
     end
-    alias :is_number? :is_float?
+    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
+    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 is_boolean?
+    def boolean?
       is_a?(::TrueClass) || !self || 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.
     #
@@ -76,7 +88,11 @@ module Lazier
     # @param stringifier [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)
-      !nil? ? (block_given? ? yield(self, default_value) : send(stringifier)) : default_value
+      if is_a?(NilClass)
+        default_value
+      else
+        block_given? ? yield(self, default_value) : send(stringifier)
+      end
     end
 
     # Makes sure that the object is an array. For non array objects, return a single element array containing the object.
@@ -89,44 +105,41 @@ module Lazier
     # @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)
-      rv = is_a?(::Array) ? dup : (default_value || (self.is_a?(NilClass) ? [] : [self]))
+      rv =
+        if is_a?(::Array)
+          dup
+        else
+          default_value || (self.is_a?(NilClass) ? [] : [self])
+        end
+
       rv = manipulate_array(rv, uniq, compact, flatten).map(&(block || sanitizer)) if block_given? || sanitizer
       manipulate_array(rv, uniq, 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 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 a block is present.*
+    # @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
+    #   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)
-      default_value = {} if default_value.nil?
+    def ensure_hash(access = nil, default_value = nil, sanitizer = nil, &block)
+      default_value = {} if default_value.is_a?(NilClass)
 
-      rv = if is_a?(::Hash) then
-        self
-      elsif default_value.is_a?(::Hash) then
-        default_value
-      else
-        key = default_value.is_a?(::String) || default_value.is_a?(::Symbol) ? default_value : :key
-        {key => self}
-      end
+      rv = convert_to_hash(default_value)
+      rv = sanitize_hash(rv, sanitizer, block) if block || sanitizer
 
-      if block_given? || sanitizer then
-        rv = rv.reduce({}) {|h, (k, v)|
-          h[k] = block_given? ? yield(v) : v.send(sanitizer)
-          h
-        }
-      end
-
-      rv.respond_to?(:ensure_access) ? rv.ensure_access(access) :rv
+      rv.respond_to?(:ensure_access) ? rv.ensure_access(access) : rv
     end
 
     # Converts the object to a boolean.
     #
     # @return [Boolean] The boolean representation of the object.
     def to_boolean
-      is_a?(TrueClass) || self == 1.0 || self == 1 || !!(ensure_string =~ ::Lazier::Object::BOOLEAN_TRUE_MATCHER) || false
+      is_a?(TrueClass) || to_integer == 1 || ::Lazier::Object::BOOLEAN_TRUE_MATCHER.match(ensure_string).is_a?(MatchData)
     end
 
     # Converts the object to a integer.
@@ -142,7 +155,11 @@ module Lazier
     # @param default_value [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)
-      is_float? ? ::Kernel.Float(is_a?(::Numeric) ? self : normalize_number) : default_value
+      if is_float?
+        ::Kernel.Float(is_a?(::Numeric) ? self : normalize_number)
+      else
+        default_value
+      end
     end
 
     # Returns the rounded float representaton of the object.
@@ -162,15 +179,14 @@ module Lazier
     # @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? then
+      if is_number?
         settings = ::Lazier.settings.format_number
         add_string ||= settings[:add_string]
 
-        rv = ("%0.#{[precision || settings[:precision], 0].max}f" % to_float).split(".")
+        rv = format("%0.#{[precision || settings[:precision], 0].max}f", to_float).split(".")
         rv[0].gsub!(/(\d)(?=(\d{3})+(?!\d))/, "\\1#{k_separator || settings[:k_separator]}")
         rv = rv.join(decimal_separator || settings[:decimal_separator])
-        rv += " #{add_string}" if add_string
-        rv
+        add_string ? rv + " #{add_string}" : rv
       else
         nil
       end
@@ -194,7 +210,7 @@ module Lazier
     # @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)
-      self.ensure_string.send(formatter, length, filler)
+      ensure_string.send(formatter, length, filler)
     end
 
     # Inspects an object.
@@ -203,29 +219,59 @@ module Lazier
     # @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
-          ::JSON.pretty_generate(self)
-        else
-          send("to_#{format}")
-      end
+      rv =
+        case format
+        when :pretty_json then ::JSON.pretty_generate(self)
+        else send("to_#{format}")
+        end
 
-      as_exception ? raise(::Lazier::Exceptions::Debug.new(rv)) : rv
+      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)
-        rv = rv.flatten if flatten
-        rv = rv.uniq if uniq
-        rv = rv.compact if compact
-        rv
+
+    # 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)
+      rv = rv.flatten if flatten
+      rv = rv.uniq if uniq
+      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)
+        self
+      elsif default_value.is_a?(::Hash)
+        default_value
+      else
+        key = default_value.is_a?(::String) || default_value.is_a?(::Symbol) ? default_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.
+    def sanitize_hash(hash, sanitizer, block)
+      hash.reduce({}) { |h, (k, v)|
+        h[k] = block ? block.call(v) : v.send(sanitizer)
+        h
+      }
+    end
   end
-end
+end

data/lib/lazier/pathname.rb

@@ -21,4 +21,4 @@ module Lazier
       each_filename.to_a
     end
   end
-end
+end

data/lib/lazier/settings.rb

@@ -66,7 +66,9 @@ module Lazier
     # @param k_separator [String] The string to use as thousands separator.
     # @return [Hash] The new formatters.
     def setup_format_number(precision = 2, decimal_separator = ".", add_string = nil, k_separator = ",")
-      @format_number = ::HashWithIndifferentAccess.new({precision: precision, decimal_separator: decimal_separator, add_string: add_string, k_separator: k_separator})
+      @format_number = ::HashWithIndifferentAccess.new(
+        precision: precision, decimal_separator: decimal_separator, add_string: add_string, k_separator: k_separator
+      )
     end
 
     # Setups strings representation of booleans.
@@ -105,7 +107,7 @@ module Lazier
     # @param short_days [Array] The abbreviated string representation of days.
     # @return [Hash] The new representations.
     def setup_date_names(long_months = nil, short_months = nil, long_days = nil, short_days = nil)
-      definitions = self.i18n.date
+      definitions = i18n.date
 
       @date_names = {
         long_months: long_months.ensure(definitions.long_months),

data/lib/lazier/string.rb

@@ -27,7 +27,7 @@ module Lazier
     # @return [String] The string with any invalid UTF-8 sequences replaced.
     def ensure_valid_utf8(replacement = "")
       # This odd line is because if need to specify a different encoding (without losing infos) to replace invalid bytes and then we go back to utf-8
-      !defined?(JRUBY_VERSION) ? encode("utf-16", invalid: :replace, undef: :replace, replace: replacement).encode("utf-8") : raise(RuntimeError.new("Sorry, Lazier::String#ensure_valid_utf8 is not available on JRuby."))
+      encode("utf-16", invalid: :replace, undef: :replace, replace: replacement).encode("utf-8")
     end
 
     # Returns the tagged version of a string.
@@ -66,11 +66,11 @@ module Lazier
     # @param pattern [String|Regexp] The pattern to use.
     # @return [Array] An array of tokens.
     def split_tokens(no_blanks = true, strip = true, uniq = false, pattern = /\s*,\s*/)
-      rv = self.split(pattern)
+      rv = split(pattern)
       rv.map!(&:strip) if strip
       rv.select!(&:present?) if no_blanks
       rv.uniq! if uniq
       rv
     end
   end
-end
+end

data/lib/lazier/version.rb

@@ -16,7 +16,7 @@ module Lazier
     MINOR = 5
 
     # The patch version.
-    PATCH = 1
+    PATCH = 2
 
     # The current version of lazier.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/spec/lazier/datetime_spec.rb

@@ -204,9 +204,9 @@ describe Lazier::TimeZone do
   let(:zone_without_dst) { ::ActiveSupport::TimeZone["International Date Line West"] }
 
   before(:all) do
+    ::Lazier.load!
     ::Lazier::Settings.instance(true)
     ::Lazier::Settings.instance.i18n = :en
-    ::Lazier.load!
   end
 
   describe ".rationalize_offset" do