ffi-icu 0.2.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0a7c36403ec9b6c70045c537a2f31cc9fc62f065
-  data.tar.gz: dce1b25080ad24cd6325a4d4b50e81b7938fc4f6
+SHA256:
+  metadata.gz: 448bbb49f51d0f81ab1aba8425c9c814fa9bb2ca06317022f1bc703769d87838
+  data.tar.gz: 27331bf11c467dc52c4ddb4bfbee954d7b0682dbeb90e802482631640e0db0fb
 SHA512:
-  metadata.gz: 01a065f767fba3fcc658838d2891782538f244246c912c9f483f440b896d7e52620128097b00bbe92f1edf6e0a26a205010ac6b02b3c15923d37903c613ff5f5
-  data.tar.gz: 941fd743b77fbbabd24254f3f23f0d18093c7614877b0a50d532211cae728f3173b2f7d744943e7e6364950ecc9f12a0770fddda150732d0a96c85880053df56
+  metadata.gz: d6d001728de2428460f163248ed9394680e9ca5509aa0644b9290de294993637ff982ec0fe7e87f40f3f1fba4a6b9dfe542147ed9a699588aae9aa80b5d01c59
+  data.tar.gz: 3c9fa41df884315d1d4a9e726b4d55c20d1d962c6e9abce260a9ab68a9ae12cb4ba0c7a8fb0f04628b9e9497c41594a5394a994f2b154aad4da1d177f4997abd

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -1,7 +1,20 @@
+language: ruby
+os: linux
+dist: focal
+
+arch:
+  - amd64
+  - arm64
+
 rvm:
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
+  - 2.6
+  - 2.7
+  - 3.0
   - ruby-head
+
 before_script:
   - sudo apt-get install -y libicu-dev
+
+jobs:
+  allow_failures:
+    - arch: arm64

data/README.md

@@ -1,4 +1,4 @@
-ffi-icu
+ffi-icu [![Build Status](https://travis-ci.org/erickguan/ffi-icu.svg?branch=master)](https://travis-ci.org/erickguan/ffi-icu)
 =======
 
 Simple FFI wrappers for ICU. Checkout the renovated [ICU gem](https://github.com/fantasticfears/icu4r) instead which supports various of encoding and distributed with packaged source. FFI-ICU needs some love with ICU gem's transcoding method.
@@ -16,7 +16,7 @@ Dependencies
 ICU.
 
 If you get messages that the library or functions are not found, you can
-set some environment varibles to tell ffi-icu where to find it, e.g.:
+set some environment variables to tell ffi-icu where to find it, e.g.:
 
     $ export FFI_ICU_LIB="icui18n.so"
     $ export FFI_ICU_VERSION_SUFFIX="_3_8"
@@ -47,7 +47,6 @@ or
 Why not just use rchardet?
 
 * speed
-* 1.9 support
 
 Locale Sensitive Collation
 --------------------------
@@ -110,14 +109,24 @@ Examples:
     f #=> "12.11.15 15:21"
 
     # reusable formatting objects
-    formater = ICU::TimeFormatting.create(:locale => 'cs_CZ', :zone => 'Europe/Prague', :date => :long , :time => :none)
-    formater.format(Time.now)  #=> "25. února 2015"
+    formatter = ICU::TimeFormatting.create(:locale => 'cs_CZ', :zone => 'Europe/Prague', :date => :long, :time => :none)
+    formatter.format(Time.now)  #=> "25. února 2015"
 ```
 
 ```ruby
     # reusable formatting objects
-    formater = ICU::TimeFormatting.create(:locale => 'cs_CZ', :zone => 'Europe/Prague', :date => :long , :time => :none)
-    formater.parse("25. února 2015") #=> Wed Feb 25 00:00:00 +0100 2015
+    formatter = ICU::TimeFormatting.create(:locale => 'cs_CZ', :zone => 'Europe/Prague', :date => :long, :time => :none)
+    formatter.parse("25. února 2015") #=> Wed Feb 25 00:00:00 +0100 2015
+```
+
+For skeleton formatting, visit the [Unicode date field symbol table](https://unicode-org.github.io/icu/userguide/format_parse/datetime/#date-field-symbol-table) page to help find the pattern characters to use.
+
+```ruby
+    formatter = ICU::TimeFormatting.create(:locale => 'cs_CZ', :date => :pattern, :time => :pattern, :skeleton => 'MMMMY')
+    formatter.format(Time.now)  #=> "únor 2015"
+
+    formatter = ICU::TimeFormatting.create(:locale => 'cs_CZ', :date => :pattern, :time => :pattern, :skeleton => 'Y')
+    formatter.format(Time.now)  #=> "2015"
 ```
 
 Tested on:
@@ -130,15 +139,15 @@ Platforms:
 
 Rubies:
 
-- 2.4.6
-- 2.5.5
-- 2.6.3
+- 2.5
+- 2.6
+- 2.7
 - ruby-head
 
 TODO:
 =====
 
-* Any other useful part of ICU? 
+* Any other useful part of ICU?
 * Windows?!
 
 Note on Patches/Pull Requests

data/ffi-icu.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
   s.summary                   = %q{Simple Ruby FFI wrappers for things I need from ICU.}
 
   s.add_runtime_dependency "ffi", "~> 1.0", ">= 1.0.9"
-  s.add_development_dependency 'rspec', '~> 2.5', '>= 2.5.0'
-  s.add_development_dependency "rake", ["~> 0.9.2"]
+  s.add_development_dependency 'rspec', '~> 3.9'
+  s.add_development_dependency "rake", [">= 12.3.3"]
 end
-

data/lib/ffi-icu/lib.rb

@@ -19,9 +19,7 @@ module ICU
             '/usr/local/{lib64,lib}',
             '/opt/local/{lib64,lib}',
             '/usr/{lib64,lib}',
-            '/usr/lib/x86_64-linux-gnu', # for Debian Multiarch http://wiki.debian.org/Multiarch
-            '/usr/lib/i386-linux-gnu',   # for Debian Multiarch
-          ]
+          ] + Dir['/usr/lib/*-linux-gnu'] # for Debian Multiarch http://wiki.debian.org/Multiarch
         end
       end
     end
@@ -39,7 +37,12 @@ module ICU
                     [find_lib("libicui18n.#{FFI::Platform::LIBSUFFIX}.??"),
                      find_lib("libicutu.#{FFI::Platform::LIBSUFFIX}.??")]
                   when :osx
-                    [find_lib("libicucore.#{FFI::Platform::LIBSUFFIX}")]
+                    # See https://developer.apple.com/documentation/macos-release-notes/macos-big-sur-11_0_1-release-notes (62986286)
+                    if Gem::Version.new(`sw_vers -productVersion`) >= Gem::Version.new('11')
+                      ["libicucore.#{FFI::Platform::LIBSUFFIX}"]
+                    else
+                      [find_lib("libicucore.#{FFI::Platform::LIBSUFFIX}")]
+                    end
                   when :linux
                     [find_lib("libicui18n.#{FFI::Platform::LIBSUFFIX}.??"),
                      find_lib("libicutu.#{FFI::Platform::LIBSUFFIX}.??")]
@@ -420,11 +423,12 @@ module ICU
     attach_function :unum_set_attribute, "unum_setAttribute#{suffix}", [:pointer, :number_format_attribute, :int32_t], :void
     # date
     enum :date_format_style, [
-      :none,  -1,
-      :full,   0,
-      :long,   1,
-      :medium, 2,
-      :short,  3,
+      :pattern, -2,
+      :none,    -1,
+      :full,    0,
+      :long,    1,
+      :medium,  2,
+      :short,   3,
     ]
     attach_function :udat_open, "udat_open#{suffix}", [:date_format_style, :date_format_style, :string, :pointer, :int32_t, :pointer, :int32_t, :pointer ], :pointer
     attach_function :udat_close, "unum_close#{suffix}", [:pointer], :void
@@ -432,6 +436,9 @@ module ICU
     attach_function :udat_parse, "udat_parse#{suffix}", [:pointer, :pointer, :int32_t,  :pointer, :pointer], :double
     attach_function :udat_toPattern, "udat_toPattern#{suffix}", [:pointer, :bool    , :pointer, :int32_t    , :pointer], :int32_t
     attach_function :udat_applyPattern, "udat_applyPattern#{suffix}", [:pointer, :bool    , :pointer, :int32_t     ], :void
+    # skeleton pattern
+    attach_function :udatpg_open, "udatpg_open#{suffix}", [:string, :pointer], :pointer
+    attach_function :udatpg_getBestPattern, "udatpg_getBestPattern#{suffix}", [:pointer, :pointer, :int32_t, :pointer, :int32_t, :pointer], :int32_t
     # tz
     attach_function :ucal_setDefaultTimeZone, "ucal_setDefaultTimeZone#{suffix}", [:pointer, :pointer], :int32_t
     attach_function :ucal_getDefaultTimeZone, "ucal_getDefaultTimeZone#{suffix}", [:pointer, :int32_t, :pointer], :int32_t

data/lib/ffi-icu/number_formatting.rb

@@ -68,8 +68,19 @@ module ICU
             case number
             when Float
               needed_length = Lib.unum_format_double(@f, number, out_ptr, needed_length, nil, error)
-            when Fixnum
-              needed_length = Lib.unum_format_int32(@f, number, out_ptr, needed_length, nil, error)
+            when Integer
+              begin
+                # Try doing it fast, for integers that can be marshaled into an int64_t
+                needed_length = Lib.unum_format_int64(@f, number, out_ptr, needed_length, nil, error)
+              rescue RangeError
+                # Fall back to stringifying in Ruby and passing that to ICU
+                unless defined? Lib.unum_format_decimal
+                  raise RangeError,"Number #{number} is too big to fit in int64_t and your "\
+                                    "ICU version is too old to have unum_format_decimal"
+                end
+                string_version = number.to_s
+                needed_length = Lib.unum_format_decimal(@f, string_version, string_version.bytesize, out_ptr, needed_length, nil, error)
+              end
             when BigDecimal
               string_version = number.to_s('F')
               if Lib.respond_to? :unum_format_decimal
@@ -77,8 +88,6 @@ module ICU
               else
                 needed_length = Lib.unum_format_double(@f, number.to_f, out_ptr, needed_length, nil, error)
               end
-            when Bignum
-              needed_length = Lib.unum_format_int64(@f, number, out_ptr, needed_length, nil, error)
             end
           end
           out_ptr.string needed_length

data/lib/ffi-icu/time_formatting.rb

@@ -65,21 +65,31 @@ module ICU
 
       private
 
-      def make_formatter(time_style, date_style, locale, time_zone_str)
-        time_zone = nil
-        d_len = 0
+      def make_formatter(time_style, date_style, locale, time_zone_str, skeleton)
+        time_zone   = nil
+        tz_len      = 0
+        pattern_len = -1
+        pattern_ptr = FFI::MemoryPointer.new(4)
+
         if time_zone_str
           time_zone = UCharPointer.from_string(time_zone_str)
-          d_len = time_zone_str.size
+          tz_len = time_zone_str.size
         else
           Lib.check_error { | error| 
             i_len  = 150
             time_zone = UCharPointer.new(i_len)
-            d_len = Lib.ucal_getDefaultTimeZone(time_zone, i_len, error) 
+            tz_len = Lib.ucal_getDefaultTimeZone(time_zone, i_len, error) 
           }
         end
 
-        ptr = Lib.check_error { | error| Lib.udat_open(time_style, date_style, locale, time_zone, d_len, FFI::MemoryPointer.new(4), -1, error) }
+        if skeleton
+          date_style = :pattern
+          time_style = :pattern
+
+          pattern_len, pattern_ptr = skeleton_format(skeleton, locale)
+        end
+
+        ptr = Lib.check_error { | error| Lib.udat_open(time_style, date_style, locale, time_zone, tz_len, pattern_ptr, pattern_len, error) }
         FFI::AutoPointer.new(ptr, Lib.method(:udat_close))
       end
     end
@@ -91,7 +101,9 @@ module ICU
         locale     = options[:locale] || 'C'
         tz_style   = options[:tz_style]
         time_zone  = options[:zone]
-        @f = make_formatter(time_style, date_style, locale, time_zone)
+        skeleton   = options[:skeleton]
+
+        @f = make_formatter(time_style, date_style, locale, time_zone, skeleton)
         if tz_style
           f0 = date_format(true)
           f1 = update_tz_format(f0, tz_style)    
@@ -103,7 +115,7 @@ module ICU
 
       def parse(str)
           str_u = UCharPointer.from_string(str)
-          str_l = str_u.size
+          str_l = str.size
           Lib.check_error do |error|
             ret = Lib.udat_parse(@f, str_u, str_l, nil, error)
             Time.at(ret / 1000.0)
@@ -177,6 +189,32 @@ module ICU
           needed_length = Lib.udat_applyPattern(@f, localized, pattern, pattern_len)
         end
       end
+
+      def skeleton_format(skeleton_pattern_str, locale)
+          skeleton_pattern_ptr = UCharPointer.from_string(skeleton_pattern_str)
+          skeleton_pattern_len = skeleton_pattern_str.size
+
+          needed_length = 0
+          pattern_ptr = UCharPointer.new(needed_length)
+
+          udatpg_ptr = Lib.check_error { |error| Lib.udatpg_open(locale, error) }
+          generator = FFI::AutoPointer.new(udatpg_ptr, Lib.method(:udat_close))
+
+          retried = false
+
+        begin
+          Lib.check_error do |error|
+            needed_length = Lib.udatpg_getBestPattern(generator, skeleton_pattern_ptr, skeleton_pattern_len, pattern_ptr, needed_length, error)
+          end
+
+          return needed_length, pattern_ptr
+        rescue BufferOverflowError
+          raise BufferOverflowError, "needed: #{needed_length}" if retried
+          pattern_ptr = pattern_ptr.resized_to needed_length
+          retried = true
+          retry
+        end
+      end
     end # DateTimeFormatter
   end # Formatting
 end # ICU

data/lib/ffi-icu/version.rb

@@ -1,3 +1,3 @@
 module ICU
-  VERSION = "0.2.0"
+  VERSION = "0.4.1"
 end

data/lib/ffi-icu.rb

@@ -18,15 +18,6 @@ module ICU
       os
     end
   end
-
-  def self.ruby19?
-    RUBY_VERSION >= '1.9'
-  end
-end
-
-unless ICU.ruby19?
-  require 'jcode'
-  $KCODE = 'u'
 end
 
 require "ffi-icu/core_ext/string"

data/spec/break_iterator_spec.rb

@@ -1,75 +1,76 @@
 # encoding: utf-8
 
-require "spec_helper"
-
 module ICU
   describe BreakIterator do
 
     it "should return available locales" do
       locales = ICU::BreakIterator.available_locales
-      locales.should be_kind_of(Array)
-      locales.should_not be_empty
-      locales.should include("en_US")
+      expect(locales).to be_an(Array)
+      expect(locales).to_not be_empty
+      expect(locales).to include("en_US")
     end
 
     it "finds all word boundaries in an English string" do
       iterator = BreakIterator.new :word, "en_US"
       iterator.text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
-      iterator.to_a.should == [0, 5, 6, 11, 12, 17, 18, 21, 22, 26, 27, 28, 39, 40, 51, 52, 56, 57, 58, 61, 62, 64, 65, 72, 73, 79, 80, 90, 91, 93, 94, 100, 101, 103, 104, 110, 111, 116, 117, 123, 124]
+      expect(iterator.to_a).to eq(
+        [0, 5, 6, 11, 12, 17, 18, 21, 22, 26, 27, 28, 39, 40, 51, 52, 56, 57, 58, 61, 62, 64, 65, 72, 73, 79, 80, 90, 91, 93, 94, 100, 101, 103, 104, 110, 111, 116, 117, 123, 124]
+      )
     end
 
     it "returns each substring" do
       iterator = BreakIterator.new :word, "en_US"
       iterator.text = "Lorem ipsum dolor sit amet."
 
-      iterator.substrings.should == ["Lorem", " ", "ipsum", " ", "dolor", " ", "sit", " ", "amet", "."]
+      expect(iterator.substrings).to eq(["Lorem", " ", "ipsum", " ", "dolor", " ", "sit", " ", "amet", "."])
     end
 
     it "returns the substrings of a non-ASCII string" do
       iterator = BreakIterator.new :word, "th_TH"
       iterator.text = "รู้อะไรไม่สู้รู้วิชา รู้รักษาตัวรอดเป็นยอดดี"
 
-      iterator.substrings.should ==  ["รู้", "อะไร", "ไม่สู้", "รู้", "วิชา", " ", "รู้", "รักษา", "ตัว", "รอด", "เป็น", "ยอดดี"]
+      expect(iterator.substrings).to eq(
+        ["รู้", "อะไร", "ไม่สู้", "รู้", "วิชา", " ", "รู้", "รักษา", "ตัว", "รอด", "เป็น", "ยอดดี"]
+      )
     end
 
     it "finds all word boundaries in a non-ASCII string" do
       iterator = BreakIterator.new :word, "th_TH"
       iterator.text = "การทดลอง"
-      iterator.to_a.should == [0, 3, 8]
+      expect(iterator.to_a).to eq([0, 3, 8])
     end
 
     it "finds all sentence boundaries in an English string" do
       iterator = BreakIterator.new :sentence, "en_US"
       iterator.text = "This is a sentence. This is another sentence, with a comma in it."
-      iterator.to_a.should == [0, 20, 65]
+      expect(iterator.to_a).to eq([0, 20, 65])
     end
 
     it "can navigate back and forward" do
       iterator = BreakIterator.new :word, "en_US"
       iterator.text = "Lorem ipsum dolor sit amet."
 
-      iterator.first.should == 0
+      expect(iterator.first).to eq(0)
       iterator.next
-      iterator.current.should == 5
-      iterator.last.should == 27
+      expect(iterator.current).to eq(5)
+      expect(iterator.last).to eq(27)
     end
 
     it "fetches info about given offset" do
       iterator = BreakIterator.new :word, "en_US"
       iterator.text = "Lorem ipsum dolor sit amet."
 
-      iterator.following(3).should == 5
-      iterator.preceding(6).should == 5
+      expect(iterator.following(3)).to eq(5)
+      expect(iterator.preceding(6)).to eq(5)
 
-      iterator.should be_boundary(5)
-      iterator.should_not be_boundary(10)
+      expect(iterator).to be_boundary(5)
+      expect(iterator).to_not be_boundary(10)
     end
 
     it "returns an Enumerator if no block was given" do
       iterator = BreakIterator.new :word, "nb"
-      expected = ICU.ruby19? ? Enumerator : Enumerable::Enumerator
 
-      iterator.each.should be_kind_of(expected)
+      expect(iterator.each).to be_kind_of(Enumerator)
     end
 
   end # BreakIterator

data/spec/chardet_spec.rb

@@ -1,29 +1,27 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 describe ICU::CharDet::Detector do
 
   let(:detector) { ICU::CharDet::Detector.new }
 
   it "should recognize UTF-8" do
     m = detector.detect("æåø")
-    m.name.should == "UTF-8"
-    m.language.should be_kind_of(String)
+    expect(m.name).to eq("UTF-8")
+    expect(m.language).to be_a(String)
   end
 
   it "has a list of detectable charsets" do
     cs = detector.detectable_charsets
-    cs.should be_kind_of(Array)
-    cs.should_not be_empty
+    expect(cs).to be_an(Array)
+    expect(cs).to_not be_empty
 
-    cs.first.should be_kind_of(String)
+    expect(cs.first).to be_a(String)
   end
 
   it "should disable / enable the input filter" do
-    detector.input_filter_enabled?.should be_false
+    expect(detector.input_filter_enabled?).to be_falsey
     detector.input_filter_enabled = true
-    detector.input_filter_enabled?.should be_true
+    expect(detector.input_filter_enabled?).to be_truthy
   end
 
   it "should should set declared encoding" do
@@ -31,14 +29,14 @@ describe ICU::CharDet::Detector do
   end
 
   it "should detect several matching encodings" do
-    detector.detect_all("foo bar").should be_instance_of(Array)
+    expect(detector.detect_all("foo bar")).to be_an(Array)
   end
 
   it "should support null bytes" do
     # Create a utf-16 string and then force it to binary (ascii) to mimic data from net/http
     string = "foo".encode("UTF-16").force_encoding("binary")
     m = detector.detect(string)
-    m.name.should == "UTF-16BE"
-    m.language.should be_kind_of(String)
+    expect(m.name).to eq("UTF-16BE")
+    expect(m.language).to be_a(String)
   end
 end

data/spec/collation_spec.rb

@@ -1,12 +1,10 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module Collation
     describe "Collation" do
       it "should collate an array of strings" do
-        Collation.collate("nb", %w[æ å ø]).should == %w[æ ø å]
+        expect(Collation.collate("nb", %w[æ å ø])).to eq(%w[æ ø å])
       end
     end
 
@@ -14,51 +12,50 @@ module ICU
       let(:collator) { Collator.new("nb") }
 
       it "should collate an array of strings" do
-        collator.collate(%w[å ø æ]).should == %w[æ ø å]
+        expect(collator.collate(%w[å ø æ])).to eq(%w[æ ø å])
       end
 
       it "raises an error if argument does not respond to :sort" do
-        lambda { collator.collate(1) }.should raise_error(ArgumentError)
+        expect { collator.collate(1) }.to raise_error(ArgumentError)
       end
 
       it "should return available locales" do
         locales = ICU::Collation.available_locales
-        locales.should be_kind_of(Array)
-        locales.should_not be_empty
-        locales.should include("nb")
+        expect(locales).to be_an(Array)
+        expect(locales).to_not be_empty
+        expect(locales).to include("nb")
       end
 
       it "should return the locale of the collator" do
-        l = collator.locale
-        l.should == "nb"
+        expect(collator.locale).to eq('nb')
       end
 
       it "should compare two strings" do
-        collator.compare("blåbærsyltetøy", "blah").should == 1
-        collator.compare("blah", "blah").should == 0
-        collator.compare("ba", "bl").should == -1
+        expect(collator.compare("blåbærsyltetøy", "blah")).to eq(1)
+        expect(collator.compare("blah", "blah")).to eq(0)
+        expect(collator.compare("ba", "bl")).to eq(-1)
       end
 
       it "should know if a string is greater than another" do
-        collator.should be_greater("z", "a")
-        collator.should_not be_greater("a", "z")
+        expect(collator).to be_greater("z", "a")
+        expect(collator).to_not be_greater("a", "z")
       end
 
       it "should know if a string is greater or equal to another" do
-        collator.should be_greater_or_equal("z", "a")
-        collator.should be_greater_or_equal("z", "z")
-        collator.should_not be_greater_or_equal("a", "z")
+        expect(collator).to be_greater_or_equal("z", "a")
+        expect(collator).to be_greater_or_equal("z", "z")
+        expect(collator).to_not be_greater_or_equal("a", "z")
       end
 
       it "should know if a string is equal to another" do
-        collator.should be_equal("a", "a")
-        collator.should_not be_equal("a", "b")
+        expect(collator).to be_equal("a", "a")
+        expect(collator).to_not be_equal("a", "b")
       end
 
       it "should return rules" do
-        collator.rules.should_not be_empty
+        expect(collator.rules).to_not be_empty
         # ö sorts before Ö
-        collator.rules.include?('ö<<<Ö').should be_true
+        expect(collator.rules).to include('ö<<<Ö')
       end
 
     end

data/spec/lib/version_info_spec.rb

@@ -1,14 +1,19 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   module Lib
     describe VersionInfo do
-      its(:to_a) { should be_an Array }
-      its(:to_s) do
-        should be_a String
-        should match /^[0-9.]+$/
+      describe '.to_a' do
+        subject { described_class.new.to_a }
+
+        it { is_expected.to be_an(Array) }
+      end
+
+      describe '.to_s' do
+        subject { described_class.new.to_s }
+
+        it { is_expected.to be_a(String) }
+        it { is_expected.to match(/^[0-9.]+$/) }
       end
     end
   end

data/spec/lib_spec.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require 'spec_helper'
-
 module ICU
   describe Lib do
     describe 'error checking' do
@@ -9,8 +7,8 @@ module ICU
 
       context 'upon success' do
         it 'returns the block result' do
-          Lib.check_error { |status| return_value }.should == return_value
-          Lib.check_error { |status| status.write_int(0); return_value }.should == return_value
+          expect(Lib.check_error { |status| return_value }).to eq(return_value)
+          expect(Lib.check_error { |status| status.write_int(0); return_value }).to eq(return_value)
         end
       end
 
@@ -28,8 +26,9 @@ module ICU
           before(:each) { $VERBOSE = true }
 
           it 'prints to STDERR and returns the block result' do
-            $stderr.should_receive(:puts) { |message| message.should match /U_.*_WARNING/ }
-            Lib.check_error { |status| status.write_int(-127); return_value }.should == return_value
+            expect($stderr).to receive(:puts) { |message| expect(message).to match /U_.*_WARNING/ }
+            error_check = Lib.check_error { |status| status.write_int(-127); return_value }
+            expect(error_check).to eq(return_value)
           end
         end
 
@@ -37,8 +36,9 @@ module ICU
           before(:each) { $VERBOSE = false }
 
           it 'returns the block result' do
-            $stderr.should_not_receive(:puts)
-            Lib.check_error { |status| status.write_int(-127); return_value }.should == return_value
+            expect($stderr).to_not receive(:puts)
+            error_check = Lib.check_error { |status| status.write_int(-127); return_value }
+            expect(error_check).to eq(return_value)
           end
         end
       end
@@ -49,15 +49,15 @@ module ICU
         subject { Lib.cldr_version }
 
         it { should be_a Lib::VersionInfo }
-        it('is populated') { subject.to_a.should_not == [0,0,0,0] }
+        it('is populated') { expect(subject.to_a).to_not eq([0,0,0,0]) }
       end
     end
 
     describe 'ICU version' do
       subject { Lib.version }
 
-      it { should be_a Lib::VersionInfo }
-      it('is populated') { subject.to_a.should_not == [0,0,0,0] }
+      it { is_expected.to be_a Lib::VersionInfo }
+      it('is populated') { expect(subject.to_a).to_not eq([0,0,0,0]) }
     end
   end
 end