lazier 3.5.7 → 4.0.0

data/lib/lazier/pathname.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/settings.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.
@@ -18,12 +17,7 @@ module Lazier
   # @attribute [r] i18n
   #   @return [R18n::Translation] The translation object.
   class Settings
-    attr_reader :format_number
-    attr_reader :boolean_names
-    attr_reader :date_names
-    attr_reader :date_formats
-
-    include Lazier::I18n
+    attr_reader :format_number, :boolean_names, :date_names, :date_formats, :i18n
 
     # Returns the singleton instance of the settings.
     #
@@ -31,12 +25,12 @@ module Lazier
     # @return [Settings] The singleton instance of the settings.
     def self.instance(force = false)
       @instance = nil if force
-      @instance ||= ::Lazier::Settings.new
+      @instance ||= new
     end
 
     # Initializes a new settings object.
     def initialize
-      i18n_setup(:lazier, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
+      @i18n = Lazier::I18n.instance
       setup
     end
 
@@ -48,15 +42,6 @@ module Lazier
       setup_date_names
     end
 
-    # Set the current locale for messages.
-    #
-    # @param locale [String] The new locale. Default is the current system locale.
-    # @return [R18n::Translation] The new translation object.
-    def i18n=(locale)
-      super(locale)
-      setup
-    end
-
     # Setups formatters for a number.
     # @see Object#format_number
     #
@@ -65,7 +50,7 @@ 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 [Hash] The new formatters.
-    def setup_format_number(precision = 2, decimal_separator = ".", add_string = nil, 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
       )
@@ -77,8 +62,9 @@ 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 [Hash] The new representations.
-    def setup_boolean_names(true_name = nil, false_name = nil)
-      @boolean_names = {true => true_name || i18n.boolean[0], false => false_name || i18n.boolean[1]}
+    def setup_boolean_names(true_name: nil, false_name: nil)
+      names = i18n.translate("boolean")
+      @boolean_names = {true => true_name || names[0], false => false_name || names[1]}
     end
 
     # Setups custom formats for dates and times.
@@ -90,7 +76,8 @@ module Lazier
     def setup_date_formats(formats = nil, replace = false)
       @date_formats = HashWithIndifferentAccess.new if replace || !@date_formats
 
-      @date_formats.merge!(formats.ensure_hash(nil, {ct_date: "%Y-%m-%d", ct_time: "%H:%M:%S", ct_date_time: "%F %T", ct_iso_8601: "%FT%T%z" }))
+      formats = {ct_date: "%Y-%m-%d", ct_time: "%H:%M:%S", ct_date_time: "%F %T", ct_iso_8601: "%FT%T%z" } unless formats.is_a?(::Hash)
+      @date_formats.merge!(formats)
       ::Time::DATE_FORMATS.merge!(@date_formats)
 
       @date_formats
@@ -106,15 +93,15 @@ module Lazier
     # @param long_days [Array] The string representation of days.
     # @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 = i18n.date
+    def setup_date_names(long_months: nil, short_months: nil, long_days: nil, short_days: nil)
+      definitions = i18n.translate("date").ensure_access(:dotted)
 
       @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
+      }.ensure_access(:indifferent, :dotted)
     end
   end
 end

data/lib/lazier/string.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.
@@ -9,18 +8,6 @@ module Lazier
   module String
     extend ::ActiveSupport::Concern
 
-    # Removes accents from the string, normalizing to the normal letter.
-    #
-    # ```ruby
-    # "èòàù".remove_accents
-    # # => "eoau"
-    # ```
-    #
-    # @return The string with all accents removed.
-    def remove_accents
-      silence_warnings { mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n, "").to_s }
-    end
-
     # Makes sure the string only contains valid UTF-8 sequences.
     #
     # @param replacement [String] The string to use to replace invalid sequences.
@@ -30,27 +17,6 @@ module Lazier
       encode("utf-16", invalid: :replace, undef: :replace, replace: replacement).encode("utf-8")
     end
 
-    # Returns the tagged version of a string.
-    #
-    # The string is downcased and spaces are substituted with `-`.
-    #
-    # ```ruby
-    # "ABC cde".untitleize
-    # # => "abc-cde"
-    # ```
-    #
-    # @return [String] The untitleized version of the string.
-    def untitleize
-      downcase.gsub(" ", "-")
-    end
-
-    # Returns the string with all `&amp;` replaced with `&`.
-    #
-    # @return [String] The string with all `&amp;` replaced with `&`.
-    def replace_ampersands
-      gsub(/&amp;(\S+);/, "&\\1;")
-    end
-
     # Returns the string itself for use in form helpers.
     #
     # @return [String] The string itself.
@@ -62,15 +28,28 @@ module Lazier
     #
     # @param no_blanks [Boolean] If filter out blank tokens.
     # @param strip [Boolean] If strip single tokens.
-    # @param uniq [Boolean] If return uniques elements.
+    # @param no_duplicates [Boolean] If return uniques elements.
     # @param pattern [String|Regexp] The pattern to use.
+    # @param presence_method [Symbol] The method to use to check if a token is present or not.
     # @return [Array] An array of tokens.
-    def split_tokens(no_blanks = true, strip = true, uniq = false, pattern = /\s*,\s*/)
+    def tokenize(no_blanks: true, strip: true, no_duplicates: false, pattern: /\s*,\s*/, presence_method: :present?)
       rv = split(pattern)
       rv.map!(&:strip) if strip
-      rv.select!(&:present?) if no_blanks
-      rv.uniq! if uniq
+      rv.select!(&presence_method) if no_blanks
+      rv.uniq! if no_duplicates
       rv
     end
+
+    # Removes accents from the string, normalizing to the normal letter.
+    #
+    # ```ruby
+    # "èòàù".remove_accents
+    # # => "eoau"
+    # ```
+    #
+    # @return The string with all accents removed.
+    def remove_accents
+      ::I18n.transliterate(self)
+    end
   end
 end

data/lib/lazier/timezone.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.
@@ -9,14 +8,28 @@ module Lazier
   module TimeZone
     extend ::ActiveSupport::Concern
 
+    # Pattern for a parameterized timezone.
+    ALREADY_PARAMETERIZED = /^[+-]\d{4}@[a-z-]+/
+
+    # Pattern for a unparameterized timezone.
+    PARAMETERIZER = /^(
+      \(
+        [a-z]+ # UTC Label
+        (?<offset>([+-])(\d{2})(:?)(\d{2}))
+      \)
+      \s
+      (?<label>.+)
+    )$/xi
+
     # General methods.
     module ClassMethods
+      # Expression to parameterize a zone
       # Returns an offset in rational value.
       #
       # @param offset [Fixnum] The offset to convert.
       # @return [Rational] The converted offset.
       def rationalize_offset(offset)
-        ::TZInfo::OffsetRationals.rational_for_offset(offset.is_a?(::Fixnum) ? offset : offset.offset)
+        ::TZInfo::OffsetRationals.rational_for_offset(offset)
       end
 
       # Returns a +HH:MM formatted representation of the offset.
@@ -31,37 +44,30 @@ module Lazier
       # Find a zone by its name.
       #
       # @param name [String] The zone name.
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
+      # @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(name, dst_label = nil)
-        catch(:zone) do
-          ::ActiveSupport::TimeZone.all.each do |zone|
-            zone.aliases.each do |zone_alias|
-              if [zone.to_str(zone_alias), zone.to_str_with_dst(dst_label, nil, zone_alias)].include?(name)
-                zone.current_alias = zone_alias
-                throw(:zone, zone)
-              end
-            end
-          end
-
-          nil
-        end
+      def find(name, dst_label = " (DST)")
+        list(true, dst_label: dst_label, as_hash: true)[name]
       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_all(with_dst = true, dst_label = nil)
-        dst_label ||= "(DST)"
-
-        @zones_names ||= { "STANDARD" => ::ActiveSupport::TimeZone.all.map(&:to_s) }
-        @zones_names["DST[#{dst_label}]-STANDARD"] ||= ::ActiveSupport::TimeZone.all
-        .map { |zone| fetch_aliases(zone, dst_label) }.flatten.compact.uniq
-        .sort { |a, b| ::ActiveSupport::TimeZone.compare(a, b) } # Sort by name
+      # @param parameterized [Boolean] If parameterize zones.
+      # @param dst_label [String] Label for the DST indication. Defaults to ` (DST)`.
+      # @param as_hash [Hash] If return an hash.
+      # @return [Array|Hash] A list of names of timezones or a hash with labels and timezones as keys.
+      def list(with_dst = true, dst_label: " (DST)", parameterized: false, sort_by_name: true, as_hash: false)
+        dst_label = nil unless with_dst
+        key = [dst_label, sort_by_name, as_hash, parameterized].join(":")
+        @zones_names ||= {}
+
+        unless @zones_names[key]
+          all = ::ActiveSupport::TimeZone.all
+          @zones_names[key] = send("finalize_list_as_#{as_hash ? "hash" : "list"}", all, dst_label, parameterized, sort_by_name)
+        end
 
-        @zones_names["#{with_dst ? "DST[#{dst_label}]-" : ""}STANDARD"]
+        @zones_names[key]
       end
 
       # Returns a string representation of a timezone.
@@ -70,17 +76,17 @@ module Lazier
       # DateTime.parameterize_zone(ActiveSupport::TimeZone["Pacific Time (US & Canada)"])
       # # => "-0800@pacific-time-us-canada"
       # ```
-      # @param tz [TimeZone] The zone to represent.
+      # @param tz [TimeZone|String] 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)
-        tz = tz.to_s unless tz.is_a?(::String)
-        mo = /^(\([a-z]+([+-])(\d{2})(:?)(\d{2})\)\s(.+))$/i.match(tz)
-
-        if mo
-          with_offset ? "#{mo[2]}#{mo[3]}#{mo[5]}@#{mo[6].to_s.parameterize}" : mo[6].to_s.parameterize
-        elsif !with_offset then
-          tz.gsub(/^([+-]?(\d{2})(:?)(\d{2})@)/, "")
+      def parameterize(tz, with_offset = true)
+        tz = tz.to_str unless tz.is_a?(::String)
+
+        if tz =~ ::Lazier::TimeZone::ALREADY_PARAMETERIZED
+          tz
+        elsif tz =~ ::Lazier::TimeZone::PARAMETERIZER
+          mo = $LAST_MATCH_INFO
+          [(with_offset ? mo[:offset].gsub(":", "") : nil), mo[:label].parameterize].compact.join("@")
         else
           tz.parameterize
         end
@@ -90,18 +96,11 @@ module Lazier
       # @see DateTime#parameterize_zone
       #
       # @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)
-        tz = parameterize_zone(tz, false)
-        rv = find_parameterized_zone(dst_label, /(#{Regexp.quote(tz)})$/)
-
-        if rv
-          as_string ? rv : find(rv, dst_label)
-        else
-          nil
-        end
+      # @return [TimeZone] The found timezone or `nil` if the zone is not valid.
+      def unparameterize(tz, dst_label = " (DST)")
+        tz = parameterize(tz)
+        list(true, dst_label: dst_label, parameterized: true, as_hash: true)[tz]
       end
 
       # Compares two timezones. They are sorted by the location name.
@@ -117,31 +116,35 @@ module Lazier
 
       private
 
-      # Returns a list of aliases for a given time zone.
-      #
-      # @param zone [ActiveSupport::TimeZone] The zone.
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-      def fetch_aliases(zone, dst_label = "(DST)")
-        matcher = /(#{Regexp.quote(dst_label)})$/
-
+      # :nodoc:
+      def fetch_aliases(zone, dst_label = "(DST)", parameterized = false)
         zone.aliases.map { |zone_alias|
-          [zone.to_str(zone_alias), (zone.uses_dst? && zone_alias !~ matcher) ? zone.to_str_with_dst(dst_label, nil, zone_alias) : nil]
-        }
+          [
+            zone.to_str(false, label: zone_alias, parameterized: parameterized),
+            (zone.uses_dst? && dst_label) ? zone.to_str(true, label: zone_alias, dst_label: dst_label, parameterized: parameterized) : nil
+          ]
+        }.flatten.uniq.compact
       end
 
-      # Finds a parameterized timezone.
-      #
-      # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-      # @param matcher [Regexp] The expression to match.
-      # @return [String] The found timezone or `nil` if the zone is not valid.
-      def find_parameterized_zone(dst_label, matcher)
-        catch(:zone) do
-          list_all(true, dst_label).each do |zone|
-            throw(:zone, zone) if parameterize_zone(zone, false) =~ matcher
-          end
-
-          nil
-        end
+      # :nodoc:
+      def finalize_list_as_list(all, dst_label, parameterized, sort_by_name)
+        rv = all.map { |zone|
+          fetch_aliases(zone, dst_label, parameterized)
+        }.flatten.uniq
+
+        sort_by_name ? rv.sort { |a, b| ::ActiveSupport::TimeZone.compare(a, b) } : rv
+      end
+
+      # :nodoc:
+      def finalize_list_as_hash(all, dst_label, parameterized, sort_by_name)
+        rv = all.reduce({}) { |accu, zone|
+          accu.merge(fetch_aliases(zone, dst_label, parameterized).reduce({}) { |a, e|
+            a[e] = zone
+            a
+          })
+        }
+
+        sort_by_name ? ::Hash[rv.sort { |a, b| ::ActiveSupport::TimeZone.compare(a[0], b[0]) }] : rv
       end
     end
 
@@ -158,150 +161,124 @@ module Lazier
     # @param date [DateTime] The date to consider. Defaults to now.
     # @return [Fixnum|Rational] The offset of this timezone.
     def current_offset(rational = false, date = nil)
-      date ||= ::DateTime.now
-      rv = (period_for_utc(date.utc).dst? ? dst_offset : offset)
-      rational ? self.class.rationalize_offset(rv) : rv
+      date = (date || ::DateTime.current).in_time_zone
+      offset(rational: rational, dst: date.dst?, year: date.year)
     end
 
     # Returns the current alias for this timezone.
     #
     # @return [String] The current alias or the first alias of the current timezone.
     def current_alias
-      if @current_alias
-        @current_alias
-      else
-        identifier = tzinfo.identifier
+      identifier = name
 
-        catch(:alias) do
-          aliases.each do |a|
-            throw(:alias, a) if a == identifier
-          end
-
-          aliases.first
+      catch(:alias) do
+        aliases.each do |a|
+          throw(:alias, a) if a == identifier
         end
+
+        aliases.first
       end
     end
 
-    # Sets the current alias.
+    # Returns the current name.
     #
-    # @param new_alias [String] The new current alias.
-    def current_alias=(new_alias)
-      @current_alias = new_alias.ensure_string
+    # @param dst [Boolean] If to return the name with DST indication.
+    # @param dst_label [String] Label for the DST indication. Defaults to ` (DST)`.
+    # @param year [Fixnum] The year to which refer to. Defaults to the current year. *Only required when `dst` is true*.
+    # @return [String] The name for the zone.
+    def current_name(dst = false, dst_label: " (DST)", year: nil)
+      year ||= Date.current.year
+      rv = current_alias
+      rv += dst_label if dst && uses_dst?(year)
+      rv
     end
 
     # Returns the standard offset for this timezone.
     #
     # @param rational [Boolean] If to return the offset as a Rational.
-    # @return [Fixnum|Rational] The offset of this timezone.
-    def offset(rational = false)
-      rational ? self.class.rationalize_offset(utc_offset) : utc_offset
-    end
-
-    # Gets a period for this timezone when the Daylight Saving Time (DST) is active (it takes care of different hemispheres).
-    #
+    # @param dst [Boolean] If to return the offset when the DST is active.
     # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @return [TimezonePeriod] A period when the Daylight Saving Time (DST) is active or `nil` if the timezone doesn't use DST for that year.
-    def dst_period(year = nil)
-      year ||= ::Date.today.year
-
-      northern_summer = ::DateTime.civil(year, 7, 15).utc # This is a representation of a summer period in the Northern Hemisphere.
-      southern_summer = ::DateTime.civil(year, 1, 15).utc # This is a representation of a summer period in the Southern Hemisphere.
+    # @return [Fixnum|Rational] The offset of this timezone.
+    def offset(rational: false, dst: false, year: nil)
+      rv =
+        if dst
+          period = dst_period(year)
+          period ? period.utc_total_offset : 0
+        else
+          utc_offset
+        end
 
-      period = period_for_utc(northern_summer)
-      period = period_for_utc(southern_summer) unless period.dst?
-      period.dst? ? period : nil
+      rational ? self.class.rationalize_offset(rv) : rv
     end
 
     # Checks if the timezone uses Daylight Saving Time (DST) for that date or year.
     #
-    # @param reference [Object] The date or year to check. Defaults to the current year.
+    # @param reference [Date|DateTime] The date or year to check. Defaults to the current year.
     # @return [Boolean] `true` if the zone uses DST for that date or year, `false` otherwise.
     def uses_dst?(reference = nil)
-      if reference.respond_to?(:year) && reference.respond_to?(:utc) # This is a date like object
-        dst_period(reference.year).present? && period_for_utc(reference.utc).dst?
+      if reference.is_a?(Date) || reference.is_a?(DateTime) || reference.is_a?(Time)
+        period_for_utc(reference).dst?
       else
-        dst_period(reference).present?
+        dst_period(reference)
       end
     end
 
-    # Return the correction applied to the standard offset the timezone when the Daylight Saving Time (DST) is active.
+    # Gets a period for this timezone when the Daylight Saving Time (DST) is active (it takes care of different hemispheres).
     #
-    # @param rational [Boolean] If to return the offset as a Rational.
     # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @return [Fixnum|Rational] The correction for dst.
-    def dst_correction(rational = false, year = nil)
-      dst_offset(rational, year, :std_offset)
+    # @return [TimezonePeriod] A period when the Daylight Saving Time (DST) is active or `nil` if the timezone doesn't use DST for that year.
+    def dst_period(year = nil)
+      year ||= ::Date.current.year
+
+      period = period_for_utc(::DateTime.civil(year, 7, 15, 12).utc) # Summer for the northern hemisphere
+      period = period_for_utc(::DateTime.civil(year, 1, 15, 12).utc) unless period.dst? # Summer for the southern hemisphere
+      period.dst? ? period : nil
+    rescue
+      nil
     end
 
-    # Returns the standard offset for this timezone timezone when the Daylight Saving Time (DST) is active.
+    # Return the correction applied to the standard offset the timezone when the Daylight Saving Time (DST) is active.
     #
     # @param rational [Boolean] If to return the offset as a Rational.
     # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @param method [Symbol] The method to use for getting the offset. Default is total offset from UTC.
-    # @return [Fixnum|Rational] The DST offset for this timezone or `0`, if the timezone doesn't use DST for that year.
-    def dst_offset(rational = false, year = nil, method = :utc_total_offset)
-      period = dst_period(year)
-      rv = period ? period.send(method) : 0
+    # @return [Fixnum|Rational] The correction for dst.
+    def dst_correction(rational = false, year = nil)
+      rv = dst_offset(year, :std_offset)
       rational ? self.class.rationalize_offset(rv) : rv
     end
 
-    # Returns the name for this zone with Daylight Saving Time (DST) active.
+    # Formats this zone as a string.
     #
-    # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-    # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @param name [String] The name to use for this zone. Defaults to the zone name.
-    # @return [String] The name for the zone with DST or `nil`, if the timezone doesn't use DST for that year.
-    def dst_name(dst_label = nil, year = nil, name = nil)
-      uses_dst?(year) ? "#{name || self.name} #{dst_label || "(DST)"}" : nil
-    end
-
-    # Returns the name for this zone with Daylight Saving Time (DST) active.
+    # @param dst [Boolean] If to represent with (DST) active.
+    # @param args [Hash] Parameters for the formatting:
     #
-    # @param name [String] The name to use for this zone. Defaults to the zone name.
-    # @param colon [Boolean] If to put the colon in the output string.
-    # @return [String] The name for this zone.
-    def to_str(name = nil, colon = true)
-      "(GMT#{formatted_offset(colon)}) #{name || current_alias}"
-    end
-
-    # Returns a string representation for this zone with Daylight Saving Time (DST) active.
+    #   * **label** (`String`): The label to use. Default to the current alias.
+    #   * **dst_label** (`String`): Label for the DST indication. Defaults to ` (DST)`.
+    #   * **utc_label** (`String`): Label for the UTC name. Defaults to `GMT`. *Only used when `parameterized` is `false`.
+    #   * **year** (`Fixnum`): The year to which refer to. Defaults to the current year.
+    #   * **parameterized** (`Boolean`): If to represent as parameterized.
+    #   * **with_offset** (`Boolean`): If to include offset into the representation. *Only used when `parameterized` is `true`.
+    #   * **offset_position** (`Symbol`): Where to put the offset. Valid values are `:begin` or `:end`. *Only used when `parameterized` is `false`.
+    #   * **colon** (`Boolean`): If include a colon in the offset. *Only used when `parameterized` is `false`.
     #
-    # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-    # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @param name [String] The name to use for this zone. Defaults to the zone name.
-    # @return [String] The string representation for the zone with DST or `nil`, if the timezone doesn't use DST for that year.
-    def to_str_with_dst(dst_label = nil, year = nil, name = nil)
-      uses_dst?(year) ? "(GMT#{self.class.seconds_to_utc_offset(dst_period(year).utc_total_offset)}) #{name || current_alias} #{dst_label || "(DST)"}" : nil
-    end
+    # @return [String] The string representation for this zone.
+    def to_str(dst = false, **args)
+      # PI: Ignore reek on this.
+      label, dst_label, utc_label, year, parameterized, with_offset, colon, offset_position = prepare_to_str_arguments(args)
 
-    # Returns a parameterized string representation for this zone.
-    #
-    # @param with_offset [Boolean] If to include offset into the representation.
-    # @param name [String] The name to use for this zone. Defaults to the zone name.
-    # @return [String] The parameterized string representation for this zone.
-    def to_str_parameterized(with_offset = true, name = nil)
-      ::ActiveSupport::TimeZone.parameterize_zone(name || to_str, with_offset)
-    end
+      if parameterized
+        self.class.parameterize(to_str(dst, label: label, dst_label: dst_label, utc_label: utc_label, year: year, parameterized: false), with_offset)
+      else
+        offset_label = self.class.seconds_to_utc_offset(offset(rational: false, dst: dst, year: year), colon)
+        dst_label = "" unless dst
 
-    # Returns a parameterized string representation for this zone with Daylight Saving Time (DST) active.
-    #
-    # @param dst_label [String] Label for the DST indication. Defaults to `(DST)`.
-    # @param year [Fixnum] The year to which refer to. Defaults to the current year.
-    # @param name [String] The name to use for this zone. Defaults to the zone name.
-    # @return [String] The parameterized string representation for this zone with DST or `nil`, if the timezone doesn't use DST for that year.
-    def to_str_with_dst_parameterized(dst_label = nil, year = nil, name = nil)
-      rv = to_str_with_dst(dst_label, year, name)
-      rv ? ::ActiveSupport::TimeZone.parameterize_zone(rv) : nil
+        to_str_unparameterized(dst_label, label, offset_label, offset_position, utc_label, with_offset)
+      end
     end
 
     private
 
-    # Formats a time zone alias.
-    #
-    # @param name [String] The zone name.
-    # @param zone [String] The zone.
-    # @param reference [String] The main name for the zone.
-    # @return [String|nil] The formatted alias.
+    # :nodoc
     def format_alias(name, zone, reference)
       if zone.gsub("_", " ") == reference
         ["International Date Line West", "UTC"].include?(name) || name.include?("(US & Canada)") ? name : reference.gsub(/\/.*/, "/#{name}")
@@ -309,5 +286,32 @@ module Lazier
         nil
       end
     end
+
+    # :nodoc:
+    def dst_offset(year, method)
+      period = dst_period(year)
+      period ? period.send(method) : 0
+    end
+
+    # :nodoc:
+    def prepare_to_str_arguments(args)
+      args = args.reverse_merge(
+        label: current_alias, dst_label: " (DST)", utc_label: "GMT", year: nil, parameterized: false,
+        with_offset: true, colon: true, offset_position: :begin
+      ).symbolize_keys
+
+      [:label, :dst_label, :utc_label, :year, :parameterized, :with_offset, :colon, :offset_position].map { |e| args[e] }
+    end
+
+    # :nodoc:
+    def to_str_unparameterized(dst_label, label, offset_label, offset_position, utc_label, with_offset)
+      if !with_offset
+        format("%s%s", label, dst_label)
+      elsif offset_position != :end
+        format("(%s%s) %s%s", utc_label, offset_label, label, dst_label)
+      else
+        format("%s%s (%s%s)", label, dst_label, utc_label, offset_label)
+      end
+    end
   end
 end