ffi-icu 0.2.0 → 0.3.0

data/spec/normalization_spec.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module Normalization
     #  http://bugs.icu-project.org/trac/browser/icu/trunk/source/test/cintltst/cnormtst.c
@@ -9,11 +7,11 @@ module ICU
     describe "Normalization" do
 
       it "should normalize a string - decomposed" do
-        ICU::Normalization.normalize("Å", :nfd).unpack("U*").should == [65, 778]
+        expect(ICU::Normalization.normalize("Å", :nfd).unpack("U*")).to eq([65, 778])
       end
 
       it "should normalize a string - composed" do
-        ICU::Normalization.normalize("Å", :nfc).unpack("U*").should == [197]
+        expect(ICU::Normalization.normalize("Å", :nfc).unpack("U*")).to eq([197])
       end
 
       # TODO: add more normalization tests

data/spec/normalizer_spec.rb

@@ -1,21 +1,19 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe Normalizer do
     describe 'NFD: nfc decompose' do
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :decompose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Å").unpack("U*").should == [65, 778]
-        normalizer.normalize("ô").unpack("U*").should == [111, 770]
-        normalizer.normalize("a").unpack("U*").should == [97]
-        normalizer.normalize("中文").unpack("U*").should == [20013, 25991]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 64259, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 8547]
+        expect(normalizer.normalize("Å").unpack("U*")).to eq([65, 778])
+        expect(normalizer.normalize("ô").unpack("U*")).to eq([111, 770])
+        expect(normalizer.normalize("a").unpack("U*")).to eq([97])
+        expect(normalizer.normalize("中文").unpack("U*")).to eq([20013, 25991])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 64259, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 8547])
       end
     end
 
@@ -23,14 +21,14 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfc', :compose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Å").unpack("U*").should == [197]
-        normalizer.normalize("ô").unpack("U*").should == [244]
-        normalizer.normalize("a").unpack("U*").should == [97]
-        normalizer.normalize("中文").unpack("U*").should == [20013, 25991]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 64259, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 8547]
+        expect(normalizer.normalize("Å").unpack("U*")).to eq([197])
+        expect(normalizer.normalize("ô").unpack("U*")).to eq([244])
+        expect(normalizer.normalize("a").unpack("U*")).to eq([97])
+        expect(normalizer.normalize("中文").unpack("U*")).to eq([20013, 25991])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 64259, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 8547])
       end
     end
 
@@ -38,10 +36,10 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :decompose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [65, 776, 102, 102, 105, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([65, 776, 102, 102, 105, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
       end
     end
 
@@ -49,10 +47,10 @@ module ICU
       let(:normalizer) { ICU::Normalizer.new(nil, 'nfkc', :compose) }
 
       it "should normalize a string" do
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Äffin").unpack("U*").should == [196, 102, 102, 105, 110]
-        normalizer.normalize("Henry IV").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
-        normalizer.normalize("Henry Ⅳ").unpack("U*").should == [72, 101, 110, 114, 121, 32, 73, 86]
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Äffin").unpack("U*")).to eq([196, 102, 102, 105, 110])
+        expect(normalizer.normalize("Henry IV").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
+        expect(normalizer.normalize("Henry Ⅳ").unpack("U*")).to eq([72, 101, 110, 114, 121, 32, 73, 86])
       end
     end
   end # Normalizer

data/spec/number_formatting_spec.rb

@@ -1,68 +1,71 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module NumberFormatting
     describe 'NumberFormatting' do
       it 'should format a simple integer' do
-        NumberFormatting.format_number("en", 1).should == "1"
-        NumberFormatting.format_number("en", 1_000).should == "1,000"
-        NumberFormatting.format_number("de-DE", 1_000_000).should == "1.000.000"
+        expect(NumberFormatting.format_number("en", 1)).to eq("1")
+        expect(NumberFormatting.format_number("en", 1_000)).to eq("1,000")
+        expect(NumberFormatting.format_number("de-DE", 1_000_000)).to eq("1.000.000")
       end
 
       it 'should format a float' do
-        NumberFormatting.format_number("en", 1.0).should == "1"
-        NumberFormatting.format_number("en", 1.123).should == "1.123"
-        NumberFormatting.format_number("en", 1_000.1238).should == "1,000.124"
-        NumberFormatting.format_number("en", 1_000.1238, max_fraction_digits: 4).should == "1,000.1238"
+        expect(NumberFormatting.format_number("en", 1.0)).to eq("1")
+        expect(NumberFormatting.format_number("en", 1.123)).to eq("1.123")
+        expect(NumberFormatting.format_number("en", 1_000.1238)).to eq("1,000.124")
+        expect(NumberFormatting.format_number("en", 1_000.1238, max_fraction_digits: 4)).to eq("1,000.1238")
         NumberFormatting.set_default_options(fraction_digits: 5)
-        NumberFormatting.format_number("en", 1_000.1238).should == "1,000.12380"
+        expect(NumberFormatting.format_number("en", 1_000.1238)).to eq("1,000.12380")
         NumberFormatting.clear_default_options
       end
 
       it 'should format a decimal' do
-        NumberFormatting.format_number("en", BigDecimal.new("10000.123")).should == "10,000.123"
+        expect(NumberFormatting.format_number("en", BigDecimal("10000.123"))).to eq("10,000.123")
       end
 
       it 'should format a currency' do
-        NumberFormatting.format_currency("en", 123.45, 'USD').should == "$123.45"
-        NumberFormatting.format_currency("en", 123_123.45, 'USD').should == "$123,123.45"
-        NumberFormatting.format_currency("de-DE", 123_123.45, 'EUR').should == "123.123,45\u{A0}€"
+        expect(NumberFormatting.format_currency("en", 123.45, 'USD')).to eq("$123.45")
+        expect(NumberFormatting.format_currency("en", 123_123.45, 'USD')).to eq("$123,123.45")
+        expect(NumberFormatting.format_currency("de-DE", 123_123.45, 'EUR')).to eq("123.123,45\u{A0}€")
       end
 
       it 'should format a percent' do
-        NumberFormatting.format_percent("en", 1.1).should == "110%"
-        NumberFormatting.format_percent("da", 0.15).should == "15\u{A0}%"
-        NumberFormatting.format_percent("da", -0.1545, max_fraction_digits: 10).should == "-15,45\u{A0}%"
+        expect(NumberFormatting.format_percent("en", 1.1)).to eq("110%")
+        expect(NumberFormatting.format_percent("da", 0.15)).to eq("15\u{A0}%")
+        expect(NumberFormatting.format_percent("da", -0.1545, max_fraction_digits: 10)).to eq("-15,45\u{A0}%")
       end
 
       it 'should spell numbers' do
-        NumberFormatting.spell("en_US", 1_000).should == 'one thousand'
-        NumberFormatting.spell("de-DE", 123.456).should == "ein\u{AD}hundert\u{AD}drei\u{AD}und\u{AD}zwanzig Komma vier fünf sechs"
+        expect(NumberFormatting.spell("en_US", 1_000)).to eq('one thousand')
+        expect(NumberFormatting.spell("de-DE", 123.456)).to eq("ein\u{AD}hundert\u{AD}drei\u{AD}und\u{AD}zwanzig Komma vier fünf sechs")
       end
 
       it 'should be able to re-use number formatter objects' do
         numf = NumberFormatting.create('fr-CA')
-        numf.format(1_000).should == "1\u{A0}000"
-        numf.format(1_000.123).should == "1\u{A0}000,123"
+        expect(numf.format(1_000)).to eq("1\u{A0}000")
+        expect(numf.format(1_000.123)).to eq("1\u{A0}000,123")
       end
 
       it 'should be able to re-use currency formatter objects' do
         curf = NumberFormatting.create('en-US', :currency)
-        curf.format(1_000.12, 'USD').should == "$1,000.12"
+        expect(curf.format(1_000.12, 'USD')).to eq("$1,000.12")
       end
 
       it 'should allow for various styles of currency formatting if the version is new enough' do
         if ICU::Lib.version.to_a.first >= 53
           curf = NumberFormatting.create('en-US', :currency, style: :iso)
-          curf.format(1_000.12, 'USD').should == "USD1,000.12"
+          expected = if ICU::Lib.version.to_a.first >= 62
+            "USD\u00A01,000.12"
+          else
+            "USD1,000.12"
+          end
+          expect(curf.format(1_000.12, 'USD')).to eq(expected)
           curf = NumberFormatting.create('en-US', :currency, style: :plural)
-          curf.format(1_000.12, 'USD').should == "1,000.12 US dollars"
+          expect(curf.format(1_000.12, 'USD')).to eq("1,000.12 US dollars")
           expect { NumberFormatting.create('en-US', :currency, style: :fake) }.to raise_error(StandardError)
         else
           curf = NumberFormatting.create('en-US', :currency, style: :default)
-          curf.format(1_000.12, 'USD').should == '$1,000.12'
+          expect(curf.format(1_000.12, 'USD')).to eq('$1,000.12')
           expect { NumberFormatting.create('en-US', :currency, style: :iso) }.to raise_error(StandardError)
         end
       end

data/spec/time_spec.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe TimeFormatting do
     describe 'the TimeFormatting ' do
@@ -17,21 +15,21 @@ module ICU
 
       f1 = TimeFormatting.create(:locale => 'cs_CZ', :zone => 'Europe/Prague', :date => :long , :time => :long, :tz_style => :localized_long)
       it 'check date_format for lang=cs_CZ' do
-        f1.date_format(true).should eql "d. MMMM y H:mm:ss ZZZZ"
-        f1.date_format(false).should eql "d. MMMM y H:mm:ss ZZZZ"
+        expect(f1.date_format(true)).to eq("d. MMMM y H:mm:ss ZZZZ")
+        expect(f1.date_format(false)).to eq("d. MMMM y H:mm:ss ZZZZ")
       end
 
       it "for lang=cs_CZ zone=Europe/Prague" do
-        f1.should be_an_instance_of TimeFormatting::DateTimeFormatter
-        f1.format(t0).should eql "12. listopadu 2008 15:21:16 GMT+01:00"
-        f1.format(t1).should eql "25. října 2008 1:15:17 GMT+02:00"
-        f1.format(t2).should eql "25. října 2008 2:16:18 GMT+02:00"
-        f1.format(t3).should eql "25. října 2008 3:17:19 GMT+02:00"
-        f1.format(t4).should eql "25. října 2008 4:18:20 GMT+02:00"
-        f1.format(t5).should eql "29. března 2008 1:35:21 GMT+01:00"
-        f1.format(t6).should eql "29. března 2008 2:36:22 GMT+01:00"
-        f1.format(t7).should eql "29. března 2008 3:37:23 GMT+01:00"
-        f1.format(t8).should eql "29. března 2008 4:38:24 GMT+01:00"
+        expect(f1).to be_an_instance_of TimeFormatting::DateTimeFormatter
+        expect(f1.format(t0)).to eq("12. listopadu 2008 15:21:16 GMT+01:00")
+        expect(f1.format(t1)).to eq("25. října 2008 1:15:17 GMT+02:00")
+        expect(f1.format(t2)).to eq("25. října 2008 2:16:18 GMT+02:00")
+        expect(f1.format(t3)).to eq("25. října 2008 3:17:19 GMT+02:00")
+        expect(f1.format(t4)).to eq("25. října 2008 4:18:20 GMT+02:00")
+        expect(f1.format(t5)).to eq("29. března 2008 1:35:21 GMT+01:00")
+        expect(f1.format(t6)).to eq("29. března 2008 2:36:22 GMT+01:00")
+        expect(f1.format(t7)).to eq("29. března 2008 3:37:23 GMT+01:00")
+        expect(f1.format(t8)).to eq("29. března 2008 4:38:24 GMT+01:00")
       end
 
       f2 = TimeFormatting.create(:locale => 'en_US', :zone => 'Europe/Moscow', :date => :short , :time => :long, :tz_style => :generic_location)
@@ -45,20 +43,20 @@ module ICU
 
       en_exp = "M/d/yy#{en_sep} h:mm:ss a VVVV"
       it 'check date_format for lang=en_US' do
-        f2.date_format(true).should eql en_exp
-        f2.date_format(false).should eql en_exp
+        expect(f2.date_format(true)).to eq(en_exp)
+        expect(f2.date_format(false)).to eq(en_exp)
       end
 
       it "lang=en_US zone=Europe/Moscow" do
-        f2.format(t0).should eql "11/12/08#{en_sep} 5:21:16 PM #{en_tz}"
-        f2.format(t1).should eql "10/25/08#{en_sep} 3:15:17 AM #{en_tz}"
-        f2.format(t2).should eql "10/25/08#{en_sep} 4:16:18 AM #{en_tz}"
-        f2.format(t3).should eql "10/25/08#{en_sep} 5:17:19 AM #{en_tz}"
-        f2.format(t4).should eql "10/25/08#{en_sep} 6:18:20 AM #{en_tz}"
-        f2.format(t5).should eql "3/29/08#{en_sep} 3:35:21 AM #{en_tz}"
-        f2.format(t6).should eql "3/29/08#{en_sep} 4:36:22 AM #{en_tz}"
-        f2.format(t7).should eql "3/29/08#{en_sep} 5:37:23 AM #{en_tz}"
-        f2.format(t8).should eql "3/29/08#{en_sep} 6:38:24 AM #{en_tz}"
+        expect(f2.format(t0)).to eq("11/12/08#{en_sep} 5:21:16 PM #{en_tz}")
+        expect(f2.format(t1)).to eq("10/25/08#{en_sep} 3:15:17 AM #{en_tz}")
+        expect(f2.format(t2)).to eq("10/25/08#{en_sep} 4:16:18 AM #{en_tz}")
+        expect(f2.format(t3)).to eq("10/25/08#{en_sep} 5:17:19 AM #{en_tz}")
+        expect(f2.format(t4)).to eq("10/25/08#{en_sep} 6:18:20 AM #{en_tz}")
+        expect(f2.format(t5)).to eq("3/29/08#{en_sep} 3:35:21 AM #{en_tz}")
+        expect(f2.format(t6)).to eq("3/29/08#{en_sep} 4:36:22 AM #{en_tz}")
+        expect(f2.format(t7)).to eq("3/29/08#{en_sep} 5:37:23 AM #{en_tz}")
+        expect(f2.format(t8)).to eq("3/29/08#{en_sep} 6:38:24 AM #{en_tz}")
       end
 
       f3 = TimeFormatting.create(:locale => 'de_DE', :zone => 'Africa/Dakar ', :date => :short , :time => :long)
@@ -69,22 +67,21 @@ module ICU
 
       ge_exp = "dd.MM.yy#{ge_sep} HH:mm:ss z"
       it 'check date_format for lang=de_DE' do
-        f3.date_format(true).should eql ge_exp
-        f3.date_format(false).should eql ge_exp
+        expect(f3.date_format(true)).to eq(ge_exp)
+        expect(f3.date_format(false)).to eq(ge_exp)
       end
 
       it "lang=de_DE zone=Africa/Dakar" do
-        f3.format(t0).should eql "12.11.08#{ge_sep} 14:21:16 GMT"
-        f3.format(t1).should eql "24.10.08#{ge_sep} 23:15:17 GMT"
-        f3.format(t2).should eql "25.10.08#{ge_sep} 00:16:18 GMT"
-        f3.format(t3).should eql "25.10.08#{ge_sep} 01:17:19 GMT"
-        f3.format(t4).should eql "25.10.08#{ge_sep} 02:18:20 GMT"
-        f3.format(t5).should eql "29.03.08#{ge_sep} 00:35:21 GMT"
-        f3.format(t6).should eql "29.03.08#{ge_sep} 01:36:22 GMT"
-        f3.format(t7).should eql "29.03.08#{ge_sep} 02:37:23 GMT"
-        f3.format(t8).should eql "29.03.08#{ge_sep} 03:38:24 GMT"
+        expect(f3.format(t0)).to eq("12.11.08#{ge_sep} 14:21:16 GMT")
+        expect(f3.format(t1)).to eq("24.10.08#{ge_sep} 23:15:17 GMT")
+        expect(f3.format(t2)).to eq("25.10.08#{ge_sep} 00:16:18 GMT")
+        expect(f3.format(t3)).to eq("25.10.08#{ge_sep} 01:17:19 GMT")
+        expect(f3.format(t4)).to eq("25.10.08#{ge_sep} 02:18:20 GMT")
+        expect(f3.format(t5)).to eq("29.03.08#{ge_sep} 00:35:21 GMT")
+        expect(f3.format(t6)).to eq("29.03.08#{ge_sep} 01:36:22 GMT")
+        expect(f3.format(t7)).to eq("29.03.08#{ge_sep} 02:37:23 GMT")
+        expect(f3.format(t8)).to eq("29.03.08#{ge_sep} 03:38:24 GMT")
       end
     end
   end
 end
-

data/spec/transliteration_spec.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require "spec_helper"
-
 module ICU
   describe Transliteration::Transliterator do
     def transliterator_for(*args)
@@ -16,7 +14,7 @@ module ICU
     ].each do |id, input, output|
       it "should transliterate #{id}" do
         tl = transliterator_for(id)
-        tl.transliterate(input).should == output
+        expect(tl.transliterate(input)).to eq(output)
       end
 
     end
@@ -25,12 +23,13 @@ module ICU
   describe Transliteration do
     it "should provide a list of available ids" do
       ids = ICU::Transliteration.available_ids
-      ids.should be_kind_of(Array)
-      ids.should_not be_empty
+
+      expect(ids).to be_an(Array)
+      expect(ids).to_not be_empty
     end
 
    it "should transliterate custom rules" do
-     ICU::Transliteration.translit("NFD; [:Nonspacing Mark:] Remove; NFC", "âêîôû").should == "aeiou"
+     expect(ICU::Transliteration.translit("NFD; [:Nonspacing Mark:] Remove; NFC", "âêîôû")).to eq("aeiou")
    end
 
   end # Transliteration

data/spec/uchar_spec.rb

@@ -1,35 +1,33 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe UCharPointer do
     it 'allocates enough memory for 16-bit characters' do
-      UCharPointer.new(5).size.should == 10
+      expect(UCharPointer.new(5).size).to eq(10)
     end
 
     it 'builds a buffer from a string' do
       ptr = UCharPointer.from_string('abc')
-      ptr.should be_a UCharPointer
-      ptr.size.should == 6
-      ptr.read_array_of_uint16(3).should == [0x61, 0x62, 0x63]
+      expect(ptr).to be_a UCharPointer
+      expect(ptr.size).to eq(6)
+      expect(ptr.read_array_of_uint16(3)).to eq([0x61, 0x62, 0x63])
     end
 
     it 'takes an optional capacity' do
       ptr = UCharPointer.from_string('abc', 5)
-      ptr.size.should == 10
+      expect(ptr.size).to eq(10)
     end
 
     describe 'converting to string' do
       let(:ptr) { UCharPointer.new(3).write_array_of_uint16 [0x78, 0x0, 0x79] }
 
       it 'returns the the entire buffer by default' do
-        ptr.string.should == "x\0y"
+        expect(ptr.string).to eq("x\0y")
       end
 
       it 'returns strings of the specified length' do
-        ptr.string(0).should == ""
-        ptr.string(2).should == "x\0"
+        expect(ptr.string(0)).to eq("")
+        expect(ptr.string(2)).to eq("x\0")
       end
     end
   end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: ffi-icu
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jari Bakken
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2019-10-15 00:00:00.000000000 Z
@@ -36,34 +36,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 12.3.3
 description: Provides charset detection, locale sensitive collation and more. Depends
   on libicu.
 email: jari.bakken@gmail.com
@@ -75,6 +69,7 @@ extra_rdoc_files:
 files:
 - ".document"
 - ".gitignore"
+- ".rspec"
 - ".travis.yml"
 - Gemfile
 - LICENSE
@@ -107,7 +102,6 @@ files:
 - spec/normalization_spec.rb
 - spec/normalizer_spec.rb
 - spec/number_formatting_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/time_spec.rb
 - spec/transliteration_spec.rb
@@ -117,7 +111,7 @@ homepage: http://github.com/jarib/ffi-icu
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -133,9 +127,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
 summary: Simple Ruby FFI wrappers for things I need from ICU.
 test_files:
@@ -148,7 +141,6 @@ test_files:
 - spec/normalization_spec.rb
 - spec/normalizer_spec.rb
 - spec/number_formatting_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/time_spec.rb
 - spec/transliteration_spec.rb