lazier 3.5.7 → 4.0.0

data/spec/lazier/exceptions_spec.rb

@@ -0,0 +1,25 @@
+#
+# 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 "spec_helper"
+
+describe Lazier::Exceptions::TranslationExceptionHandler do
+  describe "#call" do
+    it "should correctly raise exception" do
+      subject = Lazier::Exceptions::TranslationExceptionHandler.new
+      expect { subject.call(::I18n::MissingTranslation.new(1, 2, {}), 1, 2, 3) }.to raise_error(::I18n::MissingTranslationData)
+      expect { subject.call(RuntimeError.new, 1, 2, 3) }.to raise_error(RuntimeError)
+    end
+  end
+end
+
+describe Lazier::Exceptions::MissingTranslation do
+  describe "#initialize" do
+    it "should initialize a good exception" do
+      subject = Lazier::Exceptions::MissingTranslation.new("LOCALE", "MESSAGE")
+      expect(subject.message).to eq("Unable to load the translation \"MESSAGE\" for the locale \"LOCALE\".")
+    end
+  end
+end

data/spec/lazier/hash_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.
@@ -17,26 +16,6 @@ describe Object do
     ::Lazier.load!
   end
 
-  describe "method access" do
-    it "it is not enabled by default" do
-      expect { subject.b }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe "allows access to keys using dotted notation" do
-    before(:each) do
-      ::Lazier.load!(:hash_method_access)
-    end
-
-    it "should allow method subject for symbol key" do
-      subject.b.f = 4
-
-      expect(subject.a).to eq(1)
-      expect(subject.b.c).to eq(2)
-      expect(subject["b"]["f"]).to eq(4)
-    end
-  end
-
   describe "#compact" do
     it "should remove blank keys" do
       expect({a: 1, b: nil}.compact).to eq({a: 1})

data/spec/lazier/i18n_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,76 +6,161 @@
 require "spec_helper"
 
 describe Lazier::I18n do
-  subject {
-    c = ::Object.new
-    c.class_eval { include Lazier::I18n }
-    c
-  }
+  before(:each) do
+    Lazier::I18n.default_locale = :en
+  end
 
-  let(:root_path) { ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/") }
+  subject! { Lazier::I18n.instance(force: true) }
 
-  before(:each) do
-    ENV["LANG"] = "en"
-    allow(::R18n::I18n).to receive(:system_locale).and_return("en")
+  describe ".instance" do
+    it "should return the singleton instance" do
+      expect(subject).to be_a(Lazier::I18n)
+      expect(Lazier::I18n.instance).to be(subject)
+    end
+
+    it "should return a new instance" do
+      another = Lazier::I18n.instance(force: true)
+      expect(another).not_to be(subject)
+    end
   end
 
-  describe "#i18n_setup" do
-    it "should set the root and the path" do
-      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)
+  describe "#initialize" do
+    it "should save attributes" do
+      subject = Lazier::I18n.new("it", root: "foo", path: "/dev/abc/..")
+      expect(subject.locale).to eq(:it)
+      expect(subject.root).to eq(:foo)
+      expect(subject.path).to eq("/dev")
+    end
+
+    it "should fallback to the default locale" do
+      allow(::I18n).to receive("locale=")
+      Lazier::I18n.default_locale = "pt"
+      expect(Lazier::I18n.new.locale).to eq(:pt)
+    end
+
+    describe "should fallback to the system locale" do
+      before(:each) do
+        allow(::I18n).to receive("locale=")
+        Lazier::I18n.default_locale = nil
+      end
+
+      it "in JRuby" do
+        expect(Lazier).to receive(:platform).exactly(2).and_return(:java)
+
+        if RUBY_PLATFORM !~ /java/
+          stub_const("Java", Object.new)
+          allow(Java).to receive(:java).and_return(Object.new)
+          allow(Java.java).to receive(:util).and_return(Object.new)
+          allow(Java.java.util).to receive(:Locale).and_return(Object.new)
+          allow(Java.java.util.Locale).to receive(:getDefault).and_return(Object.new)
+        end
+
+        allow(Java.java.util.Locale.getDefault).to receive(:toString).and_return("jp")
+
+        expect(Lazier::I18n.new.locale).to eq(:jp)
+      end
+
+      it "in OSX" do
+        allow_any_instance_of(Lazier::I18n).to receive(:`).with("defaults read .GlobalPreferences AppleLanguages | awk 'NR==2{gsub(/[ ,]/, \"\");print}'").and_return("in")
+
+        expect(Lazier).to receive(:platform).exactly(2).and_return(:osx)
+        expect(Lazier::I18n.new.locale).to eq(:in)
+      end
+
+      it "in UNIX" do
+        old_env = ENV["LANG"]
+
+        ENV["LANG"] = "it"
+        expect(Lazier).to receive(:platform).exactly(2).and_return(:posix)
+        expect(Lazier::I18n.new.locale).to eq(:it)
+        ENV["LANG"] = old_env
+      end
+
+      it "falling back to English" do
+        expect(Lazier).to receive(:platform).and_return(:other)
+
+        expect(Lazier::I18n.new.locale).to eq(:en)
+      end
+    end
+
+    it "should setup the backend" do
+      open("/tmp/it.yml", "w") {|f| f.write("---\nit:\n  lazier:") }
+      subject = Lazier::I18n.new("it", path: "/tmp")
+
+      expect(::I18n.enforce_available_locales).to be_truthy
+      expect(::I18n.load_path).to include("/tmp/it.yml")
+      expect(::I18n.exception_handler).to be_a(::Lazier::Exceptions::TranslationExceptionHandler)
+      expect(subject.backend).to be_a(::I18n::Backend::Simple)
+      File.unlink("/tmp/it.yml")
+      ::I18n.load_path.delete("/tmp/it.yml")
+    end
+  end
+
+  describe "#reload" do
+    it "should reload translations" do
+      expect_any_instance_of(::I18n::Backend::Simple).to receive(:load_translations).and_call_original
+      subject.reload
     end
   end
 
-  describe "#i18n" do
-    it "should call the private method if nothing is set" do
-      subject.instance_variable_set(:@i18n, nil)
-      expect(subject).to receive(:i18n_load_locale)
-      subject.i18n
+  describe "#translations" do
+    it "should return the list of translations" do
+      expect(subject.translations.keys).to eq([:date, :time, :support, :number, :lazier])
     end
   end
 
-  describe "#i18n=" do
-    it "should call the private method if nothing is set" do
-      expect(subject).to receive(:i18n_load_locale).and_return("LOCALE")
-      subject.i18n = :en
-      expect(subject.instance_variable_get(:@i18n)).to eq("LOCALE")
+  describe "#locale=" do
+    it "should assign the new locale" do
+      expect(::I18n).to receive("locale=").with(:it)
+      subject.locale = "it"
+      expect(subject.locale).to eq(:it)
     end
   end
 
-  describe "#i18n_load_locale" do
-    it "should set using system locale if called without arguments" do
-      subject.i18n_setup("lazier", root_path)
-      expect(::R18n::I18n).to receive(:new).with([ENV["LANG"]].compact.uniq, root_path).and_call_original
-      subject.i18n = nil
+  describe "#locales" do
+    it "should return the list of locales" do
+      expect(subject.locales).to eq([:en, :it])
     end
+  end
 
-    it "should set the requested locale" do
-      subject.i18n_setup("lazier", root_path)
-      expect(::R18n::I18n).to receive(:new).with(["it", ENV["LANG"]].compact.uniq, root_path).and_call_original
-      subject.i18n = :it
+  describe "#translate" do
+    it "should return the translation" do
+      expect(subject.translate("configuration.not_defined", name: "foo", class: "bar")).to eq("Property foo is not defined for bar.")
+      expect(subject.translate(".date.formats")).to eq({:default=>"%Y-%m-%d", :short=>"%b %d", :long=>"%B %d, %Y"})
+      expect { subject.translate("::configuration.not_defined", property_name: "foo", class: "bar") }.to raise_error(Lazier::Exceptions::MissingTranslation)
     end
+  end
 
-    it "should call the root" do
-      Lazier.load!
-      t = ::Object.new
-      expect_any_instance_of(::R18n::I18n).to receive(:t).and_return(t)
-      expect(t).to receive("ROOT")
-      subject.i18n_setup("ROOT", root_path)
-      subject.i18n = :it
+  describe "#translate_in_locale" do
+    it "should return the translation in the desired locale" do
+      expect(subject.translate_in_locale(:it, "configuration.not_defined", name: "foo", class: "bar")).to eq("La proprietà foo non è definita per bar.")
     end
+  end
 
-    it "should only pass valid translations" do
-      subject.i18n_setup("lazier", root_path)
-      expect(::R18n::I18n).to receive(:new).with([ENV["LANG"]].compact.uniq, root_path).and_call_original
-      subject.i18n = "INVALID"
+  describe "#with_locale" do
+    it "should execute a block with the new locale and then set the old locale back" do
+      new_locale = nil
+
+      subject.with_locale(:it) do
+        new_locale = subject.locale
+      end
+
+      expect(new_locale).to eq(:it)
+      expect(subject.locale).to eq(:en)
     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")
-      subject.i18n_setup("ROOT", "/dev/")
-      expect { subject.i18n = "INVALID" }.to raise_error(::Lazier::Exceptions::MissingTranslation)
+    it "should raise exception after having restored the old locale" do
+      new_locale = nil
+
+      expect {
+        subject.with_locale(:it) do
+          new_locale = subject.locale
+          raise RuntimeError
+        end
+      }.to raise_error(RuntimeError)
+
+      expect(new_locale).to eq(:it)
+      expect(subject.locale).to eq(:en)
     end
   end
-end
+end

data/spec/lazier/math_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/object_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.
@@ -25,90 +24,78 @@ describe Lazier::Object do
     end
   end
 
-  describe "#is_number?" do
+  describe "#number?" do
     it "should return true for a valid number" do
-      expect("123.45".is_number?).to be_true
-      expect("1,23.45".is_number?).to be_true
-      expect("-1.23.45".is_number?).to be_true
-      expect("+123.45".is_number?).to be_true
-      expect("+1.231,45".is_number?).to be_true
+      expect("123.45".number?).to be_truthy
+      expect("1,23.45".number?).to be_truthy
+      expect("-1.23.45".number?).to be_truthy
+      expect("+123.45".number?).to be_truthy
+      expect("+1.231,45".number?).to be_truthy
+      expect(true.number?).to be_truthy
+      expect(false.number?).to be_truthy
+      expect(nil.number?).to be_truthy
+      expect("a".number?(Float, /[a-z]/)).to be_truthy
     end
 
     it "should return false for a invalid number" do
-      expect("s213".is_number?).to be_false
+      expect("s213".number?).to be_falsey
     end
   end
 
-  describe "#is_numeric?" do
+  describe "#integer?" do
     it "should return true for a valid number" do
-      expect(true.is_numeric?).to be_true
-      expect(false.is_numeric?).to be_true
-      expect(nil.is_numeric?).to be_true
-      expect("123".is_numeric?).to be_true
-      expect("-123".is_numeric?).to be_true
-      expect("+123.45".is_numeric?(Float, ::Lazier::Object::FLOAT_MATCHER)).to be_true
+      expect(true.integer?).to be_truthy
+      expect(false.integer?).to be_truthy
+      expect(nil.integer?).to be_truthy
+      expect("123".integer?).to be_truthy
+      expect("-123".integer?).to be_truthy
+      expect("+123".integer?).to be_truthy
     end
 
     it "should return false for a invalid number" do
-      expect("s123".is_numeric?).to be_false
-      expect("123.12".is_numeric?).to be_false
-    end
-  end
-  
-  describe "#is_integer?" do
-    it "should return true for a valid number" do
-      expect(true.is_integer?).to be_true
-      expect(false.is_integer?).to be_true
-      expect(nil.is_integer?).to be_true
-      expect("123".is_integer?).to be_true
-      expect("-123".is_integer?).to be_true
-      expect("+123".is_integer?).to be_true
-    end
-
-    it "should return false for a invalid number" do
-      expect("s123".is_integer?).to be_false
-      expect("123.12".is_integer?).to be_false
+      expect("s123".integer?).to be_falsey
+      expect("123.12".integer?).to be_falsey
     end
   end
 
-  describe "#is_float?" do
+  describe "#float?" do
     it "should return true for a valid number" do
-      expect(true.is_float?).to be_true
-      expect(false.is_float?).to be_true
-      expect(nil.is_float?).to be_true
-      expect("123.45".is_float?).to be_true
-      expect("1,23.45".is_float?).to be_true
-      expect("-1.23.45".is_float?).to be_true
-      expect("+123.45".is_float?).to be_true
-      expect("+1.231,45".is_float?).to be_true
+      expect(true.float?).to be_truthy
+      expect(false.float?).to be_truthy
+      expect(nil.float?).to be_truthy
+      expect("123.45".float?).to be_truthy
+      expect("1,23.45".float?).to be_truthy
+      expect("-1.23.45".float?).to be_truthy
+      expect("+123.45".float?).to be_truthy
+      expect("+1.231,45".float?).to be_truthy
     end
 
     it "should return false for a invalid number" do
-      expect("s213".is_float?).to be_false
+      expect("s213".float?).to be_falsey
     end
   end
 
-  describe "#is_boolean?" do
+  describe "#boolean?" do
     it "should return true for a valid boolean" do
-      expect(true.is_boolean?).to be_true
-      expect(false.is_boolean?).to be_true
-      expect(nil.is_boolean?).to be_true
-      expect("y".is_boolean?).to be_true
-      expect("n".is_boolean?).to be_true
-      expect("yes".is_boolean?).to be_true
-      expect("no".is_boolean?).to be_true
-      expect("1".is_boolean?).to be_true
-      expect("0".is_boolean?).to be_true
-      expect("true".is_boolean?).to be_true
-      expect("false".is_boolean?).to be_true
-      expect("t".is_boolean?).to be_true
-      expect("f".is_boolean?).to be_true
-      expect(1.is_boolean?).to be_true
-      expect(0.is_boolean?).to be_true
+      expect(true.boolean?).to be_truthy
+      expect(false.boolean?).to be_truthy
+      expect(nil.boolean?).to be_truthy
+      expect("y".boolean?).to be_truthy
+      expect("n".boolean?).to be_truthy
+      expect("yes".boolean?).to be_truthy
+      expect("no".boolean?).to be_truthy
+      expect("1".boolean?).to be_truthy
+      expect("0".boolean?).to be_truthy
+      expect("true".boolean?).to be_truthy
+      expect("false".boolean?).to be_truthy
+      expect("t".boolean?).to be_truthy
+      expect("f".boolean?).to be_truthy
+      expect(1.boolean?).to be_truthy
+      expect(0.boolean?).to be_truthy
     end
 
     it "should return false for a invalid boolean" do
-      expect("11".is_boolean?).to be_false
+      expect("11".boolean?).to be_falsey
     end
   end
 
@@ -167,46 +154,46 @@ describe Lazier::Object do
       expect(nil.ensure_array).to eq([])
       expect("A".ensure_array).to eq(["A"])
       expect({a: "b"}.ensure_array).to eq([{a: "b"}])
-      expect(nil.ensure_array(["1"])).to eq(["1"])
-      expect("A".ensure_array(["2"])).to eq(["2"])
-      expect({a: "b"}.ensure_array(["3"])).to eq(["3"])
+      expect(nil.ensure_array(default: ["1"])).to eq(["1"])
+      expect("A".ensure_array(default: ["2"])).to eq(["2"])
+      expect({a: "b"}.ensure_array(default: ["3"])).to eq(["3"])
     end
 
     it "should sanitize elements of the array using a method or a block" do
       expect(" 123 ".ensure_array).to eq([" 123 "])
-      expect(" 123 ".ensure_array(nil, false, false, false, :strip)).to eq(["123"])
-      expect(" 123 ".ensure_array(nil, false, false) { |e| e.reverse }).to eq([" 321 "])
+      expect(" 123 ".ensure_array(sanitizer: :strip)).to eq(["123"])
+      expect(" 123 ".ensure_array { |e| e.reverse }).to eq([" 321 "])
     end
 
     it "should unicize, compact and flatten, array if requested to" do
-      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(nil, true, false)).to eq([1, 2, 3, nil, [4]])
-      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(nil, false, true)).to eq([1, 2, 3, 3, 2, 1, [4]])
-      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(nil, true, true)).to eq([1, 2, 3, [4]])
-      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(nil, true, true, true)).to eq([1, 2, 3, 4])
+      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(no_duplicates: true)).to eq([1, 2, 3, nil, [4]])
+      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(compact: true)).to eq([1, 2, 3, 3, 2, 1, [4]])
+      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(no_duplicates: true, compact: true)).to eq([1, 2, 3, [4]])
+      expect([1, 2, 3, nil, 3, 2, 1, [4]].ensure_array(no_duplicates: true, compact: true, flatten: true)).to eq([1, 2, 3, 4])
     end
   end
 
   describe "#ensure_hash" do
     it "should return an hash" do
       expect({a: "b"}.ensure_hash).to eq({a: "b"})
-      expect(nil.ensure_hash(nil, {a: "b"})).to eq({a: "b"})
+      expect(nil.ensure_hash(default: {a: "b"})).to eq({a: "b"})
 
       expect(1.ensure_hash).to eq({})
-      expect(1.ensure_hash(nil, :test)).to eq({test: 1})
-      expect(1.ensure_hash(nil, "test")).to eq({"test" => 1})
-      expect(1.ensure_hash(nil, 2)).to eq({key: 1})
+      expect(1.ensure_hash(default: :test)).to eq({test: 1})
+      expect(1.ensure_hash(default: "test")).to eq({"test" => 1})
+      expect(1.ensure_hash(default: 2)).to eq({key: 1})
     end
 
     it "should sanitize values" do
-      expect(" 1 ".ensure_hash(nil, :key, &:strip)).to eq({key: "1"})
-      expect(1.ensure_hash(nil, :key) { |v| v * 2 }).to eq({key: 2})
+      expect(" 1 ".ensure_hash(default: nil, sanitizer: :strip)).to eq({key: "1"})
+      expect(1.ensure_hash(default: nil) { |v| v * 2 }).to eq({key: 2})
     end
 
     it "should grant access" do
       subject = {a: "b"}
 
-      expect(subject ).to receive(:ensure_access).with("ACCESS")
-      subject .ensure_hash("ACCESS")
+      expect(subject ).to receive(:ensure_access).with(["ACCESS"])
+      subject.ensure_hash(accesses: "ACCESS")
     end
   end
 
@@ -224,7 +211,7 @@ describe Lazier::Object do
       expect("+1.231,45".to_float).to eq(1231.45)
     end
 
-    it "should return 0.0 for a invalid number without a default" do
+    it "should return 0.0 for a invalid number? without a default" do
       expect("s213".to_float).to eq(0.0)
     end
 
@@ -244,7 +231,7 @@ describe Lazier::Object do
       expect("-123".to_integer).to eq(-123)
     end
 
-    it "should return 0 for a invalid number without a default" do
+    it "should return 0 for a invalid number? without a default" do
       expect("s213".to_integer).to eq(0)
     end
 
@@ -292,25 +279,25 @@ describe Lazier::Object do
 
   describe "#format_number" do
     it "should format number" do
-      expect(123.format_number(0)).to eq("123")
+      expect(123.format_number(precision: 0)).to eq("123")
       expect(123.456789.format_number).to eq("123.46")
       expect(12312.456789.format_number).to eq("12,312.46")
       expect(123123.456789.format_number).to eq("123,123.46")
       expect(1123123.456789.format_number).to eq("1,123,123.46")
-      expect(123123.456789.format_number(2)).to eq("123,123.46")
-      expect(123123.456789.format_number(3, "@")).to eq("123,123@457")
-      expect(123123.456789.format_number(3, "@", "$")).to eq("123,123@457 $")
-      expect("123123.456789".format_number(3, "@", "$", "!")).to eq("123!123@457 $")
+      expect(123123.456789.format_number(precision: 2)).to eq("123,123.46")
+      expect(123123.456789.format_number(precision: 3, decimal_separator: "@")).to eq("123,123@457")
+      expect(123123.456789.format_number(precision: 3, decimal_separator: "@", add_string: "$")).to eq("123,123@457 $")
+      expect("123123.456789".format_number(precision: 3, decimal_separator: "@", add_string: "$", k_separator: "!")).to eq("123!123@457 $")
 
-      Lazier.settings.setup_format_number(5, ",", "£", ".")
+      Lazier.settings.setup_format_number(precision: 5, decimal_separator: ",", add_string: "£", k_separator:".")
       expect(123123.456789.format_number).to eq("123.123,45679 £")
 
-      Lazier.settings.setup_format_number(2)
-      expect(123.456789.format_number(-1)).to eq("123")
+      Lazier.settings.setup_format_number(precision: 2)
+      expect(123.456789.format_number(precision: -1)).to eq("123")
     end
 
     it "should return nil for non numeric values" do
-      expect("abc".format_number(-1)).to eq(nil)
+      expect("abc".format_number(precision: -1)).to eq(nil)
     end
   end
 
@@ -321,38 +308,56 @@ describe Lazier::Object do
     end
 
     it "should support localization" do
-      Lazier.settings.setup_boolean_names("YYY", "NNN")
+      Lazier.settings.setup_boolean_names(true_name: "YYY", false_name: "NNN")
       expect("yes".format_boolean).to eq("YYY")
       expect("abc".format_boolean).to eq("NNN")
     end
 
     it "should support overrides" do
       Lazier.settings.setup_boolean_names
-      expect("yes".format_boolean("TTT")).to eq("TTT")
-      expect("yes".format_boolean(nil, "FFF")).to eq("Yes")
-      expect("abc".format_boolean("TTT")).to eq("No")
-      expect("abc".format_boolean(nil, "FFF")).to eq("FFF")
+      expect("yes".format_boolean(true_name: "TTT")).to eq("TTT")
+      expect("yes".format_boolean(false_name: "FFF")).to eq("Yes")
+      expect("abc".format_boolean(true_name: "TTT")).to eq("No")
+      expect("abc".format_boolean(false_name: "FFF")).to eq("FFF")
     end
   end
 
   describe "#indexize" do
     it "should format for printing" do
       expect(1.indexize).to eq("01")
-      expect(21.indexize(3, "A")).to eq("A21")
-      expect(21.indexize(3, "A", :ljust)).to eq("21A")
+      expect(21.indexize(length: 3, filler: "A")).to eq("A21")
+      expect(21.indexize(length: 3, filler: "A", formatter: :ljust)).to eq("21A")
+    end
+  end
+
+  describe "#to_pretty_json" do
+    subject { {a: "b", c: [1, 2, "3"]} }
+
+    it "should use json gem for JRuby" do
+      allow(Lazier).to receive(:platform).and_return(:java)
+      stub_const("JSON", "JSON")
+      expect(JSON).to receive(:pretty_generate).with(subject).and_return("JSON")
+      expect(subject.to_pretty_json).to eq("JSON")
+    end
+
+    it "should use Oj gem for other implementations" do
+      allow(Lazier).to receive(:platform).and_return(:posix)
+      stub_const("Oj", "OJ")
+      expect(Oj).to receive(:dump).with(subject, mode: :compat, indent: 2).and_return("JSON")
+      expect(subject.to_pretty_json).to eq("JSON")
     end
   end
 
-  describe "#for_debug" do
+  describe "#to_debug" do
     it "should return the correct representation for an object" do
       subject = {a: "b"}
-      expect(subject.for_debug(:json, false)).to eq(subject .to_json)
-      expect(subject.for_debug(:pretty_json, false)).to eq(::JSON.pretty_generate(subject ))
-      expect(subject.for_debug(:yaml, false)).to eq(subject .to_yaml)
+      expect(subject.to_debug(format: :json, as_exception: false)).to eq(subject.to_json)
+      expect(subject.to_debug(format: :pretty_json, as_exception: false)).to eq(subject.to_pretty_json)
+      expect(subject.to_debug(format: :yaml, as_exception: false)).to eq(subject.to_yaml)
     end
 
     it "should raise an exception if requested" do
-      expect { {a: "b"}.for_debug }.to raise_error(::Lazier::Exceptions::Debug)
+      expect { {a: "b"}.to_debug }.to raise_error(::Lazier::Exceptions::Debug)
     end
   end
 end