ffi-icu 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 357d3d218075dcfd56e963cd261c5fbe947d8daeb5d5826aebce8f1bedfe7ffe
-  data.tar.gz: afb2c28c1730cf05652433a1a721447385de47fa0fd105cb9782fe7496c55d65
+  metadata.gz: 77b5088964964f78d79893dc7260d5e01dde9e701c62877eb19556ecc3ee460b
+  data.tar.gz: b008d71ecdd7360bbe8bf24544f888a71fede1934a5fdaf1bb46b121b21be95e
 SHA512:
-  metadata.gz: a257ab16df440695f42f6db486950e62fa1c08655324ad59d347eeb0e02d46c37581f04845cf035c528c7223a8e3d092a9bac877f7da5da10daee18e701d9aa3
-  data.tar.gz: be241d1659c60288c84f7844efaec71d368c1c650b4c1be410cbb0ff99cf6f08f468af30fd02a5ac050d853b18e243250dcc199c81815a5d2f7b1bf9bd783559
+  metadata.gz: 9074f912c536402fadf8e489989bc475f4330fac69cd32b720c5916fa0f5a4b447a1ef4994692f0116c36def1cc84632d2e6f4529071412d4a44b01d2f10e5a1
+  data.tar.gz: '028fab98aaf0c3ddef7f6a4af81f9c228c84bd1d2a17be241ab4834fb0c4922ca51dd1c7e49860589a54178a0c02430b2a60cb3e1f3cd460e605336a58200982'

data/.travis.yml

@@ -7,14 +7,22 @@ arch:
   - arm64
 
 rvm:
-  - 2.6
   - 2.7
   - 3.0
+  - 3.1
   - ruby-head
+  - truffleruby
 
 before_script:
-  - sudo apt-get install -y libicu-dev
+  - sudo apt install -y icu-devtools g++
+  - sudo chmod +x build_icu.sh
+  - sudo $PWD/build_icu.sh versions
+  - sudo $PWD/build_icu.sh install 71.1
+  - export LD_LIBRARY_PATH=/usr/local/lib
+  - icuinfo
+  - yes | gem update --system --force
+  - gem install bundler
 
 jobs:
   allow_failures:
-    - arch: arm64
+    - rvm: truffleruby

data/README.md

@@ -1,4 +1,4 @@
-ffi-icu [![Build Status](https://travis-ci.org/erickguan/ffi-icu.svg?branch=master)](https://travis-ci.org/erickguan/ffi-icu)
+ffi-icu [![Build Status](https://app.travis-ci.com/erickguan/ffi-icu.svg?branch=master)](https://app.travis-ci.com/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.
@@ -129,6 +129,16 @@ For skeleton formatting, visit the [Unicode date field symbol table](https://uni
     formatter.format(Time.now)  #=> "2015"
 ```
 
+Transliteration
+---------------
+
+Example:
+
+```ruby
+ICU::Transliteration.transliterate('Traditional-Simplified', '沈從文') # => "沈从文"
+
+```
+
 Tested on:
 ==========
 

data/build_icu.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+if [[ -x $(which icuinfo) ]]; then
+    echo System ICU version: $(icuinfo | grep -o '"version">[^<]\+' | grep -o '[^"><]\+$')
+else
+    echo 'System ICU not installed'
+fi
+
+if [[ "$1" == '' ]]; then
+    echo ''
+    echo 'Usage:'
+    echo ''
+    echo '1) bash icu-install.sh versions'
+    echo ''
+    echo '2) bash icu-install.sh install <version>'
+fi
+
+if [[ "$1" == 'versions' ]]; then
+    echo ''
+    echo 'Available ICU versions'
+    wget -O - https://icu.unicode.org/download 2>/dev/null | grep -P -o '(?<=http://site.icu-project.org/download/)\d+#TOC-ICU4C-Download.+;&gt;\K[\d.]+'
+fi
+
+if [[ "$2" != "" && "$1" == 'install' ]]; then
+    which g++ || sudo apt install -y g++
+
+    ICU_VERSION=$2
+    ICU_SRC_FILE="icu4c-$(echo $ICU_VERSION | sed -e 's/\./_/')-src.tgz"
+    echo "Trying to install ICU version: $ICU_VERSION"
+    if [[ ! -e "$ICU_SRC_FILE" ]]; then
+        wget "https://github.com/unicode-org/icu/releases/download/release-$(echo $ICU_VERSION | sed -e 's/\./-/')/$ICU_SRC_FILE"
+    fi
+    if [[ ! -e "$ICU_SRC_FILE" ]]; then
+        exit 1;
+    fi
+
+    ICU_SRC_FOLDER="icu-release-$(echo $ICU_VERSION | sed -e 's/\./-/')"
+    tar zxvf "$ICU_SRC_FILE"
+    which g++ || sudo apt install -y g++
+
+    if [[ ! -e "/opt/icu$ICU_VERSION" ]]; then
+        pushd icu/source
+            sudo mkdir "/opt/icu$ICU_VERSION"
+            ./configure --prefix="/opt/icu$ICU_VERSION" && make -j2 && sudo make install
+            ls -alh /opt/icu$ICU_VERSION/lib/
+            sudo cp -r /opt/icu$ICU_VERSION/lib/* /usr/local/lib
+        popd
+    else
+        echo "ICU already installed at (/opt/icu$ICU_VERSION)"
+    fi
+
+    rm -f "$ICU_SRC_FILE"
+fi

data/lib/ffi-icu/collation.rb

@@ -1,6 +1,38 @@
 module ICU
   module Collation
 
+    ATTRIBUTES = {
+        french_collation: 0,
+        alternate_handling: 1,
+        case_first: 2,
+        case_level: 3,
+        normalization_mode: 4,
+        strength: 5,
+        hiragana_quaternary_mode: 6,
+        numeric_collation: 7,
+    }.freeze
+
+    ATTRIBUTE_VALUES = {
+        nil => -1,
+        primary: 0,
+        secondary: 1,
+        default_strength: 2,
+        tertiary: 2,
+        quaternary: 3,
+        identical: 15,
+
+        false => 16,
+        true => 17,
+
+        shifted: 20,
+        non_ignorable: 21,
+
+        lower_first: 24,
+        upper_first: 25,
+    }.freeze
+
+    ATTRIBUTE_VALUES_INVERSE = Hash[ATTRIBUTE_VALUES.map {|k,v| [v, k]}].freeze
+
     def self.collate(locale, arr)
       Collator.new(locale).collate(arr)
     end
@@ -80,10 +112,44 @@ module ICU
       def rules
         @rules ||= begin
           length = FFI::MemoryPointer.new(:int)
-          ptr = ICU::Lib.ucol_getRules(@c, length)
+          ptr = Lib.ucol_getRules(@c, length)
           ptr.read_array_of_uint16(length.read_int).pack("U*")
         end
       end
+
+      def collation_key(string)
+        ptr = UCharPointer.from_string(string)
+        size = Lib.ucol_getSortKey(@c, ptr, string.jlength, nil, 0)
+        buffer = FFI::MemoryPointer.new(:char, size)
+        Lib.ucol_getSortKey(@c, ptr, string.jlength, buffer, size)
+        buffer.read_bytes(size - 1)
+      end
+
+      def [](attribute)
+        ATTRIBUTE_VALUES_INVERSE[Lib.check_error do |error|
+          Lib.ucol_getAttribute(@c, ATTRIBUTES[attribute], error)
+        end]
+      end
+
+      def []=(attribute, value)
+        Lib.check_error do |error|
+          Lib.ucol_setAttribute(@c, ATTRIBUTES[attribute], ATTRIBUTE_VALUES[value], error)
+        end
+        value
+      end
+
+      # create friendly named methods for setting attributes
+      ATTRIBUTES.each_key do |attribute|
+        class_eval <<-CODE
+            def #{attribute}
+              self[:#{attribute}]
+            end
+
+            def #{attribute}=(value)
+              self[:#{attribute}] = value
+            end
+        CODE
+      end
     end # Collator
 
   end # Collate

data/lib/ffi-icu/duration_formatting.rb

@@ -0,0 +1,282 @@
+module ICU
+    module DurationFormatting
+        VALID_FIELDS = %i[
+            years
+            months
+            weeks
+            days
+            hours
+            minutes
+            seconds
+            milliseconds
+            microseconds
+            nanoseconds
+        ]
+        HMS_FIELDS = %i[
+            hours
+            minutes
+            seconds
+            milliseconds
+            microseconds
+            nanoseconds
+        ]
+        ROUNDABLE_FIELDS = %i[
+            seconds
+            milliseconds
+            microseconds
+            nanoseconds
+        ]
+        VALID_STYLES = %i[long short narrow digital]
+        STYLES_TO_LIST_JOIN_FORMAT = {
+            long: :wide,
+            short: :short,
+            narrow: :narrow,
+            digital: :narrow,
+        }
+        UNIT_FORMAT_STRINGS = {
+            years: 'measure-unit/duration-year',
+            months: 'measure-unit/duration-month',
+            weeks: 'measure-unit/duration-week',
+            days: 'measure-unit/duration-day',
+            hours: 'measure-unit/duration-hour',
+            minutes: 'measure-unit/duration-minute',
+            seconds: 'measure-unit/duration-second',
+            milliseconds: 'measure-unit/duration-millisecond',
+            microseconds: 'measure-unit/duration-microsecond',
+            nanoseconds: 'measure-unit/duration-nanosecond',
+        }
+        STYLES_TO_NUMBER_FORMAT_WIDTH = {
+            long: 'unit-width-full-name',
+            short: 'unit-width-short',
+            narrow: 'unit-width-narrow',
+            # digital for hours:minutes:seconds has some special casing.
+            digital: 'unit-width-narrow',
+        }
+
+        def self.format(fields, locale:, style: :long)
+            DurationFormatter.new(locale: locale, style: style).format(fields)
+        end
+
+        class DurationFormatter
+            def initialize(locale:, style: :long)
+                if !Lib.respond_to?(:unumf_openForSkeletonAndLocale) || !Lib.respond_to?(:ulistfmt_openForType)
+                    raise "ICU::DurationFormatting requires ICU >= 67"
+                end
+
+                raise ArgumentError, "Unknown style #{style}" unless VALID_STYLES.include?(style)
+
+                @locale = locale
+                @style = style
+                # These are created lazily based on what parts are actually included
+                @number_formatters = {}
+
+                list_join_format = STYLES_TO_LIST_JOIN_FORMAT.fetch(style)
+                @list_formatter = FFI::AutoPointer.new(
+                    Lib.check_error { |error|
+                        Lib.ulistfmt_openForType(@locale, :units, list_join_format, error)
+                    },
+                    Lib.method(:ulistfmt_close)
+                )
+            end
+
+            def format(fields)
+                fields.each_key do |field|
+                    raise "Unknown field #{field}" unless VALID_FIELDS.include?(field)
+                end
+                fields = fields.dup # we might modify this argument.
+
+                # Intl.js spec says that rounding options affect only the smallest unit, and only
+                # if that unit is sub-second. All other fields therefore need to be truncated.
+                smallest_unit = VALID_FIELDS[fields.keys.map { |k| VALID_FIELDS.index(k) }.max]
+                fields.each_key do |k|
+                    raise ArgumentError, "Negative durations are not yet supported" if fields[k] < 0
+                    fields[k] = fields[k].to_i unless k == smallest_unit && ROUNDABLE_FIELDS.include?(smallest_unit)
+                end
+
+                formatted_hms = nil
+                if @style == :digital
+                    # icu::MeasureFormat contains special casing for hours/minutes/seconds formatted
+                    # at numeric width, to render it as h:mm:s, essentially. This involves using
+                    # a pattern called durationUnits defined in the ICU data for the locale.
+                    # If we have data for this combination of hours/mins/seconds in this locale,
+                    # use that and emulate ICU's special casing.
+                    formatted_hms = format_hms(fields)
+                    if formatted_hms
+                        # We've taken care of all these fields now.
+                        HMS_FIELDS.each do |f|
+                            fields.delete f
+                        end
+                    end
+                end
+
+                formatted_fields = VALID_FIELDS.map do |f|
+                    next unless fields.key?(f)
+                    next unless fields[f] != 0
+
+                    format_number(fields[f], [
+                        UNIT_FORMAT_STRINGS[f], STYLES_TO_NUMBER_FORMAT_WIDTH[@style],
+                        (".#########" if f == smallest_unit),
+                    ].compact.join(' '))
+                end
+                formatted_fields << formatted_hms
+                formatted_fields.compact!
+
+                format_list(formatted_fields)
+            end
+
+            private
+
+            def hms_duration_units_pattern(fields)
+                return nil unless HMS_FIELDS.any? { |k| fields.key?(k) }
+                @unit_res_bundle ||= FFI::AutoPointer.new(
+                    Lib.check_error { |error| Lib.ures_open(Lib.resource_bundle_name(:unit), @locale, error) },
+                    Lib.method(:ures_close)
+                )
+
+                resource_key = "durationUnits/"
+                resource_key << "h" if fields.key?(:hours)
+                resource_key << "m" if fields.key?(:minutes)
+                resource_key << "s" if [:seconds, :milliseconds, :microseconds, :nanoseconds].any? { |f| fields.key?(f) }
+
+                begin
+                    pattern_resource = FFI::AutoPointer.new(
+                        Lib.check_error { |error| Lib.ures_getBykeyWithFallback(@unit_res_bundle, resource_key, nil, error) },
+                        Lib.method(:ures_close)
+                    )
+                rescue MissingResourceError
+                    # This combination of h,m,s not present for this locale.
+                    return nil
+                end
+                # Read the resource as a UChar (whose memory we _do not own_ - it's static data) and
+                # convert it to a Ruby string.
+                pattern_uchar_len = FFI::MemoryPointer.new(:int32_t)
+                pattern_uchar = Lib.check_error { |error|
+                    Lib.ures_getString(pattern_resource, pattern_uchar_len, error)
+                }
+                pattern_str = pattern_uchar.read_array_of_uint16(pattern_uchar_len.read_int32).pack("U*")
+
+                # For some reason I can't comprehend, loadNumericDateFormatterPattern in ICU wants to turn
+                # h's into H's here. I guess we have to do it too because the pattern data could in theory
+                # now contain either.
+                pattern_str.gsub('h', 'H')
+            end
+
+            def format_hms(fields)
+                pattern = hms_duration_units_pattern(fields)
+                return nil if pattern.nil?
+
+                # According to the Intl.js spec, when formatting in digital, everything < seconds
+                # should be coalesced into decimal seconds
+                seconds_incl_fractional = fields.fetch(:seconds, 0)
+                second_precision = 0
+                if fields.key?(:milliseconds)
+                    seconds_incl_fractional += fields[:milliseconds] / 1e3
+                    second_precision = 3
+                end
+                if fields.key?(:microseconds)
+                    seconds_incl_fractional += fields[:microseconds] / 1e6
+                    second_precision = 6
+                end
+                if fields.key?(:nanoseconds)
+                    seconds_incl_fractional += fields[:nanoseconds] / 1e9
+                    second_precision = 9
+                end
+
+                # Follow the rules in ICU measfmt.cpp formatNumeric to fill in the patterns here with
+                # the appropriate values.
+                enum = pattern.each_char
+                protect = false
+                result = ""
+                loop do
+                    char = enum.next
+                    next_char = enum.peek rescue nil
+
+                    if protect
+                        # In literal mode
+                        if char == "'"
+                            protect = false
+                            next
+                        end
+                        result << char
+                        next
+                    end
+
+                    value = case char
+                    when 'H' then fields[:hours]
+                    when 'm' then fields[:minutes]
+                    when 's' then seconds_incl_fractional
+                    end
+
+                    case char
+                    when 'H', 'm', 's'
+                        skeleton = "."
+                        if char == 's' && second_precision > 0
+                            skeleton << ("0" * second_precision)
+                        else
+                            skeleton << ("#" * 9)
+                        end
+                        if char == next_char
+                            # It's doubled - means format it at zero fill
+                            skeleton << " integer-width/00"
+                            enum.next
+                        end
+                        result << format_number(value, skeleton)
+                    when "'"
+                        if next_char == char
+                            # double-apostrophe, means literal '
+                            result << "'"
+                            enum.next
+                        else
+                            protect = true
+                        end
+                    else
+                        result << char
+                    end
+                end
+
+                result
+            end
+
+            def number_formatter(skeleton)
+                @number_formatters[skeleton] ||= begin
+                    skeleton_uchar = UCharPointer.from_string(skeleton)
+                    FFI::AutoPointer.new(
+                        Lib.check_error { |error|
+                            Lib.unumf_openForSkeletonAndLocale(skeleton_uchar, skeleton_uchar.length_in_uchars, @locale, error)
+                        },
+                        Lib.method(:unumf_close)
+                    )
+                end
+            end
+
+            def format_number(value, skeleton)
+                formatter = number_formatter(skeleton)
+                result = FFI::AutoPointer.new(
+                    Lib.check_error { |error| Lib.unumf_openResult(error) },
+                    Lib.method(:unumf_closeResult)
+                )
+                value_str = value.to_s
+                Lib.check_error do |error|
+                    Lib.unumf_formatDecimal(formatter, value_str, value_str.size, result, error)
+                end
+                Lib::Util.read_uchar_buffer(0) do |buf, error|
+                    Lib.unumf_resultToString(result, buf, buf.length_in_uchars, error)
+                end
+            end
+
+            def format_list(values)
+                value_uchars = values.map(&UCharPointer.method(:from_string))
+                value_uchars_array = FFI::MemoryPointer.new(:pointer, value_uchars.size)
+                value_uchars_array.put_array_of_pointer(0, value_uchars)
+                value_lengths_array = FFI::MemoryPointer.new(:int32_t, value_uchars.size)
+                value_lengths_array.put_array_of_int32(0, value_uchars.map(&:length_in_uchars))
+                Lib::Util.read_uchar_buffer(0) do |buf, error|
+                    Lib.ulistfmt_format(
+                        @list_formatter, value_uchars_array, value_lengths_array,
+                        value_uchars.size, buf, buf.length_in_uchars, error
+                    )
+                end
+            end
+        end
+    end
+end

data/lib/ffi-icu/lib.rb

@@ -5,6 +5,9 @@ module ICU
   class BufferOverflowError < StandardError
   end
 
+  class MissingResourceError < StandardError
+  end
+
   module Lib
     extend FFI::Library
 
@@ -129,6 +132,8 @@ module ICU
         name = Lib.u_errorName error_code
         if name == "U_BUFFER_OVERFLOW_ERROR"
           raise BufferOverflowError
+        elsif name == "U_MISSING_RESOURCE_ERROR"
+          raise MissingResourceError
         else
           raise Error, name
         end
@@ -192,6 +197,11 @@ module ICU
       @version ||= VersionInfo.new.tap { |version| u_getVersion(version) }
     end
 
+    def self.attach_optional_function(*args)
+      attach_function *args
+    rescue FFI::NotFoundError
+    end
+
     version = load_icu
     suffix = figure_suffix(version)
 
@@ -297,6 +307,10 @@ module ICU
     attach_function :ucol_greaterOrEqual,   "ucol_greaterOrEqual#{suffix}",   [:pointer,   :pointer,  :int32_t,  :pointer, :int32_t], :bool
     attach_function :ucol_equal,            "ucol_equal#{suffix}",            [:pointer,   :pointer,  :int32_t,  :pointer, :int32_t], :bool
     attach_function :ucol_getRules,         "ucol_getRules#{suffix}",         [:pointer,   :pointer], :pointer
+    attach_function :ucol_getSortKey,       "ucol_getSortKey#{suffix}",       [:pointer, :pointer, :int, :pointer, :int], :int
+    attach_function :ucol_getAttribute,     "ucol_getAttribute#{suffix}",     [:pointer, :int, :pointer], :int
+    attach_function :ucol_setAttribute,     "ucol_setAttribute#{suffix}",     [:pointer, :int, :int, :pointer], :void
+
 
     # Transliteration
     #
@@ -419,12 +433,45 @@ module ICU
     attach_function :unum_format_int32, "unum_format#{suffix}", [:pointer, :int32_t, :pointer, :int32_t, :pointer, :pointer], :int32_t
     attach_function :unum_format_int64, "unum_formatInt64#{suffix}", [:pointer, :int64_t, :pointer, :int32_t, :pointer, :pointer], :int32_t
     attach_function :unum_format_double, "unum_formatDouble#{suffix}", [:pointer, :double, :pointer, :int32_t, :pointer, :pointer], :int32_t
-    begin
-      attach_function :unum_format_decimal, "unum_formatDecimal#{suffix}", [:pointer, :string, :int32_t, :pointer, :int32_t, :pointer, :pointer], :int32_t
-    rescue FFI::NotFoundError
-    end
+    attach_optional_function :unum_format_decimal, "unum_formatDecimal#{suffix}", [:pointer, :string, :int32_t, :pointer, :int32_t, :pointer, :pointer], :int32_t
     attach_function :unum_format_currency, "unum_formatDoubleCurrency#{suffix}", [:pointer, :double, :pointer, :pointer, :int32_t, :pointer, :pointer], :int32_t
     attach_function :unum_set_attribute, "unum_setAttribute#{suffix}", [:pointer, :number_format_attribute, :int32_t], :void
+
+    # UResourceBundle
+    attach_function :ures_open, "ures_open#{suffix}", [:string, :string, :pointer], :pointer
+    attach_function :ures_close, "ures_close#{suffix}", [:pointer], :void
+    # This function is marked "internal" but it's fully exported by the library ABI, so we can use it anyway.
+    attach_function :ures_getBykeyWithFallback, "ures_getByKeyWithFallback#{suffix}", [:pointer, :string, :pointer, :pointer], :pointer
+    attach_function :ures_getString, "ures_getString#{suffix}", [:pointer, :pointer, :pointer], :pointer
+
+    def self.resource_bundle_name(type)
+      stem = "icudt" + version.read_array_of_char(4)[0].to_s + "l" + "-"
+      stem + type.to_s
+    end
+
+    # UNumberFormatter
+    attach_optional_function :unumf_openForSkeletonAndLocale, "unumf_openForSkeletonAndLocale#{suffix}", [:pointer, :int32_t, :string, :pointer], :pointer
+    attach_optional_function :unumf_close, "unumf_close#{suffix}", [:pointer], :void
+    attach_optional_function :unumf_openResult, "unumf_openResult#{suffix}", [:pointer], :pointer
+    attach_optional_function :unumf_closeResult, "unumf_closeResult#{suffix}", [:pointer], :void
+    attach_optional_function :unumf_formatDecimal, "unumf_formatDecimal#{suffix}", [:pointer, :string, :int32_t, :pointer, :pointer], :void
+    attach_optional_function :unumf_resultToString, "unumf_resultToString#{suffix}", [:pointer, :pointer, :int32_t, :pointer], :int32_t
+
+    # UListFormatter
+    enum :ulistfmt_type, [
+      :and, 0,
+      :or, 1,
+      :units, 2,
+    ]
+    enum :ulistfmt_width, [
+      :wide, 0,
+      :short, 1,
+      :narrow, 2,
+    ]
+    attach_optional_function :ulistfmt_openForType, "ulistfmt_openForType#{suffix}", [:string, :ulistfmt_type, :ulistfmt_width, :pointer], :pointer
+    attach_optional_function :ulistfmt_close, "ulistfmt_close#{suffix}", [:pointer], :void
+    attach_optional_function :ulistfmt_format, "ulistfmt_format#{suffix}", [:pointer, :pointer, :pointer, :int32_t, :pointer, :int32_t, :pointer], :int32_t
+
     # date
     enum :date_format_style, [
       :pattern, -2,

data/lib/ffi-icu/time_formatting.rb

@@ -254,7 +254,10 @@ module ICU
 
         # 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'
+          # Only actually append 'am/pm' if there is an hour in the format string
+          if skeleton_str =~ /[hHkKjJ]/ && !skeleton_str.include?('a')
+            skeleton_str << 'a'
+          end
         else
           skeleton_str.gsub!('a', '')
         end

data/lib/ffi-icu/version.rb

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

data/lib/ffi-icu.rb

@@ -33,3 +33,4 @@ require "ffi-icu/normalizer"
 require "ffi-icu/break_iterator"
 require "ffi-icu/number_formatting"
 require "ffi-icu/time_formatting"
+require "ffi-icu/duration_formatting"

data/spec/collation_spec.rb

@@ -58,6 +58,27 @@ module ICU
         expect(collator.rules).to include('ö<<<Ö')
       end
 
+      it "returns usable collation keys" do
+        collator.collation_key("abc").should be < collator.collation_key("xyz")
+      end
+
+      context "attributes" do
+        it "can set and get normalization_mode" do
+          collator.normalization_mode = true
+          collator.normalization_mode.should be true
+
+          collator[:normalization_mode].should be true
+          collator[:normalization_mode] = false
+          collator.normalization_mode.should be false
+
+          collator.case_first.should be false
+          collator.case_first = :lower_first
+          collator.case_first.should == :lower_first
+
+          collator.strength = :tertiary
+          collator.strength.should == :tertiary
+        end
+      end
     end
   end # Collate
 end # ICU

data/spec/duration_formatting_spec.rb

@@ -0,0 +1,143 @@
+module ICU
+    module DurationFormatting
+        describe 'DurationFormatting::format' do
+            before(:each) do
+                skip("Only works on ICU >= 67") if Lib.version.to_a[0] < 67
+              end
+
+            it 'produces hours, minutes, and seconds in order' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'C', style: :long)
+                expect(result).to match(/1.*hour.*2.*minute.*3.*second/i)
+            end
+
+            it 'rounds down fractional seconds < 0.5' do
+                result = DurationFormatting.format({seconds: 5.4}, locale: 'C', style: :long)
+                expect(result).to match(/5.*second/i)
+            end
+
+            it 'rounds up fractional seconds > 0.5' do
+                result = DurationFormatting.format({seconds: 5.6}, locale: 'C', style: :long)
+                expect(result).to match(/6.*second/i)
+            end
+
+            it 'trims off leading zero values' do
+                result = DurationFormatting.format({hours: 0, minutes: 1, seconds: 30}, locale: 'C', style: :long)
+                expect(result).to match(/1.*minute.*30.*second/i)
+                expect(result).to_not match(/hour/i)
+            end
+
+            it 'trims off leading missing values' do
+                result = DurationFormatting.format({minutes: 1, seconds: 30}, locale: 'C', style: :long)
+                expect(result).to match(/1.*minute.*30.*second/i)
+                expect(result).to_not match(/hour/i)
+            end
+
+            it 'trims off non-leading zero values' do
+                result = DurationFormatting.format({hours: 1, minutes: 0, seconds: 10}, locale: 'C', style: :long)
+                expect(result).to match(/1.*hour.*10.*second/i)
+                expect(result).to_not match(/minute/i)
+            end
+
+            it 'trims off non-leading missing values' do
+                result = DurationFormatting.format({hours: 1, seconds: 10}, locale: 'C', style: :long)
+                expect(result).to match(/1.*hour.*10.*second/i)
+                expect(result).to_not match(/minute/i)
+            end
+
+            it 'uses comma-based number formatting as appropriate for locale' do
+                result = DurationFormatting.format({seconds: 90123}, locale: 'en-AU', style: :long)
+                expect(result).to match(/90,123.*second/i)
+                expect(result).to_not match(/hour/i)
+                expect(result).to_not match(/minute/i)
+            end
+
+            it 'localizes unit names' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'el', style: :long)
+                expect(result).to match(/1.*ώρα.*2.*λεπτά.*3.*δευτερόλεπτα/i)
+            end
+
+            it 'can format long' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :long)
+                expect(result).to match(/hour.*minute.*second/i)
+            end
+
+            it 'can format short' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :short)
+                expect(result).to match(/hr.*min.*sec/i)
+                expect(result).to_not match(/hour/i)
+                expect(result).to_not match(/minute/i)
+                expect(result).to_not match(/second/i)
+            end
+
+            it 'can format narrow' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :narrow)
+                expect(result).to match(/h.*min.*s/i)
+                expect(result).to_not match(/hr/i)
+                expect(result).to_not match(/sec/i)
+            end
+
+            it 'can format digital' do
+                result = DurationFormatting.format({hours: 1, minutes: 2, seconds: 3}, locale: 'en-AU', style: :digital)
+                expect(result).to eql('1:02:03')
+            end
+
+            it 'can format the full sequence of time units in order' do
+                duration = {
+                    years: 1,
+                    months: 2,
+                    weeks: 3,
+                    days: 4,
+                    hours: 5,
+                    minutes: 6,
+                    seconds: 7,
+                    milliseconds: 8,
+                    microseconds: 9,
+                    nanoseconds: 10,
+                }
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
+                expect(result).to match(/1.yr.*2.*mths.*3.*wks.*4.*days.*5.*hrs.*6.*mins.*7.*secs.*8.*ms.*9.*μs.*10.*ns/)
+            end
+
+            it 'joins ms, us, ns values to seconds in digital format' do
+                duration = {minutes: 10, seconds: 5, milliseconds: 325, microseconds: 53, nanoseconds: 236}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
+                expect(result).to eql('10:05.325053236')
+            end
+
+            it 'includes trailing zeros as appropriate for the last unit in digital format' do
+                duration = {minutes: 10, seconds: 5, milliseconds: 325, microseconds: 400}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
+                expect(result).to eql('10:05.325400')
+            end
+
+            it 'joins h:mm:ss and other units in digital format' do
+                duration = {days: 8, hours: 23, minutes: 10, seconds: 9}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :digital)
+                expect(result).to match(/8.*d.*23:10:09/  )
+            end
+
+            it 'ignores all decimal parts except the last, if it is seconds' do
+                duration = {hours: 7.3, minutes: 9.7, seconds: 8.93}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
+                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min.*8\.93[^0-9]*secs/)
+            end
+
+            it 'ignores all decimal parts except the last, if it is milliseconds' do
+                duration = {hours: 7.3, minutes: 9.7, seconds: 8.93, milliseconds: 632.2}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
+                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min.*8[^0-9]*secs.*632\.2[^0-9]*ms/)
+            end
+
+            it 'ignores all decimal parts including the last, if it is > seconds' do
+                duration = {hours: 7.3, minutes: 9.7}
+                result = DurationFormatting.format(duration, locale: 'en-AU', style: :short)
+                expect(result).to match(/7[^0-9]*hrs.*9[^0-9]*min/)
+            end
+
+            it 'raises on durations with any negative component' do
+                duration = {hours: 7.3, minutes: -9.7}
+                expect { DurationFormatting.format(duration, locale: 'en-AU') }.to raise_error(ArgumentError)
+            end
+        end
+    end
+end

data/spec/time_spec.rb

@@ -128,6 +128,12 @@ module ICU
               expect(str).to_not match(/(am|pm)/i)
             end
 
+            it 'does not include am/pm if time is not requested' do
+              t = Time.new(2021, 04, 01, 00, 05, 0, "+00:00")
+              str = TimeFormatting.format(t, time: :none, date: :short, locale: locale_name, zone: 'UTC', hour_cycle: 'h12')
+              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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-icu
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Jari Bakken
@@ -77,12 +77,14 @@ files:
 - Rakefile
 - benchmark/detect.rb
 - benchmark/shared.rb
+- build_icu.sh
 - ffi-icu.gemspec
 - lib/ffi-icu.rb
 - lib/ffi-icu/break_iterator.rb
 - lib/ffi-icu/chardet.rb
 - lib/ffi-icu/collation.rb
 - lib/ffi-icu/core_ext/string.rb
+- lib/ffi-icu/duration_formatting.rb
 - lib/ffi-icu/lib.rb
 - lib/ffi-icu/lib/util.rb
 - lib/ffi-icu/locale.rb
@@ -96,6 +98,7 @@ files:
 - spec/break_iterator_spec.rb
 - spec/chardet_spec.rb
 - spec/collation_spec.rb
+- spec/duration_formatting_spec.rb
 - spec/lib/version_info_spec.rb
 - spec/lib_spec.rb
 - spec/locale_spec.rb
@@ -127,21 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Simple Ruby FFI wrappers for things I need from ICU.
-test_files:
-- spec/break_iterator_spec.rb
-- spec/chardet_spec.rb
-- spec/collation_spec.rb
-- spec/lib/version_info_spec.rb
-- spec/lib_spec.rb
-- spec/locale_spec.rb
-- spec/normalization_spec.rb
-- spec/normalizer_spec.rb
-- spec/number_formatting_spec.rb
-- spec/spec_helper.rb
-- spec/time_spec.rb
-- spec/transliteration_spec.rb
-- spec/uchar_spec.rb
+test_files: []