lazier 3.5.7 → 4.0.0

data/doc/top-level-namespace.html

@@ -103,7 +103,7 @@
 </div>
 
     <div id="footer">
-  Generated on Thu Jun 19 11:49:04 2014 by
+  Generated on Sun Jun  1 15:50:05 2014 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.8.7.4 (ruby-2.1.2).
 </div>

data/lazier.gemspec

@@ -23,11 +23,14 @@ Gem::Specification.new do |gem|
   gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = ">= 1.9.3"
+  gem.required_ruby_version = ">= 2.1"
 
-  gem.add_dependency("json", "~> 1.8.1")
-  gem.add_dependency("activesupport", ">= 3.2.13") # We don't use ~> to enable use with 4.0
-  gem.add_dependency("tzinfo", ">= 0.3.37") # We don't use ~> to enable use with 0.3.37 (required by activesupport 4.0) and 1.x, which is the latest available
-  gem.add_dependency("r18n-desktop", "~> 1.1.10")
-  gem.add_dependency("hashie", "~> 2.1.1")
+  gem.add_dependency("activesupport", "~> 4.1")
+  gem.add_dependency("hashie", "~> 2.1")
+
+  if RUBY_ENGINE != "jruby"
+    gem.add_dependency("oj", "~> 2.9")
+  else
+    gem.add_dependency("json", "~> 1.8")
+  end
 end

data/lib/lazier.rb

@@ -1,20 +1,19 @@
-# 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.
 #
 
-require "json"
+require(RUBY_ENGINE != "jruby" ? "oj" : "json")
+require "English"
 require "tzinfo"
 require "active_support"
 require "active_support/core_ext"
-require "r18n-desktop"
+require "i18n"
 require "hashie"
 
 require "lazier/version" unless defined?(Lazier::Version)
 require "lazier/exceptions"
 require "lazier/i18n"
-require "lazier/localizer"
 require "lazier/configuration"
 require "lazier/settings"
 require "lazier/object"
@@ -28,6 +27,9 @@ require "lazier/pathname"
 
 # Several Ruby object enhancements.
 module Lazier
+  # The root directory of the library
+  ROOT = File.absolute_path(__dir__ + "/../")
+
   # Returns the settings for the extensions.
   #
   # @return [Settings] The settings for the extensions.
@@ -49,8 +51,9 @@ module Lazier
   #   @option pathname Extensions for path objects.
   # @return [Settings] The settings for the extensions.
   def self.load!(*what)
-    modules = what.present? ? what.flatten.uniq.compact.map(&:to_s) : %w(object boolean string hash datetime math pathname)
-    modules.each { |w| ::Lazier.send("load_#{w}") }
+    valid_modules = [:object, :boolean, :string, :hash, :datetime, :math, :pathname]
+    modules = what.present? ? what.flatten.uniq.compact.map(&:to_s) : valid_modules
+    (modules & valid_modules).each { |w| ::Lazier.send("load_#{w}") }
 
     yield if block_given?
     ::Lazier::Settings.instance
@@ -82,14 +85,10 @@ module Lazier
   # Loads Hash extensions.
   def self.load_hash
     clean_hash_compact
+    Lazier.load_object
     ::Hash.class_eval { include ::Lazier::Hash }
   end
 
-  # Loads Hash method access extensions.
-  def self.load_hash_method_access
-    ::Hash.class_eval { include Hashie::Extensions::MethodAccess }
-  end
-
   # Loads DateTime extensions.
   def self.load_datetime
     Lazier.load_object
@@ -117,14 +116,14 @@ module Lazier
   #
   # @param cls [Symbol|String|Object] If a `String` or a `Symbol` or a `Class`, then it will be the class to instantiate.
   #   Otherwise the class of the object will returned.
-  # @param scope [String] An additional scope to find the class. `%CLASS%`, `%`, `$`, `?` and `@` will be substituted with the class name.
-  # @param only_in_scope [Boolean] If only try to instantiate the class in the scope.
+  # @param scope [String] The scope where to find the class. `%CLASS%`, `%`, `$`, `?` and `@` will be substituted with the class name.
+  # @param only_in_scope [Boolean] If only search inside the scope.
   # @return [Class] The found class.
-  def self.find_class(cls, scope = "::%CLASS%", only_in_scope = false)
-    if cls.is_a?(::String) || cls.is_a?(::Symbol)
-      rv, cls = perform_initial_class_search(cls, only_in_scope)
-      rv = search_class_inside_scope(rv, cls, scope) # Search inside scope
-      rv || raise(NameError.new("", cls))
+  def self.find_class(cls, scope = "::@", only_in_scope = false)
+    if [::String, ::Symbol].include?(cls.class)
+      cls = cls.to_s.camelize
+      cls.gsub!(/^::/, "") if scope && only_in_scope
+      search_class(cls, scope) || raise(NameError, ["", cls])
     else
       cls.is_a?(::Class) ? cls : cls.class
     end
@@ -137,14 +136,30 @@ module Lazier
   # @param block [Proc] The block to evaluate.
   # @return [Float|String] If a `message` is provided, then the message itself plus the duration under parenthesis will be returned,
   #   otherwise the duration alone as a number.
-  def self.benchmark(message = nil, precision = 0, &block)
+  def self.benchmark(message: nil, precision: 0, &block)
     rv = Benchmark.ms(&block)
     message ? format("%s (%0.#{precision}f ms)", message, rv) : rv
   end
 
+  # Returns which platform are we running on. Can be `:java`, `:osx`, `:posix` or `:win32`
+  #
+  # @return [Boolean] If force detection again.
+  # @return [Symbol] The current platform.
+  def self.platform(force = false)
+    @platform = nil if force
+
+    @platform ||=
+      case RUBY_PLATFORM
+      when /cygwin|mingw|win32/ then :win32
+      when /java/ then :java
+      when /darwin/ then :osx
+      else :posix
+      end
+  end
+
   private
 
-  # Removes existing `compact` and `compact!` methods from the Hash class.
+  # Removes existing `compact` and `compact!` methods from the Hash class to avoid conflicts with ActiveSupport.
   def self.clean_hash_compact
     ::Hash.class_eval do
       begin
@@ -156,39 +171,15 @@ module Lazier
     end
   end
 
-  # Performs the initial search to find a class.
-  # @param cls [Symbol|String|Object] If a `String` or a `Symbol` or a `Class`, then it will be the class to instantiate.
-  # @param only_in_scope [Boolean] If only try to instantiate the class in the scope.
-  # @return [Array] The found class (if any) and the sanitized name.
-  def self.perform_initial_class_search(cls, only_in_scope)
-    rv = nil
-    cls = cls.to_s.camelize
-
-    if only_in_scope
-      cls.gsub!(/^::/, "") # Mark only search only inside scope
-    else
-      rv = search_class(cls) # Search outside scope
-    end
-
-    [rv, cls]
-  end
-
   # Tries to search a class.
   #
   # @param cls [String] The class to search.
+  # @param scope [String] Scope to find the class. `%CLASS%`, `%`, `$`, `?` and `@` will be substituted with the class name.
   # @return [Class] The instantiated class.
-  def self.search_class(cls)
-    cls.constantize rescue nil
-  end
-
-  # Finds a class inside a specific scope.
-  #
-  # @param current [Class] The class found outside the scope.
-  # @param cls [String] The class to search.
-  # @param scope [String] The scope to search the class into.
-  # @return [Class] The found class.
-  def self.search_class_inside_scope(current, cls, scope)
-    cls = cls.ensure_string
-    !current && cls !~ /^::/ && scope.present? ? search_class(scope.to_s.gsub(/%CLASS%|[@%$?]/, cls)) : current
+  def self.search_class(cls, scope = nil)
+    cls = scope.gsub(/%CLASS%|[@%$?]/, cls)
+    cls.constantize
+  rescue
+    nil
   end
 end

data/lib/lazier/boolean.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.

data/lib/lazier/configuration.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,14 +6,11 @@
 module Lazier
   # A configuration class to set properties.
   class Configuration < Hashie::Dash
-    include ::Lazier::I18n
-
     # Initializes a new configuration object.
     #
     # @param attributes [Hash] The initial values of properties of this configuration.
     def initialize(attributes = {}, &block)
-      @lazier_i18n = Lazier::Localizer.new(:lazier, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/")).i18n
-      i18n_setup(:lazier, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
+      @i18n = Lazier::I18n.instance
       super(attributes, &block)
     end
 
@@ -25,41 +21,43 @@ module Lazier
     # * :required - Specify the value as required for this property, to raise an error if a value is unset in a new or existing configuration.
     # * :readonly - Specify if the property is readonly, which means that it can only defined during creation of the configuration.
     #
-    # @param property_name [String|Symbol] The new property name.
+    # @param name [String|Symbol] The new property name.
     # @param options [Hash] The options for the property.
-    def self.property(property_name, options = {})
-      super(property_name, options)
+    def self.property(name, options = {})
+      super(name, options)
 
       if options[:readonly]
-        class_eval <<-ACCESSOR
-          def #{property_name}=(_)
-            raise ArgumentError.new(@lazier_i18n.configuration.readonly("#{property_name}", "#{name}"))
-          end
-        ACCESSOR
+        send(:define_method, "#{name}=") do |_|
+          assert_readonly_property!(name)
+        end
       end
     end
 
     private
 
-    # Checks if a property exists.
-    #
-    # @param property [String|Symbol] The property to check.
-    def assert_property_exists!(property)
-      raise(ArgumentError, @lazier_i18n.configuration.not_found(property, self.class.name)) unless self.class.property?(property)
+    # :nodoc:
+    def assert_readonly_property!(name)
+      raise(ArgumentError, assertion_error("configuration.readonly", name))
     end
 
-    # Checks if a property has been set.
-    #
-    # @param property [String|Symbol] The property to check.
-    def assert_property_set!(property)
-      raise(ArgumentError, @lazier_i18n.configuration.required(property, self.class.name)) if send(property).is_a?(NilClass)
+    # :nodoc:
+    def assert_property_exists!(name)
+      raise(ArgumentError, assertion_error("configuration.not_found", name)) unless self.class.property?(name)
     end
 
-    # Checks if a property is required.
-    #
-    # @param property [String|Symbol] The property to check.
-    def assert_property_required!(property, value)
-      raise(ArgumentError, @lazier_i18n.configuration.required(property, self.class.name)) if self.class.required?(property) && value.is_a?(NilClass)
+    # :nodoc:
+    def assert_property_set!(name)
+      raise(ArgumentError, assertion_error("configuration.required", name)) if send(name).nil?
+    end
+
+    # :nodoc:
+    def assert_property_required!(name, value)
+      raise(ArgumentError, assertion_error("configuration.required", name)) if value.nil? && self.class.required?(name)
+    end
+
+    # :nodoc:
+    def assertion_error(label, name)
+      @i18n.translate(label, name: name, class: self.class.name)
     end
   end
 end

data/lib/lazier/datetime.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.
@@ -51,66 +50,31 @@ module Lazier
       # @param reference [Fixnum] The ending (or middle, if `also_future` is `true`) value of the range. Defaults to the current year.
       # @param as_objects [Boolean] If to return years in hashes with `:value` and `label` keys.
       # @return [Array] A range of years. Every entry is
-      def years(offset = 10, also_future = true, reference = nil, as_objects = false)
+      def years(offset: 10, also_future: true, reference: nil, as_objects: false)
         y = reference || ::Date.today.year
         (y - offset..(also_future ? y + offset : y)).map { |year| as_objects ? {value: year, label: year} : year }
       end
 
-      # Returns all the availabe timezones.
-      #
-      # @return [Array]All the zone available.
-      def timezones
-        ::ActiveSupport::TimeZone.all
-      end
-
-      # Returns a list of names of all timezones.
-      #
-      # @param with_dst [Boolean] If include DST version of the zones.
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-      # @return [Array] A list of names of timezones.
-      def list_timezones(with_dst = true, dst_label = nil)
-        ::ActiveSupport::TimeZone.list_all(with_dst, dst_label)
-      end
-
-      # Find a zone by its name.
-      #
-      # @param name [String] The zone name.
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-      # @return [TimeZone] A timezone or `nil` if no zone was found.
-      def find_timezone(name = true, dst_label = nil)
-        ::ActiveSupport::TimeZone.find(name, dst_label)
-      end
-
-      # Returns a string representation of a timezone.
-      #
-      # ```ruby
-      # DateTime.parameterize_zone(ActiveSupport::TimeZone["Pacific Time (US & Canada)"])
-      # # => "-0800@pacific-time-us-canada"
-      # ```
-      # @param tz [TimeZone] The zone to represent.
-      # @param with_offset [Boolean] If to include offset into the representation.
-      # @return [String] A string representation which can be used for searches.
-      def parameterize_zone(tz, with_offset = true)
-        ::ActiveSupport::TimeZone.parameterize_zone(tz, with_offset)
-      end
-
-      # Finds a parameterized timezone.
-      # @see DateTime#parameterize_zone
+      # Lookups a custom datetime format.
+      # @see Settings#setup_date_formats
       #
-      # @param tz [String] The zone to unparameterize.
-      # @param as_string [Boolean] If return just the zone name.
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-      # @return [String|TimeZone] The found timezone or `nil` if the zone is not valid.
-      def unparameterize_zone(tz, as_string = false, dst_label = nil)
-        ::ActiveSupport::TimeZone.unparameterize_zone(tz, as_string, dst_label)
+      # @param key [Symbol] The name of the format to search.
+      # @return [String] The format or the name itself (if the format has not been found).
+      def custom_format(key)
+        ::Lazier.settings.date_formats.fetch(key, key)
       end
 
-      # Returns an offset in rational value.
+      # Checks if the date is valid against to a specific format.
+      # @see DateTime#custom_format
       #
-      # @param offset [Fixnum] The offset to convert.
-      # @return [Rational] The converted offset.
-      def rationalize_offset(offset)
-        ::ActiveSupport::TimeZone.rationalize_offset(offset)
+      # @param value [String] The value to check.
+      # @param format [String] The format to check the value against.
+      # @return [Boolean] `true` if the value is valid against the format, `false` otherwise.
+      def valid?(value, format = "%F %T")
+        ::DateTime.strptime(value, custom_format(format))
+        true
+      rescue
+        false
       end
 
       # Returns the Easter (according to Gregorian calendar) date for the year.
@@ -119,7 +83,7 @@ module Lazier
       # @param year [Fixnum] The year to compute the date for. Defaults to the current year.
       # @return [Date] The Easter date for the year.
       def easter(year = nil)
-        year = ::Date.today.year unless year.is_integer?
+        year = ::Date.today.year unless year.integer?
 
         # Compute using Anonymous Gregorian Algorithm: http://en.wikipedia.org/wiki/Computus#Anonymous_Gregorian_algorithm
         data = easter_start(year)
@@ -131,42 +95,14 @@ module Lazier
         ::Date.civil(year, month, day)
       end
 
-      # Lookups a custom datetime format.
-      # @see Settings#setup_date_formats
-      #
-      # @param key [Symbol] The name of the format to search.
-      # @return [String] The format or the name itself (if the format has not been found).
-      def custom_format(key)
-        ::Lazier.settings.date_formats.fetch(key, key)
-      end
-
-      # Checks if the date is valid against to a specific format.
-      # @see DateTime#custom_format
-      #
-      # @param value [String] The value to check.
-      # @param format [String] The format to check the value against.
-      # @return [Boolean] `true` if the value is valid against the format, `false` otherwise.
-      def valid?(value, format = "%F %T")
-        ::DateTime.strptime(value, custom_format(format))
-        true
-      rescue
-        false
-      end
-      alias_method :is_valid?, :valid?
-
       private
 
-      # Part one of Easter calculation.
-      #
-      # @param year [Fixnum] The year to compute the date for.
-      # @return [Array] Partial variables for #easter_divide.
+      # :nodoc:
       def easter_start(year)
         [year % 19, (year / 100.0).floor, year % 100]
       end
 
-      # Part two of Easter calculation.
-      # @param data [Fixnum] Partial variables from #easter_start.
-      # @return [Array] Partial variables for #easter_aggregate.
+      # :nodoc:
       def easter_divide(data)
         _, b, c = data
 
@@ -178,10 +114,7 @@ module Lazier
         ]
       end
 
-      # Part three of Easter calculation.
-      #
-      # @param data [Fixnum] Partial variables from #easter_divide.
-      # @return [Array] Partial variables for #easter_prepare.
+      # :nodoc:
       def easter_aggregate(year, data)
         a = year % 19
         x, e, i, k = data
@@ -189,32 +122,20 @@ module Lazier
         [h, (32 + (2 * e) + (2 * i) - h - k) % 7]
       end
 
-      # Part four of Easter calculation
-      # @param data [Arrays] Partial variables from #easter_aggregate.
-      # @return [Array] Partial variables for #easter_end.
+      # :nodoc:
       def easter_prepare(year, data)
         a = year % 19
         h, l = data
         [h, l, ((a + (11 * h) + (22 * l)) / 451.0).floor]
       end
 
-      # Final part of Easter calculation.
-      #
-      # @param data [Fixnum] Variable from #easter_prepare.
-      # @return [Array] Day and month of Easter day.
+      # :nodoc:
       def easter_end(data)
         h, l, m = data
         [((h + l - (7 * m) + 114) % 31) + 1, ((h + l - (7 * m) + 114) / 31.0).floor]
       end
     end
 
-    # Returns the UTC::Time representation of the current datetime.
-    #
-    # @return [UTC::Time] The UTC::Time representation of the current datetime.
-    def utc_time
-      utc.to_time
-    end
-
     # Returns the number of months passed between the beginning of the base year and the current date.
     #
     # ```ruby
@@ -224,7 +145,7 @@ module Lazier
     #
     # @param base [DateTime] The base year to start computation from. Default to current year.
     # @return [Fixnum] Returns the number of months passed between the beginning of the base year and the current date.
-    def in_months(base = nil)
+    def months_since_year(base = nil)
       (year - (base || ::Date.today.year)) * 12 + month
     end
 
@@ -235,41 +156,26 @@ module Lazier
       month.indexize
     end
 
-    # Formats a datetime, looking up also custom formats.
+    # Formats a datetime, eventually looking up also custom formats and/or moving to the current timezone.
     # @see Settings#setup_date_formats
     #
     # @param format [String] A format or a custom format name to use for formatting.
+    # @param custom [Boolean] Whether to use custom formats.
+    # @param change_time_zone [Boolean] Whether to move the date to the current timezone.
     # @return [String] The formatted date.
-    def lstrftime(format = nil)
-      strftime(::DateTime.custom_format(format.to_s).gsub(/(?<!%)(%[ab])/i) { |mo| localize_time_component(mo) })
-    end
-
-    # Formats a datetime in the current timezone.
-    #
-    # @param format [String] The format to use for formatting.
-    # @return [String] The formatted date.
-    def local_strftime(format = nil)
-      (respond_to?(:in_time_zone) ? in_time_zone : self).strftime(::DateTime.custom_format(format))
-    end
-
-    # Formats a datetime in the current timezone, looking up also custom formats.
-    # @see Settings#setup_date_formats
-    #
-    # @param format [String] A format or a custom format name.
-    # @return [String] The formatted date.
-    def local_lstrftime(format = nil)
-      (respond_to?(:in_time_zone) ? in_time_zone : self).lstrftime(format)
+    def format(format = nil, custom: true, change_time_zone: false)
+      target = change_time_zone && respond_to?(:in_time_zone) ? in_time_zone : self
+      format = custom ? ::DateTime.custom_format(format.to_s).gsub(/(?<!%)(%[ab])/i) { |mo| localize_time_component(mo) } : format.to_s
+      target.strftime(format)
     end
 
     private
 
-    # Returns a component of the date in the current locale.
-    #
-    # @param component [String] The component to localize.
-    # @return [String] The localized component.
+    # :nodoc:
     def localize_time_component(component)
       type = {"%a" => :short_days, "%A" => :long_days, "%b" => :short_months, "%B" => :long_months}.fetch(component, "")
       index = component =~ /%a/i ? wday : month - 1
+
       ::Lazier.settings.date_names[type][index]
     end
   end