lazier 3.5.7 → 4.0.0

data/spec/lazier/pathname_spec.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/spec/lazier/settings_spec.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,11 +8,10 @@ require "spec_helper"
 describe Lazier::Settings do
   let(:subject) { ::Lazier::Settings.instance }
   let(:number_subject) { 123456.654321 }
-  let(:date_subject) { DateTime.civil(2005, 6, 7, 8, 9, 10, DateTime.rationalize_offset(25200)) }
+  let(:date_subject) { DateTime.civil(2005, 6, 7, 8, 9, 10, ::ActiveSupport::TimeZone.rationalize_offset(25200)) }
 
   before(:all) do
     Lazier.load!
-    ::Lazier::Settings.instance.i18n = :en
   end
 
   describe ".instance" do
@@ -45,16 +43,16 @@ describe Lazier::Settings do
 
   describe "#setup_format_number" do
     it "should save format numbering options for usage" do
-      subject.setup_format_number(2)
+      subject.setup_format_number(precision: 2)
       expect(number_subject.format_number).to eq("123,456.65")
 
-      subject.setup_format_number(3, "A")
+      subject.setup_format_number(precision: 3, decimal_separator: "A")
       expect(number_subject.format_number).to eq("123,456A654")
 
-      subject.setup_format_number(4, "A", "B")
+      subject.setup_format_number(precision: 4, decimal_separator: "A", add_string: "B")
       expect(number_subject.format_number).to eq("123,456A6543 B")
 
-      subject.setup_format_number(5, "A", "B", "C")
+      subject.setup_format_number(precision: 5, decimal_separator: "A", add_string: "B", k_separator: "C")
       expect(number_subject.format_number).to eq("123C456A65432 B")
 
       subject.setup_format_number
@@ -64,13 +62,13 @@ describe Lazier::Settings do
 
   describe "#setup_boolean_names" do
     it "should save names for boolean values" do
-      subject.setup_boolean_names("TRUE1")
+      subject.setup_boolean_names(true_name: "TRUE1")
       expect([true.format_boolean, false.format_boolean]).to eq(["TRUE1", "No"])
 
-      subject.setup_boolean_names(nil, "FALSE1")
+      subject.setup_boolean_names(false_name: "FALSE1")
       expect([true.format_boolean, false.format_boolean]).to eq(["Yes", "FALSE1"])
 
-      subject.setup_boolean_names("TRUE2", "FALSE2")
+      subject.setup_boolean_names(true_name: "TRUE2", false_name: "FALSE2")
       expect([true.format_boolean, false.format_boolean]).to eq(["TRUE2", "FALSE2"])
 
       subject.setup_boolean_names
@@ -83,26 +81,25 @@ describe Lazier::Settings do
       subject.setup_date_formats(nil, true)
 
       subject.setup_date_formats({c1: "%Y"})
-      expect(date_subject.lstrftime(:ct_date)).to eq(date_subject.strftime("%Y-%m-%d"))
-      expect(date_subject.lstrftime("c1")).to eq(date_subject.year.to_s)
+      expect(date_subject.format(:ct_date)).to eq(date_subject.strftime("%Y-%m-%d"))
+      expect(date_subject.format("c1")).to eq(date_subject.year.to_s)
 
       subject.setup_date_formats({c1: "%Y"}, true)
-      expect(date_subject.lstrftime("ct_date")).to eq("ct_date")
-      expect(date_subject.lstrftime(:c1)).to eq(date_subject.year.to_s)
+      expect(date_subject.format("ct_date")).to eq("ct_date")
+      expect(date_subject.format(:c1)).to eq(date_subject.year.to_s)
 
       subject.setup_date_formats
-      expect(date_subject.lstrftime(:ct_date)).to eq(date_subject.strftime("%Y-%m-%d"))
-      expect(date_subject.lstrftime("c1")).to eq(date_subject.year.to_s)
+      expect(date_subject.format(:ct_date)).to eq(date_subject.strftime("%Y-%m-%d"))
+      expect(date_subject.format("c1")).to eq(date_subject.year.to_s)
 
       subject.setup_date_formats(nil, true)
-      expect(date_subject.lstrftime("ct_date")).to eq(date_subject.strftime("%Y-%m-%d"))
-      expect(date_subject.lstrftime(:c1)).to eq("c1")
+      expect(date_subject.format("ct_date")).to eq(date_subject.strftime("%Y-%m-%d"))
+      expect(date_subject.format(:c1)).to eq("c1")
     end
   end
 
   describe "#setup_date_names" do
     it "should save names for days and months" do
-      subject.i18n = :en
       subject.setup_date_names
       subject.setup_date_formats({sdn: "%B %b %A %a"})
 
@@ -111,20 +108,20 @@ describe Lazier::Settings do
       long_days = 7.times.map {|i| (i + 1).to_s * 2}
       short_days = 7.times.map {|i| (i + 1).to_s}
 
-      subject.setup_date_names(long_months)
-      expect(date_subject.lstrftime(:sdn)).to eq("66 Jun Tuesday Tue")
+      subject.setup_date_names(long_months: long_months)
+      expect(date_subject.format(:sdn)).to eq("66 Jun Tuesday Tue")
 
-      subject.setup_date_names(long_months, short_months)
-      expect(date_subject.lstrftime("sdn")).to eq("66 6 Tuesday Tue")
+      subject.setup_date_names(long_months: long_months, short_months: short_months)
+      expect(date_subject.format("sdn")).to eq("66 6 Tuesday Tue")
 
-      subject.setup_date_names(long_months, short_months, long_days)
-      expect(date_subject.lstrftime(:sdn)).to eq("66 6 33 Tue")
+      subject.setup_date_names(long_months: long_months, short_months: short_months, long_days: long_days)
+      expect(date_subject.format(:sdn)).to eq("66 6 33 Tue")
 
-      subject.setup_date_names(long_months, short_months, long_days, short_days)
-      expect(date_subject.lstrftime("sdn")).to eq("66 6 33 3")
+      subject.setup_date_names(long_months: long_months, short_months: short_months, long_days: long_days, short_days: short_days)
+      expect(date_subject.format("sdn")).to eq("66 6 33 3")
 
       subject.setup_date_names
-      expect(date_subject.lstrftime(:sdn)).to eq("June Jun Tuesday Tue")
+      expect(date_subject.format(:sdn)).to eq("June Jun Tuesday Tue")
     end
   end
 end

data/spec/lazier/string_spec.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.
@@ -30,18 +29,6 @@ describe Lazier::String do
     end
   end
 
-  describe "#untitleize" do
-    it "should convert spaces to dashes" do
-      expect(subject.untitleize).to eq(untitleized_subject)
-    end
-  end
-
-  describe "#replace_ampersands" do
-    it "should remove HTML ampersands" do
-      expect(subject.replace_ampersands).to eq(amp_subject)
-    end
-  end
-
   describe "#value" do
     it "should return the string itself" do
       expect(subject.value).to eq(subject)
@@ -51,14 +38,14 @@ describe Lazier::String do
     end
   end
 
-  describe "split_tokens" do
+  describe "tokenize" do
     it "should return a valid array" do
-      expect("  1, 2,3,4,,,,,5,5".split_tokens()).to eq(["1", "2", "3", "4", "5", "5"])
-      expect("  1, 2,3,4,,,,,5,5".split_tokens(false)).to eq(["1", "2", "3", "4", "", "", "", "", "5", "5"])
-      expect("  1, 2,3,4,,,,,5,5".split_tokens(true, false)).to eq(["  1", "2", "3", "4", "5", "5"])
-      expect("  1, 2,3,4,,,,,5,5".split_tokens(true, true, true)).to eq(["1", "2", "3", "4", "5"])
-      expect("  1, 2,3,4,,,,,5,5".split_tokens(true, true, false, "@")).to eq(["1, 2,3,4,,,,,5,5"])
-      expect("1@2@3@4@5".split_tokens(true, true, false, "@")).to eq(["1", "2", "3", "4", "5"])
+      expect("  1, 2,3,4,,,,,5,5".tokenize()).to eq(["1", "2", "3", "4", "5", "5"])
+      expect("  1, 2,3,4,,,,,5,5".tokenize(no_blanks: false)).to eq(["1", "2", "3", "4", "", "", "", "", "5", "5"])
+      expect("  1, 2,3,4,,,,,5,5".tokenize(strip: false)).to eq(["  1", "2", "3", "4", "5", "5"])
+      expect("  1, 2,3,4,,,,,5,5".tokenize(no_duplicates: true)).to eq(["1", "2", "3", "4", "5"])
+      expect("  1, 2,3,4,,,,,5,5".tokenize(pattern: "@")).to eq(["1, 2,3,4,,,,,5,5"])
+      expect("1@2@3@4@5".tokenize(pattern: "@")).to eq(["1", "2", "3", "4", "5"])
     end
   end
 end

data/spec/lazier/timezone_spec.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,18 +6,17 @@
 require "spec_helper"
 
 describe Lazier::TimeZone do
+  let(:subject_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
   let(:subject_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
   let(:zone_without_dst) { ::ActiveSupport::TimeZone["International Date Line West"] }
 
   before(:all) do
     ::Lazier.load!
-    ::Lazier::Settings.instance(true)
-    ::Lazier::Settings.instance.i18n = :en
+    ::Time.zone = ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"]
   end
 
   describe ".rationalize_offset" do
     it "should return the correct rational value" do
-      expect(::ActiveSupport::TimeZone.rationalize_offset(::ActiveSupport::TimeZone[4])).to eq(Rational(1, 6))
       expect(::ActiveSupport::TimeZone.rationalize_offset(-25200)).to eq(Rational(-7, 24))
     end
   end
@@ -30,52 +28,74 @@ describe Lazier::TimeZone do
     end
   end
 
-  describe ".parameterize_zone" do
-    it "should return the parameterized version of the zone" do
-      expect(::ActiveSupport::TimeZone.parameterize_zone(subject_zone.to_str)).to eq(subject_zone.to_str_parameterized)
-      expect(::ActiveSupport::TimeZone.parameterize_zone(subject_zone.to_str)).to eq(subject_zone.to_str_parameterized)
-      expect(::ActiveSupport::TimeZone.parameterize_zone(subject_zone.to_str, false)).to eq(subject_zone.to_str_parameterized(false))
-      expect(::ActiveSupport::TimeZone.parameterize_zone("INVALID")).to eq("invalid")
+  describe ".find" do
+    it "should find timezones" do
+      expect(::ActiveSupport::TimeZone.find("(GMT-07:00) Mountain Time (US & Canada)")).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) (DST)")).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) Daylight Saving Time", " Daylight Saving Time")).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.find("INVALID", "INVALID")).to be_nil
+    end
+  end
+
+  describe ".list" do
+    it "should list all timezones as list" do
+      expect(::ActiveSupport::TimeZone.list(false)).to include("(GMT-11:00) Pacific/American Samoa", "(GMT-11:00) International Date Line West")
+      expect(::ActiveSupport::TimeZone.list(false).first).to eq("(GMT+01:00) Africa/Algiers")
+      expect(::ActiveSupport::TimeZone.list(false, sort_by_name: false).first).to eq("(GMT-11:00) Pacific/American Samoa")
+      expect(::ActiveSupport::TimeZone.list(false)).to include("(GMT-11:00) Pacific/American Samoa", "(GMT-11:00) International Date Line West")
+      expect(::ActiveSupport::TimeZone.list(true)).to include("(GMT-06:00) #{subject_zone.aliases.first} (DST)")
+      expect(::ActiveSupport::TimeZone.list(true, dst_label: " Daylight Saving Time")).to include("(GMT-06:00) #{subject_zone.aliases.first} Daylight Saving Time")
+      expect(::ActiveSupport::TimeZone.list(true, parameterized: true)).to include("-0600@mountain-time-us-canada-dst")
+    end
+
+    it "should list all timezones as hash" do
+      expect(::ActiveSupport::TimeZone.list(true, sort_by_name: true, as_hash: true)["(GMT-06:00) #{subject_zone.aliases.first} (DST)"]).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.list(true, sort_by_name: true, as_hash: true).keys.first).to eq("(GMT+01:00) Africa/Algiers")
+      expect(::ActiveSupport::TimeZone.list(true, sort_by_name: false, as_hash: true).keys.first).to eq("(GMT-11:00) Pacific/American Samoa")
+      expect(::ActiveSupport::TimeZone.list(true, as_hash: true, parameterized: true)).to include("-0700@mountain-time-us-canada")
+
     end
   end
 
-  describe ".unparameterize_zone" do
+  describe ".parameterize" do
     it "should return the parameterized version of the zone" do
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(subject_zone.to_str_parameterized)).to eq(subject_zone)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(subject_zone.to_str_parameterized, true)).to eq(subject_zone.to_str)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(subject_zone.to_str_with_dst_parameterized)).to eq(subject_zone)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(subject_zone.to_str_with_dst_parameterized, true)).to eq(subject_zone.to_str_with_dst)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone("INVALID")).to eq(nil)
+      expect(::ActiveSupport::TimeZone.parameterize(subject_zone)).to eq("-0700@mountain-time-us-canada")
+      expect(::ActiveSupport::TimeZone.parameterize(subject_zone.to_str)).to eq("-0700@mountain-time-us-canada")
+      expect(::ActiveSupport::TimeZone.parameterize(subject_zone, false)).to eq("mountain-time-us-canada")
+      expect(::ActiveSupport::TimeZone.parameterize("INVALID")).to eq("invalid")
+      expect(::ActiveSupport::TimeZone.parameterize("-0700@mountain-time-us-canada")).to eq("-0700@mountain-time-us-canada")
     end
   end
 
-  describe ".find" do
-    it "should find timezones" do
-      expect(::ActiveSupport::TimeZone.find("(GMT-07:00) Mountain Time (US & Canada)")).to eq(subject_zone)
-      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) (DST)")).to eq(subject_zone)
-      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) Daylight Saving Time", "Daylight Saving Time")).to eq(subject_zone)
-      expect(::ActiveSupport::TimeZone.find("INVALID", "INVALID")).to be_nil
+  describe ".unparameterize" do
+    it "should return the parameterized version of the zone" do
+      expect(::ActiveSupport::TimeZone.unparameterize("-0700@mountain-time-us-canada")).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.unparameterize("mountain-time-us-canada")).to be_nil
+      expect(::ActiveSupport::TimeZone.unparameterize("-0600@mountain-time-us-canada-day", " DAY")).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.unparameterize(subject_zone.to_str)).to eq(subject_zone)
+      expect(::ActiveSupport::TimeZone.unparameterize("INVALID")).to eq(nil)
     end
   end
 
-  describe ".list_all" do
-    it "should list all timezones" do
-      expect(::ActiveSupport::TimeZone.list_all(false)).to eq(::ActiveSupport::TimeZone.all.map(&:to_s))
-      expect(::ActiveSupport::TimeZone.list_all(true)).to include("(GMT-06:00) #{subject_zone.aliases.first} (DST)")
-      expect(::ActiveSupport::TimeZone.list_all(true, "Daylight Saving Time")).to include("(GMT-06:00) #{subject_zone.aliases.first} Daylight Saving Time")
+  describe "#compare" do
+    it "should correctly compare timezones" do
+      expect(::ActiveSupport::TimeZone.compare(::ActiveSupport::TimeZone["Africa/Algiers"], ::ActiveSupport::TimeZone["International Date Line West"])).to eq(-1)
+      expect(::ActiveSupport::TimeZone.compare(::ActiveSupport::TimeZone["Africa/Algiers"], ::ActiveSupport::TimeZone["Africa/Algiers"])).to eq(0)
+      expect(::ActiveSupport::TimeZone.compare(::ActiveSupport::TimeZone["Europe/Madrid"], ::ActiveSupport::TimeZone["Europe/Copenhagen"])).to eq(1)
+      expect(::ActiveSupport::TimeZone.compare("(GMT+01:00) Europe/Rome", "(GMT+02:00) Europe/Kiev")).to eq(1)
     end
   end
 
-  describe "#offset" do
-    it "should correctly return zone offset" do
-      expect(subject_zone.offset).to eq(subject_zone.utc_offset)
+  describe "#aliases" do
+    it "should return the right list of aliases" do
+      expect(ActiveSupport::TimeZone["America/Los_Angeles"].aliases).to eq(["America/Los Angeles", "Pacific Time (US & Canada)"])
     end
   end
 
   describe "#current_offset" do
     it "should correctly return current zone offset" do
-      expect(subject_zone.current_offset(false, ::DateTime.civil(2012, 1, 15))).to eq(subject_zone.offset)
-      expect(subject_zone.current_offset(true, ::DateTime.civil(2012, 7, 15))).to eq(subject_zone.dst_offset(true))
+      expect(subject_zone.current_offset(false, ::DateTime.civil(2012, 1, 15))).to eq(-25200)
+      expect(subject_zone.current_offset(true, ::DateTime.civil(2012, 7, 15))).to eq(Rational(-1, 4))
     end
   end
 
@@ -83,43 +103,44 @@ describe Lazier::TimeZone do
     it "should correctly return current zone alias or the first one" do
       zone = ActiveSupport::TimeZone["America/Halifax"]
       expect(zone.current_alias).to eq("America/Halifax")
-      allow(zone.tzinfo).to receive(:identifier).and_return("INVALID")
+      allow(zone).to receive(:name).and_return("INVALID")
       expect(zone.current_alias).to eq("America/Atlantic Time (Canada)")
     end
   end
 
-  describe "#current_alias=" do
-    it "should set the current alias alias" do
-      zone = ActiveSupport::TimeZone["America/Halifax"]
-      zone.current_alias = "ALIAS"
-      expect(zone.current_alias).to eq("ALIAS")
+  describe "#current_name" do
+    it "should correctly get zone name with Daylight Saving Time" do
+      expect(subject_zone.current_name).to eq("Mountain Time (US & Canada)")
+      expect(subject_zone.current_name(true)).to eq("Mountain Time (US & Canada) (DST)")
+      expect(subject_zone.current_name(true, dst_label: "-dst")).to eq("Mountain Time (US & Canada)-dst")
+      expect(subject_zone.current_name(true, year: 1000)).to eq("Mountain Time (US & Canada)")
     end
   end
 
-  describe "#dst_period" do
+  describe "#offset" do
     it "should correctly return zone offset" do
-      expect(subject_zone.dst_period).to be_a(::TZInfo::TimezonePeriod)
-      expect(subject_zone.dst_period(1000)).to be_nil
-      expect(zone_without_dst.dst_period).to be_nil
+      expect(subject_zone.offset).to eq(subject_zone.utc_offset)
     end
   end
 
   describe "#uses_dst?" do
     it "should correctly detect offset usage" do
-      expect(subject_zone.uses_dst?).to be_true
-      expect(subject_zone.uses_dst?(::DateTime.civil(2012, 7, 15))).to be_true
-      expect(subject_zone.uses_dst?(::DateTime.civil(2012, 1, 15))).to be_false
-      expect(subject_zone.uses_dst?(1000)).to be_false
-      expect(zone_without_dst.uses_dst?).to be_false
+      expect(subject_zone.uses_dst?).to be_truthy
+      expect(subject_zone.uses_dst?(::DateTime.civil(2012, 7, 15))).to be_truthy
+      expect(subject_zone.uses_dst?(::DateTime.civil(2012, 1, 15))).to be_falsey
+      expect(subject_zone.uses_dst?(1000)).to be_falsey
+      expect(zone_without_dst.uses_dst?).to be_falsey
     end
   end
 
-  describe "#dst_name" do
-    it "should correctly get zone name with Daylight Saving Time" do
-      expect(subject_zone.dst_name).to eq("Mountain Time (US & Canada) (DST)")
-      expect(subject_zone.dst_name("Daylight Saving Time")).to eq("Mountain Time (US & Canada) Daylight Saving Time")
-      expect(subject_zone.dst_name(nil, 1000)).to be_nil
-      expect(zone_without_dst.to_str_with_dst).to be_nil
+  describe "#dst_period" do
+    it "should correctly return zone offset" do
+      expect(subject_zone.dst_period).to be_a(::TZInfo::TimezonePeriod)
+      expect(subject_zone.dst_period(1000)).to be_nil
+      expect(zone_without_dst.dst_period).to be_nil
+
+      expect(zone_without_dst).to receive(:period_for_utc).and_raise(RuntimeError)
+      expect(zone_without_dst.dst_period).to be_nil
     end
   end
 
@@ -132,40 +153,33 @@ describe Lazier::TimeZone do
     end
   end
 
-  describe "#dst_offset" do
-    it "should correctly return zone offset" do
-      expect(subject_zone.dst_offset).to eq(subject_zone.dst_correction + subject_zone.utc_offset)
-      expect(subject_zone.dst_offset(true)).to eq(::ActiveSupport::TimeZone.rationalize_offset(subject_zone.dst_correction + subject_zone.utc_offset))
-      expect(zone_without_dst.dst_offset(false, 1000)).to eq(0)
-      expect(zone_without_dst.dst_offset).to eq(0)
-    end
-  end
-
-  describe "#to_str_with_dst" do
-    it "should correctly format zone with Daylight Saving Time" do
-      expect(subject_zone.to_str_with_dst).to eq("(GMT-06:00) #{subject_zone.current_alias} (DST)")
-      expect(subject_zone.to_str_with_dst("Daylight Saving Time")).to eq("(GMT-06:00) #{subject_zone.current_alias} Daylight Saving Time")
-      expect(subject_zone.to_str_with_dst("Daylight Saving Time", nil, "NAME")).to eq("(GMT-06:00) NAME Daylight Saving Time")
-      expect(subject_zone.to_str_with_dst(nil, 1000)).to be_nil
-      expect(zone_without_dst.to_str_with_dst).to be_nil
-    end
-  end
-
-  describe "#to_str_parameterized" do
-    it "should correctly format (parameterized) zone" do
-      expect(subject_zone.to_str_parameterized).to eq(::ActiveSupport::TimeZone.parameterize_zone(subject_zone.to_str))
-      expect(subject_zone.to_str_parameterized(false)).to eq(::ActiveSupport::TimeZone.parameterize_zone(subject_zone.to_str, false))
-      expect(subject_zone.to_str_parameterized(false, "NAME SPACE")).to eq(::ActiveSupport::TimeZone.parameterize_zone("NAME SPACE", false))
-    end
-  end
-
-  describe "#to_str_with_dst_parameterized" do
-    it "should correctly format (parameterized) zone with Daylight Saving Time" do
-      expect(subject_zone.to_str_with_dst_parameterized).to eq("-0600@mountain-time-us-canada-dst")
-      expect(subject_zone.to_str_with_dst_parameterized("Daylight Saving Time")).to eq("-0600@mountain-time-us-canada-daylight-saving-time")
-      expect(subject_zone.to_str_with_dst_parameterized(nil, 1000)).to be_nil
-      expect(subject_zone.to_str_with_dst_parameterized("Daylight Saving Time", nil, "NAME SPACE")).to eq("-0600@name-space-daylight-saving-time")
-      expect(zone_without_dst.to_str_with_dst_parameterized).to be_nil
+  describe "#to_str" do
+    describe "parameterized" do
+      it "should correctly parameterize the zone" do
+        expect(subject_zone.to_str(parameterized: true, label: "FOO")).to eq("-0700@foo")
+        expect(subject_zone.to_str(parameterized: true)).to eq("-0700@mountain-time-us-canada")
+        expect(subject_zone.to_str(true, parameterized: true)).to eq("-0600@mountain-time-us-canada-dst")
+        expect(subject_zone.to_str(true, parameterized: true, dst_label: "-DAY")).to eq("-0600@mountain-time-us-canada-day")
+        expect(subject_zone.to_str(true, parameterized: true, utc_label: "UTC")).to eq("-0600@mountain-time-us-canada-dst")
+        expect(subject_zone.to_str(parameterized: true, year: 1000)).to eq("-0700@mountain-time-us-canada")
+        expect(subject_zone.to_str(parameterized: true, with_offset: false)).to eq("mountain-time-us-canada")
+      end
+    end
+
+    describe "not parameterized" do
+      it "should correctly parameterize the zone" do
+        expect(subject_zone.to_str(label: "FOO")).to eq("(GMT-07:00) FOO")
+        expect(subject_zone.to_str).to eq("(GMT-07:00) Mountain Time (US & Canada)")
+        expect(subject_zone.to_str(true)).to eq("(GMT-06:00) Mountain Time (US & Canada) (DST)")
+        expect(subject_zone.to_str(true, dst_label: "-DAY")).to eq("(GMT-06:00) Mountain Time (US & Canada)-DAY")
+        expect(subject_zone.to_str(true, utc_label: "UTC")).to eq("(UTC-06:00) Mountain Time (US & Canada) (DST)")
+        expect(subject_zone.to_str(year: 1000)).to eq("(GMT-07:00) Mountain Time (US & Canada)")
+        expect(subject_zone.to_str(with_offset: false)).to eq("Mountain Time (US & Canada)")
+        expect(subject_zone.to_str(offset_position: :end)).to eq("Mountain Time (US & Canada) (GMT-07:00)")
+        expect(subject_zone.to_str(offset_position: :other)).to eq("(GMT-07:00) Mountain Time (US & Canada)")
+        expect(subject_zone.to_str(colon: false)).to eq("(GMT-0700) Mountain Time (US & Canada)")
+        expect(subject_zone.to_str).to eq("(GMT-07:00) Mountain Time (US & Canada)")
+      end
     end
   end
 end

data/spec/lazier_spec.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,7 +8,6 @@ require "spec_helper"
 describe Lazier do
   describe ".load!" do
     describe "should load all extensions by default" do
-      ENV["LANG"] = "en"
       ::Lazier.load!
 
       it "for Boolean" do
@@ -19,7 +17,7 @@ describe Lazier do
 
       it "for DateTime" do
         expect(::DateTime).to respond_to(:custom_format)
-        expect(::DateTime.now).to respond_to(:lstrftime)
+        expect(::DateTime.now).to respond_to(:format)
       end
 
       it "for Hash" do
@@ -31,7 +29,7 @@ describe Lazier do
       end
 
       it "for Object" do
-        expect(0).to respond_to(:for_debug)
+        expect(0).to respond_to(:to_debug)
       end
 
       it "for Pathname" do
@@ -39,7 +37,7 @@ describe Lazier do
       end
 
       it "for String" do
-        expect("").to respond_to(:remove_accents)
+        expect("").to respond_to(:ensure_valid_utf8)
       end
     end
   end
@@ -87,12 +85,31 @@ describe Lazier do
     end
 
     it "without a message should return the elapsed time" do
-      expect(Lazier.benchmark { control = "OK" }).to be_a(Float)
+      expect(Lazier.benchmark { "OK" }).to be_a(Float)
     end
 
     it "with a message should embed the elapsed time into the given message" do
-      expect(Lazier.benchmark("MESSAGE") { control = "OK" }).to match(/^MESSAGE \(\d+ ms\)$/)
-      expect(Lazier.benchmark("MESSAGE", 2) { control = "OK" }).to match(/^MESSAGE \(\d+\.\d+ ms\)$/)
+      expect(Lazier.benchmark(message: "MESSAGE") { "OK" }).to match(/^MESSAGE \(\d+ ms\)$/)
+      expect(Lazier.benchmark(message: "MESSAGE", precision: 2) { "OK" }).to match(/^MESSAGE \(\d+\.\d+ ms\)$/)
+    end
+  end
+
+  describe ".platform" do
+    it "should detect the right platform" do
+      stub_const("RUBY_PLATFORM", "cygwin")
+      expect(Lazier.platform(true)).to eq(:win32)
+
+      stub_const("RUBY_PLATFORM", "darwin")
+      expect(Lazier.platform(true)).to eq(:osx)
+
+      stub_const("RUBY_PLATFORM", "java")
+      expect(Lazier.platform(true)).to eq(:java)
+
+      stub_const("RUBY_PLATFORM", "whatever")
+      expect(Lazier.platform(true)).to eq(:posix)
+
+      stub_const("RUBY_PLATFORM", "osx")
+      expect(Lazier.platform).to eq(:posix)
     end
   end
 end