lazier 2.8.1 → 3.0.0

data/lib/lazier/exceptions.rb

@@ -7,18 +7,18 @@
 module Lazier
   # Exceptions for lazier.
   module Exceptions
-    # This exception is raised from {Object#debug_dump} when `must_raise` is `true`.
-    class Dump < ::StandardError
+    # This exception is raised to debug code.
+    class Debug < ::StandardError
     end
 
     # This exception is raised from {I18n I18n} if no valid translation are found in the specified path.
-    class MissingTranslation < Exception
+    class MissingTranslation < StandardError
       # 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.to_json}.")
+        super("Unable to load any of the following translation in #{path}: #{locales.join(", ")}.")
       end
     end
   end

data/lib/lazier/hash.rb

@@ -8,29 +8,5 @@ module Lazier
   # Extensions for Hash objects.
   module Hash
     extend ::ActiveSupport::Concern
-
-    # This is called when the user access a member using dotted notation.
-    #
-    # @param method [String|Symbol] Key to search.
-    # @param args [Array] *Unused.*
-    # @param block [Proc] *Unused.*
-    # @return [Object] The value for the key.
-    def method_missing(method, *args, &block)
-     if self.has_key?(method.to_sym) then
-        self[method.to_sym]
-     elsif self.has_key?(method.to_s) then
-        self[method.to_s]
-     else
-        ::Hash.method_missing(method, *args, &block)
-     end
-    end
-
-    # This is called when the user access a member using dotted notation.
-    #
-    # @param method [String|Symbol] Key to search.
-    # @return [Boolean] `true` if the key exists, `false` otherwise.
-    def respond_to?(method)
-      (self.has_key?(method.to_sym) || self.has_key?(method.to_s)) ? true : ::Hash.respond_to?(method)
-    end
   end
 end

data/lib/lazier/i18n.rb

@@ -49,13 +49,11 @@ module Lazier
       # @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 || "").to_s
-        locales = [locale, ENV["LANG"], R18n::I18n.system_locale].collect { |l| find_locale_in_path(l.to_s, path)}
-        locales << "en" # Add English as a fallback
-        locales = locales.uniq.compact
+        path = @i18n_locales_path.ensure_string
+        locales = validate_locales([locale], path)
 
         begin
-          translation = R18n::I18n.new(locales, path).t.send((@i18n_root || "").to_s)
+          translation = R18n::I18n.new(locales, path).t.send(@i18n_root)
           raise ArgumentError if translation.is_a?(R18n::Untranslated)
           translation
         rescue
@@ -63,13 +61,22 @@ module Lazier
         end
       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.collect(&: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[0, 5], locale[0, 2]].select {|l| File.exists?("#{path}/#{l}.yml") }.first
+        locale ? [locale, locale[0, 5], locale[0, 2]].select {|l| File.exists?("#{path}/#{l}.yml") }.first : nil
       end
   end
 end

data/lib/lazier/localizer.rb

@@ -15,9 +15,7 @@ module Lazier
     # @param path [String] The path where the translations are stored.
     # @param locale [String|Symbol] The locale to use for localization.
     def initialize(root = nil, path = nil, locale = nil)
-      root ||= :lazier
-      path ||= ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/")
-      self.i18n_setup(root, path)
+      i18n_setup(root || :lazier, path || ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
       self.i18n = locale
     end
 
@@ -27,7 +25,7 @@ module Lazier
     # @param args [Array] Optional arguments to localize the message.
     # @return [String|R18n::Untranslated] The localized message.
     def self.localize(message, *args)
-      self.new.i18n.send(message, *args)
+      Lazier::Localizer.new.i18n.send(message, *args)
     end
 
     # Localize a message in a specified locale.
@@ -37,7 +35,7 @@ module Lazier
     # @param args [Array] Optional arguments to localize the message.
     # @return [String|R18n::Untranslated] The localized message.
     def self.localize_on_locale(locale, message, *args)
-      self.new(nil, nil, locale).i18n.send(message, *args)
+      Lazier::Localizer.new(nil, nil, locale).i18n.send(message, *args)
     end
   end
 end

data/lib/lazier/object.rb

@@ -10,128 +10,156 @@ module Lazier
     include ::ActionView::Helpers::NumberHelper
     extend ::ActiveSupport::Concern
 
+    # Expression to match a boolean value.
+    BOOLEAN_MATCHER = /^(\s*(1|0|true|false|yes|no|t|f|y|n)\s*)$/i
+
+    # Expression to match a true value.
+    BOOLEAN_TRUE_MATCHER = /^(\s*(1|true|yes|t|y)\s*)$/i
+
+    # Expression to match a integer value.
+    INTEGER_MATCHER = /^([+-]?)(\d+)$/
+
+    # Expression to match a float value.
+    FLOAT_MATCHER = /^([+-]?)(\d+)([.,]\d+)?$/
+
     # Normalizes a number for conversion. Basically this methods removes all separator and ensures that `.` is used for decimal separator.
     #
     # @return [String] The normalized number.
     def normalize_number
-      if self.is_a?(TrueClass) then
-        "1"
-      elsif !self then
-        "0"
-      else
-        rv = self.ensure_string.strip.split(/[\.,]/)
-        rv[-1] = "." + rv[-1] if rv.length > 1
-        rv.join("")
-      end
-    end
-
-    # Checks if the object is a valid number.
-    #
-    # @return [Boolean] `true` is a valid number, `false` otherwise.
-    def is_number?
-      self.is_float?
+      is_boolean? ? to_i.to_s : ensure_string.strip.gsub(/[\.,](?=(.*[\.,]))/, "").gsub(",", ".")
     end
 
     # Checks if the object is a valid integer.
     #
     # @return [Boolean] `true` is a valid integer, `false` otherwise.
     def is_integer?
-      self.is_a?(::Integer) || /^([+-]?)(\d+)$/.match(self.normalize_number)
+      is_a?(::Integer) || is_a?(::TrueClass) || !self || normalize_number =~ ::Lazier::Object::INTEGER_MATCHER
     end
 
     # Checks if the object is a valid float.
     #
     # @return [Boolean] `true` is a valid float, `false` otherwise.
     def is_float?
-      self.is_a?(::Float) || /^([+-]?)(\d+)([.,]\d+)?$/.match(self.normalize_number)
+      is_a?(::Numeric) || is_a?(::TrueClass) || !self || normalize_number =~ ::Lazier::Object::FLOAT_MATCHER
     end
+    alias :is_number? :is_float?
 
     # Checks if the object is a valid boolean value.
     #
     # @return [Boolean] `true` is a valid boolean value, `false` otherwise.
     def is_boolean?
-      self.is_a?(::TrueClass) || self.is_a?(::FalseClass) || self.is_a?(::NilClass) || (self.ensure_string.strip =~ /^(1|0|true|false|yes|no|t|f|y|n)$/i)
+      is_a?(::TrueClass) || !self || to_s =~ ::Lazier::Object::BOOLEAN_MATCHER
+    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 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?)
+      valid = block_given? ? yield(self) : send(verifier)
+      !valid ? self : default_value
+    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.*
+    # @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
     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 compact [Boolean] If to compact 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
-      self.is_a?(::Array) ? self : [self]
+    def ensure_array(default_value = nil, uniq = false, compact = false, sanitizer = nil, &block)
+      rv = is_a?(::Array) ? self : (default_value || [self])
+      rv.collect!(&(block || sanitizer))
+      rv.uniq! if uniq
+      rv.compact! if compact
+      rv
     end
 
-    # Makes sure that the object is a string. For `nil`, it returns "".
+    # Makes sure that the object is an hash. For non hash objects, return an hash basing on the `default_value` parameter.
     #
-    # @return [String] The string representation of the object.
-    def ensure_string
-      if self.is_a?(::String) then
+    # @param default_value [Hash|Object|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`).
+    # @param sanitizer [Symbol|nil] If not `nil`, the method to use to sanitize values of the hash. *Ignored if a block is present.*
+    # @return [Hash] If the object is an hash, then the object itself, a hash with the object as single value otherwise.
+    def ensure_hash(default_value = nil, sanitizer = nil)
+      rv = if is_a?(::Hash) then
         self
+      elsif default_value.is_a?(::Hash) then
+        default_value
       else
-        self.present? ? self.to_s : ""
+        key = default_value.is_a?(::String) || default_value.is_a?(::Symbol) ? default_value : :key
+        {key => self}
       end
-    end
 
-    # Converts the object to a float.
-    #
-    # @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)
-      if self.is_a?(::Float)
-        self
-      elsif self.is_a?(::Integer)
-        self.to_f
+      if block_given? || sanitizer then
+        rv.inject({}) {|h, (k, v)|
+          h[k] = block_given? ? yield(v) : v.send(sanitizer)
+          h
+        }
       else
-        self.is_float? ? ::Kernel.Float(self.normalize_number) : default_value
+        rv
       end
     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
+    end
+
     # Converts the object to a integer.
     #
     # @param default_value [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)
-      self.is_a?(::Integer) ? self : self.to_float(default_value).to_i
+      to_float(default_value).to_i
     end
 
-    # Converts the object to a boolean.
+    # Converts the object to a float.
     #
-    # @return [Boolean] The boolean representation of the object.
-    def to_boolean
-      rv = self
-      rv = rv.to_i if rv.is_a?(::Float)
-      (rv.is_a?(TrueClass) || /^(1|on|true|yes|t|y)$/i.match(rv.ensure_string.strip)) ? true : false
+    # @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
     end
 
     # Returns the rounded float representaton of the object.
     #
-    # @param prec [Fixnum] The precision to keep.
+    # @param precision [Fixnum] The precision to keep.
     # @return [Float] The rounded float representaton of the object.
-    def round_to_precision(prec = 2)
-      (self.is_number? && prec >= 0) ? number_with_precision(self, precision: prec) : nil
+    def round_to_precision(precision = 2)
+      is_number? ? number_with_precision(to_float, precision: [precision, 0].max) : nil
     end
 
     # Formats a number.
     # @see Settings#setup_format_number
     #
-    # @param prec [Fixnum] The precision to show.
+    # @param precision [Fixnum] The precision to show.
     # @param decimal_separator [String] The string to use as decimal separator.
     # @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(prec = nil, decimal_separator = nil, add_string = nil, k_separator = nil)
-      prec ||= ::Lazier.settings.format_number[:prec]
-      decimal_separator ||= ::Lazier.settings.format_number[:decimal_separator]
-      add_string ||= ::Lazier.settings.format_number[:add_string]
-      k_separator ||= ::Lazier.settings.format_number[:k_separator]
-      format = "%n"
-      unit = ""
-
-      if add_string.present? then
-        format = "%n %u"
-        unit = add_string
-      end
+    def format_number(precision = nil, decimal_separator = nil, add_string = nil, k_separator = nil)
+      if is_number? then
+        settings = ::Lazier.settings.format_number
+        add_string ||= settings[:add_string]
+        format, unit = (add_string  ? ["%n %u", add_string] : ["%n", ""])
 
-      (self.is_number? && prec >= 0) ? number_to_currency(self, {precision: prec, separator: decimal_separator, delimiter: k_separator, format: format, unit: unit}) : nil
+        number_to_currency(self, {precision: [precision || settings[:precision], 0].max, separator: decimal_separator || settings[:decimal_separator], delimiter: k_separator || settings[:k_separator], format: format, unit: unit})
+      else
+        nil
+      end
     end
 
     # Formats a boolean.
@@ -141,33 +169,34 @@ module Lazier
     # @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)
-      names = {
-        true => true_name || ::Lazier.settings.boolean_names[true],
-        false => false_name || ::Lazier.settings.boolean_names[false]
-      }
+      settings = ::Lazier.settings.boolean_names
+      to_boolean ? (true_name || settings[true]) : (false_name || settings[false])
+    end
 
-      names[self.to_boolean]
+    # Prepares an object to be printed in list summaries, like `[01/04] Opening this...`.
+    #
+    # @param length [Fixnum] The minimum length of the label.
+    # @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)
+      self.ensure_string.send(formatter, length, filler)
     end
 
     # Inspects an object.
     #
     # @param format The format to use.
-    # @param must_raise [Boolean] If raise a Dump exception.
+    # @param as_exception [Boolean] If raise an exception.
     # @return [String] The object inspected and formatted.
-    def debug_dump(format = :yaml, must_raise = true)
-      rv = ""
-
-      begin
-        if format == :pretty_json then
-          rv = ::JSON.pretty_generate(self)
+    def analyze(format = :yaml, as_exception = true)
+      rv = case format
+        when :pretty_json
+          ::JSON.pretty_generate(self)
         else
-          rv = self.send("to_#{format}")
-        end
-      rescue
-        rv = self.inspect
+          send("to_#{format}")
       end
 
-      must_raise ? raise(::Lazier::Exceptions::Dump.new(rv)) : rv
+      as_exception ? raise(::Lazier::Exceptions::Debug.new(rv)) : rv
     end
   end
 end

data/lib/lazier/pathname.rb

@@ -18,9 +18,7 @@ module Lazier
     #
     # @return [Array] A list of all components that are included in this path.
     def components
-      rv = []
-      self.each_filename { |p| rv << p }
-      rv
+      each_filename.to_a
     end
   end
 end

data/lib/lazier/settings.rb

@@ -31,21 +31,21 @@ module Lazier
     # @return [Settings] The singleton instance of the settings.
     def self.instance(force = false)
       @instance = nil if force
-      @instance ||= self.new
+      @instance ||= ::Lazier::Settings.new
     end
 
     # Initializes a new settings object.
     def initialize
-      self.i18n_setup(:lazier, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
-      self.setup
+      i18n_setup(:lazier, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
+      setup
     end
 
     # Setups the current instance.
     def setup
-      self.setup_format_number
-      self.setup_boolean_names
-      self.setup_date_formats
-      self.setup_date_names
+      setup_format_number
+      setup_boolean_names
+      setup_date_formats
+      setup_date_names
     end
 
     # Set the current locale for messages.
@@ -54,19 +54,19 @@ module Lazier
     # @return [R18n::Translation] The new translation object.
     def i18n=(locale)
       super(locale)
-      self.setup
+      setup
     end
 
     # Setups formatters for a number.
     # @see Object#format_number
     #
-    # @param prec [Fixnum] The precision to show.
+    # @param precision [Fixnum] The precision to show.
     # @param decimal_separator [String] The string to use as decimal separator.
     # @param add_string [String] The string to append to the number.
     # @param k_separator [String] The string to use as thousands separator.
     # @return [Hash] The new formatters.
-    def setup_format_number(prec = 2, decimal_separator = ".", add_string = "", k_separator = ",")
-      @format_number = { prec: prec, decimal_separator: decimal_separator, add_string: add_string, k_separator: k_separator}
+    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})
     end
 
     # Setups strings representation of booleans.
@@ -76,9 +76,7 @@ module Lazier
     # @param false_name [String] The string representation of `false`. Defaults to `No`.
     # @return [Hash] The new representations.
     def setup_boolean_names(true_name = nil, false_name = nil)
-      true_name ||= self.i18n.boolean[0]
-      false_name ||= self.i18n.boolean[1]
-      @boolean_names = {true => true_name, false => false_name}
+      @boolean_names = {true => true_name || i18n.boolean[0], false => false_name || i18n.boolean[1]}
     end
 
     # Setups custom formats for dates and times.
@@ -88,18 +86,10 @@ module Lazier
     # @param replace [Boolean] If to discard current formats.
     # @return [Hash] The new formats.
     def setup_date_formats(formats = nil, replace = false)
-      formats = {ct_date: "%Y-%m-%d", ct_time: "%H:%M:%S", ct_date_time: "%F %T", ct_iso_8601: "%FT%T%z" } if formats.blank?
+      @date_formats = HashWithIndifferentAccess.new if replace || !@date_formats
 
-      if formats.is_a?(::Hash) then
-        if !replace then
-          @date_formats ||= {}
-          @date_formats.merge!(formats)
-        else
-          @date_formats = formats
-        end
-
-        @date_formats.each_pair do |k, v| ::Time::DATE_FORMATS[k] = v end
-      end
+      @date_formats.merge!(formats.ensure_hash({ct_date: "%Y-%m-%d", ct_time: "%H:%M:%S", ct_date_time: "%F %T", ct_iso_8601: "%FT%T%z" }))
+      ::Time::DATE_FORMATS.merge!(@date_formats)
 
       @date_formats
     end
@@ -115,12 +105,14 @@ 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)
-      long_months = self.i18n.date.long_months if long_months.blank?
-      short_months = self.i18n.date.short_months if short_months.blank?
-      long_days = self.i18n.date.long_days if long_days.blank?
-      short_days = self.i18n.date.short_days if short_days.blank?
+      definitions = self.i18n.date
 
-      @date_names = { long_months: long_months, short_months: short_months, long_days: long_days, short_days: short_days }
+      @date_names = {
+        long_months: long_months.ensure(definitions.long_months),
+        short_months: short_months.ensure(definitions.short_months),
+        long_days: long_days.ensure(definitions.long_days),
+        short_days: short_days.ensure(definitions.short_days)
+      }.with_indifferent_access
     end
   end
 end