1 files changed, 59 insertions, 57 deletions
diff --git a/activesupport/test/xml_mini_test.rb b/activesupport/test/xml_mini_test.rb
index 55e8181b54..18a3f2ca66 100644
--- a/activesupport/test/xml_mini_test.rb
+++ b/activesupport/test/xml_mini_test.rb
@@ -1,9 +1,11 @@
-require 'abstract_unit'
-require 'active_support/xml_mini'
-require 'active_support/builder'
-require 'active_support/core_ext/hash'
-require 'active_support/core_ext/big_decimal'
-require 'yaml'
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/xml_mini"
+require "active_support/builder"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/big_decimal"
+require "yaml"
 
 module XmlMiniTest
   class RenameKeyTest < ActiveSupport::TestCase
@@ -12,23 +14,23 @@ module XmlMiniTest
     end
 
     def test_rename_key_dasherizes_with_dasherize_true
-      assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => true)
+      assert_equal "my-key", ActiveSupport::XmlMini.rename_key("my_key", dasherize: true)
     end
 
     def test_rename_key_does_nothing_with_dasherize_false
-      assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", :dasherize => false)
+      assert_equal "my_key", ActiveSupport::XmlMini.rename_key("my_key", dasherize: false)
     end
 
     def test_rename_key_camelizes_with_camelize_true
-      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => true)
+      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", camelize: true)
     end
 
     def test_rename_key_lower_camelizes_with_camelize_lower
-      assert_equal "myKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :lower)
+      assert_equal "myKey", ActiveSupport::XmlMini.rename_key("my_key", camelize: :lower)
     end
 
     def test_rename_key_lower_camelizes_with_camelize_upper
-      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", :camelize => :upper)
+      assert_equal "MyKey", ActiveSupport::XmlMini.rename_key("my_key", camelize: :upper)
     end
 
     def test_rename_key_does_not_dasherize_leading_underscores
@@ -63,16 +65,16 @@ module XmlMiniTest
 
     def setup
       @xml = ActiveSupport::XmlMini
-      @options = {:skip_instruct => true, :builder => Builder::XmlMarkup.new}
+      @options = { skip_instruct: true, builder: Builder::XmlMarkup.new }
     end
 
     test "#to_tag accepts a callable object and passes options with the builder" do
-      @xml.to_tag(:some_tag, lambda {|o| o[:builder].br }, @options)
+      @xml.to_tag(:some_tag, lambda { |o| o[:builder].br }, @options)
       assert_xml "<br/>"
     end
 
     test "#to_tag accepts a callable object and passes options and tag name" do
-      @xml.to_tag(:tag, lambda {|o, t| o[:builder].b(t) }, @options)
+      @xml.to_tag(:tag, lambda { |o, t| o[:builder].b(t) }, @options)
       assert_xml "<b>tag</b>"
     end
 
@@ -92,58 +94,58 @@ module XmlMiniTest
     end
 
     test "#to_tag should use the type value in the options hash" do
-      @xml.to_tag(:b, "blue", @options.merge(type: 'color'))
-      assert_xml( "<b type=\"color\">blue</b>" )
+      @xml.to_tag(:b, "blue", @options.merge(type: "color"))
+      assert_xml("<b type=\"color\">blue</b>")
     end
 
     test "#to_tag accepts symbol types" do
       @xml.to_tag(:b, :name, @options)
-      assert_xml( "<b type=\"symbol\">name</b>" )
+      assert_xml("<b type=\"symbol\">name</b>")
     end
 
     test "#to_tag accepts boolean types" do
       @xml.to_tag(:b, true, @options)
-      assert_xml( "<b type=\"boolean\">true</b>")
+      assert_xml("<b type=\"boolean\">true</b>")
     end
 
     test "#to_tag accepts float types" do
       @xml.to_tag(:b, 3.14, @options)
-      assert_xml( "<b type=\"float\">3.14</b>")
+      assert_xml("<b type=\"float\">3.14</b>")
     end
 
     test "#to_tag accepts decimal types" do
-      @xml.to_tag(:b, ::BigDecimal.new("1.2"), @options)
-      assert_xml( "<b type=\"decimal\">1.2</b>")
+      @xml.to_tag(:b, BigDecimal("1.2"), @options)
+      assert_xml("<b type=\"decimal\">1.2</b>")
     end
 
     test "#to_tag accepts date types" do
-      @xml.to_tag(:b, Date.new(2001,2,3), @options)
-      assert_xml( "<b type=\"date\">2001-02-03</b>")
+      @xml.to_tag(:b, Date.new(2001, 2, 3), @options)
+      assert_xml("<b type=\"date\">2001-02-03</b>")
     end
 
     test "#to_tag accepts datetime types" do
-      @xml.to_tag(:b, DateTime.new(2001,2,3,4,5,6,'+7'), @options)
-      assert_xml( "<b type=\"dateTime\">2001-02-03T04:05:06+07:00</b>")
+      @xml.to_tag(:b, DateTime.new(2001, 2, 3, 4, 5, 6, "+7"), @options)
+      assert_xml("<b type=\"dateTime\">2001-02-03T04:05:06+07:00</b>")
     end
 
     test "#to_tag accepts time types" do
       @xml.to_tag(:b, Time.new(1993, 02, 24, 12, 0, 0, "+09:00"), @options)
-      assert_xml( "<b type=\"dateTime\">1993-02-24T12:00:00+09:00</b>")
+      assert_xml("<b type=\"dateTime\">1993-02-24T12:00:00+09:00</b>")
     end
 
     test "#to_tag accepts array types" do
       @xml.to_tag(:b, ["first_name", "last_name"], @options)
-      assert_xml( "<b type=\"array\"><b>first_name</b><b>last_name</b></b>" )
+      assert_xml("<b type=\"array\"><b>first_name</b><b>last_name</b></b>")
     end
 
     test "#to_tag accepts hash types" do
       @xml.to_tag(:b, { first_name: "Bob", last_name: "Marley" }, @options)
-      assert_xml( "<b><first-name>Bob</first-name><last-name>Marley</last-name></b>" )
+      assert_xml("<b><first-name>Bob</first-name><last-name>Marley</last-name></b>")
     end
 
     test "#to_tag should not add type when skip types option is set" do
       @xml.to_tag(:b, "Bob", @options.merge(skip_types: 1))
-      assert_xml( "<b>Bob</b>" )
+      assert_xml("<b>Bob</b>")
     end
 
     test "#to_tag should dasherize the space when passed a string with spaces as a key" do
@@ -233,62 +235,62 @@ module XmlMiniTest
     end
 
     def test_symbol
-      parser = @parsing['symbol']
-      assert_equal :symbol, parser.call('symbol')
+      parser = @parsing["symbol"]
+      assert_equal :symbol, parser.call("symbol")
       assert_equal :symbol, parser.call(:symbol)
       assert_equal :'123', parser.call(123)
-      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
     def test_date
-      parser = @parsing['date']
-      assert_equal Date.new(2013,11,12), parser.call("2013-11-12T0211Z")
+      parser = @parsing["date"]
+      assert_equal Date.new(2013, 11, 12), parser.call("2013-11-12T0211Z")
       assert_raises(TypeError) { parser.call(1384190018) }
       assert_raises(ArgumentError) { parser.call("not really a date") }
     end
 
     def test_datetime
-      parser = @parsing['datetime']
-      assert_equal Time.new(2013,11,12,02,11,00,0), parser.call("2013-11-12T02:11:00Z")
-      assert_equal DateTime.new(2013,11,12), parser.call("2013-11-12T0211Z")
-      assert_equal DateTime.new(2013,11,12,02,11), parser.call("2013-11-12T02:11Z")
-      assert_equal DateTime.new(2013,11,12,02,11), parser.call("2013-11-12T11:11+9")
+      parser = @parsing["datetime"]
+      assert_equal Time.new(2013, 11, 12, 02, 11, 00, 0), parser.call("2013-11-12T02:11:00Z")
+      assert_equal DateTime.new(2013, 11, 12), parser.call("2013-11-12T0211Z")
+      assert_equal DateTime.new(2013, 11, 12, 02, 11), parser.call("2013-11-12T02:11Z")
+      assert_equal DateTime.new(2013, 11, 12, 02, 11), parser.call("2013-11-12T11:11+9")
       assert_raises(ArgumentError) { parser.call("1384190018") }
     end
 
     def test_integer
-      parser = @parsing['integer']
+      parser = @parsing["integer"]
       assert_equal 123, parser.call(123)
       assert_equal 123, parser.call(123.003)
       assert_equal 123, parser.call("123")
       assert_equal 0, parser.call("")
-      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
     def test_float
-      parser = @parsing['float']
+      parser = @parsing["float"]
       assert_equal 123, parser.call("123")
       assert_equal 123.003, parser.call("123.003")
       assert_equal 123.0, parser.call("123,003")
       assert_equal 0.0, parser.call("")
       assert_equal 123, parser.call(123)
       assert_equal 123.05, parser.call(123.05)
-      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
     def test_decimal
-      parser = @parsing['decimal']
+      parser = @parsing["decimal"]
       assert_equal 123, parser.call("123")
       assert_equal 123.003, parser.call("123.003")
       assert_equal 123.0, parser.call("123,003")
       assert_equal 0.0, parser.call("")
       assert_equal 123, parser.call(123)
       assert_raises(ArgumentError) { parser.call(123.04) }
-      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
     def test_boolean
-      parser = @parsing['boolean']
+      parser = @parsing["boolean"]
       [1, true, "1"].each do |value|
         assert parser.call(value)
       end
@@ -299,13 +301,13 @@ module XmlMiniTest
     end
 
     def test_string
-      parser = @parsing['string']
+      parser = @parsing["string"]
       assert_equal "123", parser.call(123)
       assert_equal "123", parser.call("123")
       assert_equal "[]", parser.call("[]")
       assert_equal "[]", parser.call([])
       assert_equal "{}", parser.call({})
-      assert_raises(ArgumentError) { parser.call(Date.new(2013,11,12,02,11)) }
+      assert_raises(ArgumentError) { parser.call(Date.new(2013, 11, 12, 02, 11)) }
     end
 
     def test_yaml
@@ -316,14 +318,14 @@ product:
     description : Basketball
 YAML
       expected = {
-        "product"=> [
-          {"sku"=>"BL394D", "quantity"=>4, "description"=>"Basketball"}
+        "product" => [
+          { "sku" => "BL394D", "quantity" => 4, "description" => "Basketball" }
         ]
       }
-      parser = @parsing['yaml']
+      parser = @parsing["yaml"]
       assert_equal(expected, parser.call(yaml))
-      assert_equal({1 => 'test'}, parser.call({1 => 'test'}))
-      assert_equal({"1 => 'test'"=>nil}, parser.call("{1 => 'test'}"))
+      assert_equal({ 1 => "test" }, parser.call(1 => "test"))
+      assert_equal({ "1 => 'test'" => nil }, parser.call("{1 => 'test'}"))
     end
 
     def test_base64Binary_and_binary
@@ -341,12 +343,12 @@ in the continued and indefatigable generation of knowledge, exceeds the short
 vehemence of any carnal pleasure.
 EXPECTED
 
-      parser = @parsing['base64Binary']
-      assert_equal expected_base64.gsub(/\n/," ").strip, parser.call(base64)
+      parser = @parsing["base64Binary"]
+      assert_equal expected_base64.gsub(/\n/, " ").strip, parser.call(base64)
       parser.call("NON BASE64 INPUT")
 
-      parser = @parsing['binary']
-      assert_equal expected_base64.gsub(/\n/," ").strip, parser.call(base64, 'encoding' => 'base64')
+      parser = @parsing["binary"]
+      assert_equal expected_base64.gsub(/\n/, " ").strip, parser.call(base64, "encoding" => "base64")
       assert_equal "IGNORED INPUT", parser.call("IGNORED INPUT", {})
     end
   end