lazier 3.5.0 → 3.5.1

data/lib/lazier/hash.rb

@@ -7,6 +7,14 @@
 module Lazier
   # Extensions for Hash objects.
   module Hash
+    # The supported accesses for #ensure_access
+    VALID_ACCESSES = {
+      strings: :stringify_keys,
+      symbols: :symbolize_keys,
+      indifferent: :with_indifferent_access,
+      dotted: :enable_dotted_access
+    }
+
     extend ::ActiveSupport::Concern
 
     # Returns a new hash, removing all keys which values are blank.
@@ -28,11 +36,14 @@ module Lazier
 
     # Makes sure that the keys of the hash are accessible in the desired way.
     #
-    # @param access [Symbol|NilClass] The requested access for the keys. Can be `:strings`, `:symbols` or `:indifferent`. If `nil` the keys are not modified.
+    # @param accesses [Array] The requested access for the keys. Can be `:strings`, `:symbols` or `:indifferent`. If `nil` the keys are not modified.
     # @return [Hash] The current hash with keys modified.
-    def ensure_access(access)
-      method = {strings: :stringify_keys, symbols: :symbolize_keys, indifferent: :with_indifferent_access, dotted: :enable_dotted_access}.fetch(access, nil)
-      method ? send(method) : self
+    def ensure_access(*accesses)
+      accesses.compact.inject(self) do |rv, access|
+        method = VALID_ACCESSES.fetch(access.ensure_string.to_sym, nil)
+        rv = rv.send(method) if method
+        rv
+      end
     end
 
     # Makes sure that the hash is accessible using dotted notation. This is also applied to every embedded hash.

data/lib/lazier/version.rb

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

data/spec/lazier/configuration_spec.rb

@@ -22,10 +22,10 @@ describe Lazier::Configuration do
     end
 
     it "should not allow writing readonly properties" do
-      reference = ConfigurationSpecSample.new(required: 1)
+      subject = ConfigurationSpecSample.new(required: 1)
 
-      expect { reference.readonly = "4" }.to raise_error(ArgumentError)
-      expect(reference.readonly).to eq("2")
+      expect { subject .readonly = "4" }.to raise_error(ArgumentError)
+      expect(subject .readonly).to eq("2")
     end
 
     it "should blow up for require properties" do

data/spec/lazier/datetime_spec.rb

@@ -7,9 +7,9 @@
 require "spec_helper"
 
 describe Lazier::DateTime do
-  let(:random_reference) { ::DateTime.civil(1990 + rand(30), 1 + rand(10), 1 + rand(25), 1 + rand(20), 1 + rand(58), 1 + rand(58)).in_time_zone }
-  let(:fixed_reference){ ::DateTime.civil(2005, 6, 7, 8, 9, 10, ::DateTime.rationalize_offset(25200)) }
-  let(:reference_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
+  let(:random_subject) { ::DateTime.civil(1990 + rand(30), 1 + rand(10), 1 + rand(25), 1 + rand(20), 1 + rand(58), 1 + rand(58)).in_time_zone }
+  let(:fixed_subject){ ::DateTime.civil(2005, 6, 7, 8, 9, 10, ::DateTime.rationalize_offset(25200)) }
+  let(:subject_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
   let(:zone_without_dst) { ::ActiveSupport::TimeZone["International Date Line West"] }
 
   before(:all) do
@@ -73,7 +73,7 @@ describe Lazier::DateTime do
   describe ".find_timezone" do
     it "should forward to ActiveSupport::TimeZone" do
       expect(::ActiveSupport::TimeZone).to receive(:find)
-      ::DateTime.find_timezone(reference_zone.name)
+      ::DateTime.find_timezone(subject_zone.name)
     end
   end
 
@@ -87,14 +87,14 @@ describe Lazier::DateTime do
   describe ".parameterize_zone" do
     it "should forward to ActiveSupport::TimeZone" do
       expect(::ActiveSupport::TimeZone).to receive(:parameterize_zone)
-      ::DateTime.parameterize_zone(reference_zone)
+      ::DateTime.parameterize_zone(subject_zone)
     end
   end
 
   describe ".unparameterize_zone" do
     it "should forward to ActiveSupport::TimeZone" do
       expect(::ActiveSupport::TimeZone).to receive(:unparameterize_zone)
-      ::DateTime.unparameterize_zone(reference_zone)
+      ::DateTime.unparameterize_zone(subject_zone)
     end
   end
 
@@ -136,40 +136,40 @@ describe Lazier::DateTime do
 
   describe "#utc_time" do
     it "should convert to UTC Time" do
-      expect(random_reference.utc_time).to be_a(::Time)
+      expect(random_subject.utc_time).to be_a(::Time)
     end
   end
 
   describe "#in_months" do
-    it "should return the amount of months passed since the start of the reference year" do
+    it "should return the amount of months passed since the start of the subject year" do
       expect(::Date.today.in_months).to eq(::Date.today.month)
-      expect(fixed_reference.in_months(2000)).to eq(66)
+      expect(fixed_subject.in_months(2000)).to eq(66)
     end
   end
 
   describe "#padded_month" do
     it "should pad the month number" do
-      expect(random_reference.padded_month).to eq(random_reference.month.to_s.rjust(2, "0"))
+      expect(random_subject.padded_month).to eq(random_subject.month.to_s.rjust(2, "0"))
       expect(::Date.civil(2000, 8, 8).padded_month).to eq("08")
     end
   end
 
   describe "#lstrftime" do
     it "should return corrected formatted string" do
-      expect(fixed_reference.lstrftime(:db)).to eq("db")
-      expect(fixed_reference.lstrftime("%F")).to eq("2005-06-07")
-      expect(fixed_reference.lstrftime(:ct_iso_8601)).to eq("2005-06-07T08:09:10+0700")
+      expect(fixed_subject.lstrftime(:db)).to eq("db")
+      expect(fixed_subject.lstrftime("%F")).to eq("2005-06-07")
+      expect(fixed_subject.lstrftime(:ct_iso_8601)).to eq("2005-06-07T08:09:10+0700")
 
       ::Lazier.settings.setup_date_names
       ::Lazier.settings.setup_date_formats({ct_local_test: "%a %A %b %B %d %Y %H"})
-      expect(fixed_reference.lstrftime(:ct_local_test)).to eq("Tue Tuesday Jun June 07 2005 08")
+      expect(fixed_subject.lstrftime(:ct_local_test)).to eq("Tue Tuesday Jun June 07 2005 08")
 
       ::Lazier.settings.setup_date_names(
           12.times.map {|i| (i + 1).to_s * 2}, 12.times.map {|i| (i + 1).to_s},
           7.times.map {|i| (i + 1).to_s * 2}, 7.times.map {|i| (i + 1).to_s}
       )
 
-      expect(fixed_reference.lstrftime(:ct_local_test)).to eq("3 33 6 66 07 2005 08")
+      expect(fixed_subject.lstrftime(:ct_local_test)).to eq("3 33 6 66 07 2005 08")
     end
   end
 
@@ -177,7 +177,7 @@ describe Lazier::DateTime do
     it "should retrieve the date in the current timezone" do
       ::Time.zone = ::ActiveSupport::TimeZone[0]
       ::Lazier.settings.setup_date_formats({ct_local_test: "%a %A %b %B %d %Y %H"})
-      expect(fixed_reference.local_strftime(:ct_local_test)).to eq("Tue Tuesday Jun June 07 2005 01")
+      expect(fixed_subject.local_strftime(:ct_local_test)).to eq("Tue Tuesday Jun June 07 2005 01")
     end
   end
 
@@ -193,14 +193,14 @@ describe Lazier::DateTime do
           7.times.map {|i| (i + 1).to_s * 2}, 7.times.map {|i| (i + 1).to_s}
       )
 
-      expect(fixed_reference.local_lstrftime(:ct_local_test)).to eq("3 33 6 66 07 2005 01")
+      expect(fixed_subject.local_lstrftime(:ct_local_test)).to eq("3 33 6 66 07 2005 01")
     end
   end
 end
 
 describe Lazier::TimeZone do
-  let(:reference_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
-  let(:reference_zone) { ::ActiveSupport::TimeZone["Mountain Time (US & Canada)"] }
+  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
@@ -225,28 +225,28 @@ describe Lazier::TimeZone do
 
   describe ".parameterize_zone" do
     it "should return the parameterized version of the zone" do
-      expect(::ActiveSupport::TimeZone.parameterize_zone(reference_zone.to_str)).to eq(reference_zone.to_str_parameterized)
-      expect(::ActiveSupport::TimeZone.parameterize_zone(reference_zone.to_str)).to eq(reference_zone.to_str_parameterized)
-      expect(::ActiveSupport::TimeZone.parameterize_zone(reference_zone.to_str, false)).to eq(reference_zone.to_str_parameterized(false))
+      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")
     end
   end
 
   describe ".unparameterize_zone" do
     it "should return the parameterized version of the zone" do
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(reference_zone.to_str_parameterized)).to eq(reference_zone)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(reference_zone.to_str_parameterized, true)).to eq(reference_zone.to_str)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(reference_zone.to_str_with_dst_parameterized)).to eq(reference_zone)
-      expect(::ActiveSupport::TimeZone.unparameterize_zone(reference_zone.to_str_with_dst_parameterized, true)).to eq(reference_zone.to_str_with_dst)
+      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)
     end
   end
 
   describe ".find" do
     it "should find timezones" do
-      expect(::ActiveSupport::TimeZone.find("(GMT-07:00) Mountain Time (US & Canada)")).to eq(reference_zone)
-      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) (DST)")).to eq(reference_zone)
-      expect(::ActiveSupport::TimeZone.find("(GMT-06:00) Mountain Time (US & Canada) Daylight Saving Time", "Daylight Saving Time")).to eq(reference_zone)
+      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
@@ -254,21 +254,21 @@ describe Lazier::TimeZone do
   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) #{reference_zone.aliases.first} (DST)")
-      expect(::ActiveSupport::TimeZone.list_all(true, "Daylight Saving Time")).to include("(GMT-06:00) #{reference_zone.aliases.first} Daylight Saving Time")
+      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")
     end
   end
 
   describe "#offset" do
     it "should correctly return zone offset" do
-      expect(reference_zone.offset).to eq(reference_zone.utc_offset)
+      expect(subject_zone.offset).to eq(subject_zone.utc_offset)
     end
   end
 
   describe "#current_offset" do
     it "should correctly return current zone offset" do
-      expect(reference_zone.current_offset(false, ::DateTime.civil(2012, 1, 15))).to eq(reference_zone.offset)
-      expect(reference_zone.current_offset(true, ::DateTime.civil(2012, 7, 15))).to eq(reference_zone.dst_offset(true))
+      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))
     end
   end
 
@@ -283,44 +283,44 @@ describe Lazier::TimeZone do
 
   describe "#dst_period" do
     it "should correctly return zone offset" do
-      expect(reference_zone.dst_period).to be_a(::TZInfo::TimezonePeriod)
-      expect(reference_zone.dst_period(1000)).to be_nil
+      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
     end
   end
 
   describe "#uses_dst?" do
     it "should correctly detect offset usage" do
-      expect(reference_zone.uses_dst?).to be_true
-      expect(reference_zone.uses_dst?(::DateTime.civil(2012, 7, 15))).to be_true
-      expect(reference_zone.uses_dst?(::DateTime.civil(2012, 1, 15))).to be_false
-      expect(reference_zone.uses_dst?(1000)).to be_false
+      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
     end
   end
 
   describe "#dst_name" do
     it "should correctly get zone name with Daylight Saving Time" do
-      expect(reference_zone.dst_name).to eq("Mountain Time (US & Canada) (DST)")
-      expect(reference_zone.dst_name("Daylight Saving Time")).to eq("Mountain Time (US & Canada) Daylight Saving Time")
-      expect(reference_zone.dst_name(nil, 1000)).to be_nil
+      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
     end
   end
 
   describe "#dst_correction" do
     it "should correctly detect offset usage" do
-      expect(reference_zone.dst_correction).to eq(3600)
-      expect(reference_zone.dst_correction(true)).to eq(Rational(1, 24))
-      expect(reference_zone.dst_correction(false, 1000)).to eq(0)
+      expect(subject_zone.dst_correction).to eq(3600)
+      expect(subject_zone.dst_correction(true)).to eq(Rational(1, 24))
+      expect(subject_zone.dst_correction(false, 1000)).to eq(0)
       expect(zone_without_dst.dst_correction).to eq(0)
     end
   end
 
   describe "#dst_offset" do
     it "should correctly return zone offset" do
-      expect(reference_zone.dst_offset).to eq(reference_zone.dst_correction + reference_zone.utc_offset)
-      expect(reference_zone.dst_offset(true)).to eq(::ActiveSupport::TimeZone.rationalize_offset(reference_zone.dst_correction + reference_zone.utc_offset))
+      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
@@ -328,28 +328,28 @@ describe Lazier::TimeZone do
 
   describe "#to_str_with_dst" do
     it "should correctly format zone with Daylight Saving Time" do
-      expect(reference_zone.to_str_with_dst).to eq("(GMT-06:00) #{reference_zone.aliases.first} (DST)")
-      expect(reference_zone.to_str_with_dst("Daylight Saving Time")).to eq("(GMT-06:00) #{reference_zone.aliases.first} Daylight Saving Time")
-      expect(reference_zone.to_str_with_dst("Daylight Saving Time", nil, "NAME")).to eq("(GMT-06:00) NAME Daylight Saving Time")
-      expect(reference_zone.to_str_with_dst(nil, 1000)).to be_nil
+      expect(subject_zone.to_str_with_dst).to eq("(GMT-06:00) #{subject_zone.aliases.first} (DST)")
+      expect(subject_zone.to_str_with_dst("Daylight Saving Time")).to eq("(GMT-06:00) #{subject_zone.aliases.first} 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(reference_zone.to_str_parameterized).to eq(::ActiveSupport::TimeZone.parameterize_zone(reference_zone.to_str))
-      expect(reference_zone.to_str_parameterized(false)).to eq(::ActiveSupport::TimeZone.parameterize_zone(reference_zone.to_str, false))
-      expect(reference_zone.to_str_parameterized(false, "NAME SPACE")).to eq(::ActiveSupport::TimeZone.parameterize_zone("NAME SPACE", false))
+      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(reference_zone.to_str_with_dst_parameterized).to eq("-0600@america-denver-dst")
-      expect(reference_zone.to_str_with_dst_parameterized("Daylight Saving Time")).to eq("-0600@america-denver-daylight-saving-time")
-      expect(reference_zone.to_str_with_dst_parameterized(nil, 1000)).to be_nil
-      expect(reference_zone.to_str_with_dst_parameterized("Daylight Saving Time", nil, "NAME SPACE")).to eq("-0600@name-space-daylight-saving-time")
+      expect(subject_zone.to_str_with_dst_parameterized).to eq("-0600@america-denver-dst")
+      expect(subject_zone.to_str_with_dst_parameterized("Daylight Saving Time")).to eq("-0600@america-denver-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
     end
   end

data/spec/lazier/hash_spec.rb

@@ -7,7 +7,7 @@
 require "spec_helper"
 
 describe Lazier::Hash do
-  let(:reference) {
+  subject {
     rv = {a: 1, "b" => {c: 2, d: {"e" => 3}}}
     rv.default = 0
     rv
@@ -17,10 +17,9 @@ describe Lazier::Hash do
     ::Lazier.load!
   end
 
-
   describe "method access" do
     it "it is not enabled by default" do
-      expect { reference.b }.to raise_error(NoMethodError)
+      expect { subject.b }.to raise_error(NoMethodError)
     end
   end
 
@@ -29,12 +28,12 @@ describe Lazier::Hash do
       ::Lazier.load!(:hash_method_access)
     end
 
-    it "should allow method reference for symbol key" do
-      reference.b.f = 4
+    it "should allow method subject for symbol key" do
+      subject.b.f = 4
 
-      expect(reference.a).to eq(1)
-      expect(reference.b.c).to eq(2)
-      expect(reference["b"]["f"]).to eq(4)
+      expect(subject.a).to eq(1)
+      expect(subject.b.c).to eq(2)
+      expect(subject["b"]["f"]).to eq(4)
     end
   end
 
@@ -48,23 +47,23 @@ describe Lazier::Hash do
     end
 
     it "should not be destructive" do
-      reference = {a: 1, b: nil}
-      reference.compact
-      expect(reference).to eq({a: 1, b: nil})
+      subject = {a: 1, b: nil}
+      subject.compact
+      expect(subject).to eq({a: 1, b: nil})
     end
   end
 
   describe "#compact!" do
     it "should remove blank keys" do
-      reference = {a: 1, b: nil}
-      reference.compact!
-      expect(reference).to eq({a: 1})
+      subject = {a: 1, b: nil}
+      subject.compact!
+      expect(subject).to eq({a: 1})
     end
 
     it "should use a custom validator" do
-      reference = {a: 1, b: nil, c: 3}
-      reference.compact! {|k, v| v == 1 || k == :c}
-      expect(reference).to eq({b: nil})
+      subject = {a: 1, b: nil, c: 3}
+      subject.compact! {|k, v| v == 1 || k == :c}
+      expect(subject).to eq({b: nil})
     end
   end
 
@@ -79,25 +78,27 @@ describe Lazier::Hash do
       expect({a: "b"}.ensure_access(:indifferent)).to be_a(::HashWithIndifferentAccess)
       expect({a: "b"}.ensure_access(:other)).to eq({a: "b"})
 
-      reference.ensure_access(:dotted)
-      expect(reference.a).to eq(1)
-      expect(reference.b.c).to eq(2)
+      accessed = subject.ensure_access(:indifferent, :dotted)
+      expect(accessed[:a]).to eq(1)
+      expect(accessed["a"]).to eq(1)
+      expect(accessed.a).to eq(1)
+      expect(accessed.b.c).to eq(2)
     end
   end
 
   describe "#with_dotted_access" do
     it "should recursively enable dotted access on a hash" do
-      reference = {a: 1, b: {c: 3}, c: [1, {f: {g: 1}}]}
+      subject = {a: 1, b: {c: 3}, c: [1, {f: {g: 1}}]}
 
-      reference.enable_dotted_access
-      expect(reference.b.c).to eq(3)
-      expect(reference.c[1].f.g).to eq(1)
+      subject.enable_dotted_access
+      expect(subject.b.c).to eq(3)
+      expect(subject.c[1].f.g).to eq(1)
     end
 
     it "should also provide write access if asked" do
-      reference.enable_dotted_access(false)
-      expect { reference.b.f = 4 }.not_to raise_error
-      expect(reference["b"]["f"]).to eq(4)
+      subject.enable_dotted_access(false)
+      expect { subject.b.f = 4 }.not_to raise_error
+      expect(subject["b"]["f"]).to eq(4)
     end
   end
 end

data/spec/lazier/i18n_spec.rb

@@ -7,8 +7,8 @@
 require "spec_helper"
 
 describe Lazier::I18n do
-  let(:object) {
-    c = Object.new
+  subject {
+    c = ::Object.new
     c.class_eval { include Lazier::I18n }
     c
   }
@@ -22,39 +22,39 @@ describe Lazier::I18n do
 
   describe "#i18n_setup" do
     it "should set the root and the path" do
-      object.i18n_setup("ROOT", root_path)
-      expect(object.instance_variable_get(:@i18n_root)).to eq(:ROOT)
-      expect(object.instance_variable_get(:@i18n_locales_path)).to eq(root_path)
+      subject.i18n_setup("ROOT", root_path)
+      expect(subject.instance_variable_get(:@i18n_root)).to eq(:ROOT)
+      expect(subject.instance_variable_get(:@i18n_locales_path)).to eq(root_path)
     end
   end
 
   describe "#i18n" do
     it "should call the private method if nothing is set" do
-      object.instance_variable_set(:@i18n, nil)
-      expect(object).to receive(:i18n_load_locale)
-      object.i18n
+      subject.instance_variable_set(:@i18n, nil)
+      expect(subject).to receive(:i18n_load_locale)
+      subject.i18n
     end
   end
 
   describe "#i18n=" do
     it "should call the private method if nothing is set" do
-      expect(object).to receive(:i18n_load_locale).and_return("LOCALE")
-      object.i18n = :en
-      expect(object.instance_variable_get(:@i18n)).to eq("LOCALE")
+      expect(subject).to receive(:i18n_load_locale).and_return("LOCALE")
+      subject.i18n = :en
+      expect(subject.instance_variable_get(:@i18n)).to eq("LOCALE")
     end
   end
 
   describe "#i18n_load_locale" do
     it "should set using system locale if called without arguments" do
-      object.i18n_setup("lazier", root_path)
+      subject.i18n_setup("lazier", root_path)
       expect(::R18n::I18n).to receive(:new).with([ENV["LANG"]].compact.uniq, root_path).and_call_original
-      object.i18n = nil
+      subject.i18n = nil
     end
 
     it "should set the requested locale" do
-      object.i18n_setup("lazier", root_path)
+      subject.i18n_setup("lazier", root_path)
       expect(::R18n::I18n).to receive(:new).with(["it", ENV["LANG"]].compact.uniq, root_path).and_call_original
-      object.i18n = :it
+      subject.i18n = :it
     end
 
     it "should call the root" do
@@ -62,21 +62,21 @@ describe Lazier::I18n do
       t = ::Object.new
       expect_any_instance_of(::R18n::I18n).to receive(:t).and_return(t)
       expect(t).to receive("ROOT")
-      object.i18n_setup("ROOT", root_path)
-      object.i18n = :it
+      subject.i18n_setup("ROOT", root_path)
+      subject.i18n = :it
     end
 
     it "should only pass valid translations" do
-      object.i18n_setup("lazier", root_path)
+      subject.i18n_setup("lazier", root_path)
       expect(::R18n::I18n).to receive(:new).with([ENV["LANG"]].compact.uniq, root_path).and_call_original
-      object.i18n = "INVALID"
+      subject.i18n = "INVALID"
     end
 
     it "should raise an exception if no valid translation are found" do
       ENV["LANG"] = "INVALID"
       allow(::R18n::I18n).to receive(:system_locale).and_return("INVALID")
-      object.i18n_setup("ROOT", "/dev/")
-      expect { object.i18n = "INVALID" }.to raise_error(::Lazier::Exceptions::MissingTranslation)
+      subject.i18n_setup("ROOT", "/dev/")
+      expect { subject.i18n = "INVALID" }.to raise_error(::Lazier::Exceptions::MissingTranslation)
     end
   end
 end