ffi-icu 0.3.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e1817bf83d85197ea62937c274ff98c71984ef4a432a6f76fc3cca764bf45dc
-  data.tar.gz: 2a21f2177dc151831fe89782be8cfe53d2f13a6d1038961eb1efe5c3970a27a0
+  metadata.gz: 357d3d218075dcfd56e963cd261c5fbe947d8daeb5d5826aebce8f1bedfe7ffe
+  data.tar.gz: afb2c28c1730cf05652433a1a721447385de47fa0fd105cb9782fe7496c55d65
 SHA512:
-  metadata.gz: 6fb2d659678226632c485ea24de6e79f7d20ccf7b80b03833f680bb295ae07736957f3a9037ac1d3639b432f6974c279b580767d08315ad005c57cc6be79ed8b
-  data.tar.gz: 9c49ddef23ae27f88d4eaffbaf0cf42b670e7f07939b7c19b6255a4ac157faae25e8eb5bc973764e767b3b32d40226c4b1cc95772c629fbe4b678d4cff5ebccb
+  metadata.gz: a257ab16df440695f42f6db486950e62fa1c08655324ad59d347eeb0e02d46c37581f04845cf035c528c7223a8e3d092a9bac877f7da5da10daee18e701d9aa3
+  data.tar.gz: be241d1659c60288c84f7844efaec71d368c1c650b4c1be410cbb0ff99cf6f08f468af30fd02a5ac050d853b18e243250dcc199c81815a5d2f7b1bf9bd783559

data/.travis.yml

@@ -1,13 +1,20 @@
 language: ruby
 os: linux
-dist: xenial
+dist: focal
+
+arch:
+  - amd64
+  - arm64
 
 rvm:
-  - 2.5
   - 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

@@ -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"
@@ -109,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:

data/lib/ffi-icu/lib/util.rb

@@ -28,7 +28,19 @@ module ICU
         result.read_string(length)
       end
 
-      def self.read_uchar_buffer(length)
+      def self.read_uchar_buffer(length, &blk)
+        buf, len = read_uchar_buffer_as_ptr_impl(length, &blk)
+        buf.string(len)
+      end
+
+      def self.read_uchar_buffer_as_ptr(length, &blk)
+        buf, _ = read_uchar_buffer_as_ptr_impl(length, &blk)
+        buf
+      end
+
+      private
+
+      def self.read_uchar_buffer_as_ptr_impl(length)
         attempts = 0
 
         begin
@@ -40,7 +52,7 @@ module ICU
           raise BufferOverflowError, "needed: #{length}"
         end
 
-        result.string(length)
+        [result, length]
       end
     end
   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,8 +37,12 @@ module ICU
                     [find_lib("libicui18n.#{FFI::Platform::LIBSUFFIX}.??"),
                      find_lib("libicutu.#{FFI::Platform::LIBSUFFIX}.??")]
                   when :osx
-                    # 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')
+                    if ENV.key?('FFI_ICU_LIB')
+                      # Ensure we look in the user-supplied override dir for a user-compiled libicu
+                      [find_lib("libicui18n.??.#{FFI::Platform::LIBSUFFIX}"),
+                      find_lib("libicutu.??.#{FFI::Platform::LIBSUFFIX}")]
+                    elsif Gem::Version.new(`sw_vers -productVersion`) >= Gem::Version.new('11')
+                      # See https://developer.apple.com/documentation/macos-release-notes/macos-big-sur-11_0_1-release-notes (62986286)
                       ["libicucore.#{FFI::Platform::LIBSUFFIX}"]
                     else
                       [find_lib("libicucore.#{FFI::Platform::LIBSUFFIX}")]
@@ -425,11 +427,16 @@ 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,
+    ]
+    enum :uloc_data_locale_type, [
+      :actual_locale, 0,
+      :valid_locale, 1,
     ]
     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
@@ -437,6 +444,11 @@ 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_close, "udatpg_close#{suffix}", [:pointer], :void
+    attach_function :udatpg_getBestPattern, "udatpg_getBestPattern#{suffix}", [:pointer, :pointer, :int32_t, :pointer, :int32_t, :pointer], :int32_t
+    attach_function :udatpg_getSkeleton, "udatpg_getSkeleton#{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

@@ -38,6 +38,14 @@ module ICU
                                     #   (for example, "Unknown City"), such as Los Angeles
       # see: http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
     }
+
+    HOUR_CYCLE_SYMS = {
+      'h11' => 'K',
+      'h12' => 'h',
+      'h23' => 'H',
+      'h24' => 'k',
+      :locale => 'j',
+    }
     @default_options = {}
     
     def self.create(options = {})
@@ -65,33 +73,50 @@ 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
 
     class DateTimeFormatter < BaseFormatter
       def initialize(options={})
-        time_style = options[:time]   || :short
-        date_style = options[:date]   || :short
-        locale     = options[:locale] || 'C'
-        tz_style   = options[:tz_style]
-        time_zone  = options[:zone]
-        @f = make_formatter(time_style, date_style, locale, time_zone)
+        time_style  = options[:time]   || :short
+        date_style  = options[:date]   || :short
+        @locale     = options[:locale] || 'C'
+        tz_style    = options[:tz_style]
+        time_zone   = options[:zone]
+        skeleton    = options[:skeleton]
+        @hour_cycle = options[:hour_cycle]
+
+        if @hour_cycle && !HOUR_CYCLE_SYMS.keys.include?(@hour_cycle)
+          raise ICU::Error.new("Unknown hour cycle #{@hour_cycle}")
+        end
+
+        @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)    
@@ -99,11 +124,13 @@ module ICU
             set_date_format(true, f1)
           end
         end
+
+        replace_hour_symbol!
       end
 
       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)
@@ -170,6 +197,128 @@ module ICU
       end
 
       def set_date_format(localized, pattern_str)
+        set_date_format_impl(localized, pattern_str)
+
+        # After setting the date format string, we need to ensure that any hour
+        # symbols were properly localised according to @hour_cycle.
+        replace_hour_symbol!
+      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(:udatpg_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
+
+      private
+
+      # Converts the current pattern to a pattern that takes the desired hour cycle
+      # into account. This is needed because most of the standard patterns in ICU
+      # contain either h (12 hour) or H (23 hour) in them, instead of j (locale-
+      # specified hour cycle). This means if you use a locale with an @hours=h12
+      # keyword in it, for example, it would normally be totally ignored by ICU.
+      #
+      # This is the same fixup done by Firefox:
+      # https://github.com/tc39/ecma402/issues/665#issuecomment-1084833809
+      # https://searchfox.org/mozilla-central/rev/625c3d0c8ae46502aed83f33bd530cb93e926e9f/intl/components/src/DateTimeFormat.cpp#282-323
+      def replace_hour_symbol!
+        # Short circuit this case - nil means "use whatever is in the pattern already", so
+        # no need to actually run any of this implementation.
+        return unless @hour_cycle
+
+        # Get the current pattern and convert to a skeleton
+        skeleton_str = pattern_to_skeleton_uchar(current_pattern_as_uchar).string
+
+        # Manipulate the skeleton to make it work with the correct hour cycle.
+        skeleton_str.gsub!(/[hHkKjJ]/, HOUR_CYCLE_SYMS[@hour_cycle])
+
+        # Either ensure the skeleton has, or does not have, am/pm, as appropriate
+        if ['h11', 'h12'].include?(@hour_cycle)
+          skeleton_str << 'a' unless skeleton_str.include? 'a'
+        else
+          skeleton_str.gsub!('a', '')
+        end
+
+        # Convert the skeleton back to a pattern
+        new_pattern_str = skeleton_to_pattern_uchar(UCharPointer.from_string(skeleton_str)).string
+
+        # We also need to manipulate the _pattern_, a little bit, because (according to Firefox source):
+        #
+        #     Input skeletons don't differentiate between "K" and "h" resp. "k" and "H".
+        #
+        # https://searchfox.org/mozilla-central/rev/625c3d0c8ae46502aed83f33bd530cb93e926e9f/intl/components/src/DateTimeFormat.cpp#183
+        # So, if we put a skeleton with a k in it into getBestPattern, it comes out with a H (and a
+        # skeleton with a K in it comes out with a h). Need to fix this in the generated pattern.
+        resolved_hour_cycle = @hour_cycle == :locale ? Locale.new(@locale).keyword('hours') : @hour_cycle
+
+        if HOUR_CYCLE_SYMS.keys.include?(resolved_hour_cycle)
+          new_pattern_str.gsub!(/[hHkK]/, HOUR_CYCLE_SYMS[resolved_hour_cycle])
+        end
+
+        # Finally, set the new pattern onto the date time formatter
+        set_date_format_impl(false, new_pattern_str)
+      end
+
+      # Load up the date formatter locale and make a generator
+      # Note that we _MUST_ actually use @locale as passed to us, rather than calling
+      # udat_getLocaleByType to look it up from @f, because the latter will throw away
+      # any @hours specifier in the locale, and we need it.
+      def datetime_pattern_generator
+        @datetime_pattern_generator ||= FFI::AutoPointer.new(
+          Lib.check_error { |error| Lib.udatpg_open(@locale, error) },
+          Lib.method(:udatpg_close)
+        )
+      end
+
+      def current_pattern_as_uchar
+        Lib::Util.read_uchar_buffer_as_ptr(0) do |buf, error|
+          Lib.udat_toPattern(@f, false, buf, buf.length_in_uchars, error)
+        end
+      end
+
+      def pattern_to_skeleton_uchar(pattern_uchar)
+        Lib::Util.read_uchar_buffer_as_ptr(0) do |buf, error|
+          Lib.udatpg_getSkeleton(
+            datetime_pattern_generator,
+            pattern_uchar, pattern_uchar.length_in_uchars,
+            buf, buf.length_in_uchars,
+            error
+          )
+        end
+      end
+
+      def skeleton_to_pattern_uchar(skeleton_uchar)
+        Lib::Util.read_uchar_buffer_as_ptr(0) do |buf, error|
+          Lib.udatpg_getBestPattern(
+            datetime_pattern_generator,
+            skeleton_uchar, skeleton_uchar.length_in_uchars,
+            buf, buf.length_in_uchars,
+            error
+          )
+        end
+      end
+
+      def set_date_format_impl(localized, pattern_str)
         pattern     = UCharPointer.from_string(pattern_str)
         pattern_len = pattern_str.size
 

data/lib/ffi-icu/uchar.rb

@@ -43,6 +43,10 @@ module ICU
       wstring.pack("U*")
     end
 
+    def length_in_uchars
+      size / type_size
+    end
+
 
   end # UCharPointer
 end # ICU

data/lib/ffi-icu/version.rb

@@ -1,3 +1,3 @@
 module ICU
-  VERSION = "0.3.0"
+  VERSION = "0.4.2"
 end

data/spec/number_formatting_spec.rb

@@ -69,6 +69,11 @@ module ICU
           expect { NumberFormatting.create('en-US', :currency, style: :iso) }.to raise_error(StandardError)
         end
       end
+
+      it 'should format a bignum' do
+        str = NumberFormatting.format_number("en", 1_000_000_000_000_000_000_000_000_000_000_000_000_000)
+        expect(str).to eq('1,000,000,000,000,000,000,000,000,000,000,000,000,000')
+      end
     end
   end # NumberFormatting
 end # ICU

data/spec/time_spec.rb

@@ -59,7 +59,7 @@ module ICU
         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)
+      f3 = TimeFormatting.create(:locale => 'de_DE', :zone => 'Africa/Dakar', :date => :short , :time => :long)
       ge_sep = ""
       if cldr_version >= "27.0.1"
         ge_sep = ","
@@ -82,6 +82,105 @@ module ICU
         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
+
+      context 'skeleton pattern' do
+        f4 = TimeFormatting.create(:locale => 'fr_FR', :date => :pattern, :time => :pattern, :skeleton => 'MMMy')
+
+        it 'check format' do
+          expect(f4.format(t0)).to eq("nov. 2008")
+          expect(f4.format(t1)).to eq("oct. 2008")
+        end
+
+        it 'check date_format' do
+          expect(f4.date_format(true)).to eq("MMM y")
+        end
+      end
+
+      context 'hour cycle' do
+        # en_AU normally is 12 hours, fr_FR is normally 23 hours
+        ['en_AU', 'fr_FR', 'zh_CN'].each do |locale_name|
+          context "with locale #{locale_name}" do
+            it 'works with hour_cycle: h11' do
+              t = Time.new(2021, 04, 01, 12, 05, 0, "+00:00")
+              str = TimeFormatting.format(t, time: :short, date: :none, locale: locale_name, zone: 'UTC', hour_cycle: 'h11')
+              expect(str).to match(/0:05/i)
+              expect(str).to match(/(pm|下午)/i)
+            end
+
+            it 'works with hour_cycle: h12' do
+              t = Time.new(2021, 04, 01, 12, 05, 0, "+00:00")
+              str = TimeFormatting.format(t, time: :short, date: :none, locale: locale_name, zone: 'UTC', hour_cycle: 'h12')
+              expect(str).to match(/12:05/i)
+              expect(str).to match(/(pm|下午)/i)
+            end
+
+            it 'works with hour_cycle: h23' do
+              t = Time.new(2021, 04, 01, 00, 05, 0, "+00:00")
+              str = TimeFormatting.format(t, time: :short, date: :none, locale: locale_name, zone: 'UTC', hour_cycle: 'h23')
+              expect(str).to match(/0:05/i)
+              expect(str).to_not match(/(am|pm)/i)
+            end
+
+            it 'works with hour_cycle: h24' do
+              t = Time.new(2021, 04, 01, 00, 05, 0, "+00:00")
+              str = TimeFormatting.format(t, time: :short, date: :none, locale: locale_name, zone: 'UTC', hour_cycle: 'h24')
+              expect(str).to match(/24:05/i)
+              expect(str).to_not match(/(am|pm)/i)
+            end
+
+            context '@hours keyword' do
+              before(:each) do
+                skip("Only works on ICU >= 67") if Lib.version.to_a[0] < 67
+              end
+
+              it 'works with @hours=h11 keyword' do
+                t = Time.new(2021, 04, 01, 12, 05, 0, "+00:00")
+                locale = Locale.new(locale_name).with_keyword('hours', 'h11').to_s
+                str = TimeFormatting.format(t, time: :short, date: :none, locale: locale, zone: 'UTC', hour_cycle: :locale)
+                expect(str).to match(/0:05/i)
+                expect(str).to match(/(pm|下午)/i)
+              end
+              it 'works with @hours=h12 keyword' do
+                t = Time.new(2021, 04, 01, 12, 05, 0, "+00:00")
+                locale = Locale.new(locale_name).with_keyword('hours', 'h12').to_s
+                str = TimeFormatting.format(t, time: :short, date: :none, locale: locale, zone: 'UTC', hour_cycle: :locale)
+                expect(str).to match(/12:05/i)
+                expect(str).to match(/(pm|下午)/i)
+              end
+
+              it 'works with @hours=h23 keyword' do
+                t = Time.new(2021, 04, 01, 00, 05, 0, "+00:00")
+                locale = Locale.new(locale_name).with_keyword('hours', 'h23').to_s
+                str = TimeFormatting.format(t, time: :short, date: :none, locale: locale, zone: 'UTC', hour_cycle: :locale)
+                expect(str).to match(/0:05/i)
+                expect(str).to_not match(/(am|pm)/i)
+              end
+
+              it 'works with @hours=h24 keyword' do
+                t = Time.new(2021, 04, 01, 00, 05, 0, "+00:00")
+                locale = Locale.new(locale_name).with_keyword('hours', 'h24').to_s
+                str = TimeFormatting.format(t, time: :short, date: :none, locale: locale, zone: 'UTC', hour_cycle: :locale)
+                expect(str).to match(/24:05/i)
+                expect(str).to_not match(/(am|pm)/i)
+              end
+            end
+          end
+        end
+
+        it 'works with defaults on a h12 locale' do
+          t = Time.new(2021, 04, 01, 13, 05, 0, "+00:00")
+          str = TimeFormatting.format(t, time: :short, date: :none, locale: 'en_AU', zone: 'UTC', hour_cycle: :locale)
+          expect(str).to match(/1:05/i)
+          expect(str).to match(/pm/i)
+        end
+
+        it 'works with defaults on a h23 locale' do
+          t = Time.new(2021, 04, 01, 0, 05, 0, "+00:00")
+          str = TimeFormatting.format(t, time: :short, date: :none, locale: 'fr_FR', zone: 'UTC', hour_cycle: :locale)
+          expect(str).to match(/0:05/i)
+          expect(str).to_not match(/(am|pm)/i)
+        end
+      end
     end
   end
 end

data/spec/transliteration_spec.rb

@@ -9,7 +9,7 @@ module ICU
     [
       ["Any-Hex", "abcde", "\\u0061\\u0062\\u0063\\u0064\\u0065"],
       ["Lower", "ABC", "abc"],
-      ["en", "雙屬性集合之空間分群演算法-應用於地理資料", "shuāng shǔ xìng jí hé zhī kōng jiān fēn qún yǎn suàn fǎ-yīng yòng yú de lǐ zī liào"],
+      ["Han-Latin", "雙屬性集合之空間分群演算法-應用於地理資料", "shuāng shǔ xìng jí hé zhī kōng jiān fēn qún yǎn suàn fǎ-yīng yòng yú de lǐ zī liào"],
       ["Devanagari-Latin", "दौलत", "daulata"]
     ].each do |id, input, output|
       it "should transliterate #{id}" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-icu
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Jari Bakken