ffi-icu 0.6.1 → 0.8.0

data/lib/ffi-icu/collation.rb

@@ -72,21 +72,15 @@ module ICU
       end
 
       def compare(a, b)
-        Lib.ucol_strcoll(
-          @c,
-          UCharPointer.from_string(a), a.size,
-          UCharPointer.from_string(b), b.size
-        )
+        Lib.ucol_strcoll(@c, *collation_arguments(a, b))
       end
 
       def greater?(a, b)
-        Lib.ucol_greater(@c, UCharPointer.from_string(a), a.size,
-                         UCharPointer.from_string(b), b.size)
+        Lib.ucol_greater(@c, *collation_arguments(a, b))
       end
 
       def greater_or_equal?(a, b)
-        Lib.ucol_greaterOrEqual(@c, UCharPointer.from_string(a), a.size,
-                                UCharPointer.from_string(b), b.size)
+        Lib.ucol_greaterOrEqual(@c, *collation_arguments(a, b))
       end
 
       def equal?(*args)
@@ -96,8 +90,7 @@ module ICU
 
         a, b = args
 
-        Lib.ucol_equal(@c, UCharPointer.from_string(a), a.size,
-                       UCharPointer.from_string(b), b.size)
+        Lib.ucol_equal(@c, *collation_arguments(a, b))
       end
 
       def collate(sortable)
@@ -110,15 +103,16 @@ module ICU
         @rules ||= begin
           length = FFI::MemoryPointer.new(:int)
           ptr = Lib.ucol_getRules(@c, length)
-          ptr.read_array_of_uint16(length.read_int).pack('U*')
+          ptr.read_array_of_uint16(length.read_int).
+            pack('v*').force_encoding('UTF-16LE').encode('UTF-8')
         end
       end
 
       def collation_key(string)
-        ptr = UCharPointer.from_string(string)
-        size = Lib.ucol_getSortKey(@c, ptr, string.size, nil, 0)
+        ptr = UCharPointer.from_utf8(string)
+        size = Lib.ucol_getSortKey(@c, ptr, ptr.length_in_uchars, nil, 0)
         buffer = FFI::MemoryPointer.new(:char, size)
-        Lib.ucol_getSortKey(@c, ptr, string.size, buffer, size)
+        Lib.ucol_getSortKey(@c, ptr, ptr.length_in_uchars, buffer, size)
         buffer.read_bytes(size - 1)
       end
 
@@ -134,6 +128,17 @@ module ICU
         end
       end
 
+      def collation_arguments(left, right)
+        left_text = UCharPointer.from_utf8(left)
+        right_text = UCharPointer.from_utf8(right)
+
+        [
+          left_text, left_text.length_in_uchars,
+          right_text, right_text.length_in_uchars
+        ]
+      end
+      private :collation_arguments
+
       # create friendly named methods for setting attributes
       ATTRIBUTES.each_key do |attribute|
         class_eval <<-CODE, __FILE__, __LINE__ + 1

data/lib/ffi-icu/currency.rb

@@ -0,0 +1,123 @@
+module ICU
+  class Currency
+    CURRENCY_TYPE_COMMON         = 1
+    CURRENCY_TYPE_UNCOMMON       = 2
+    CURRENCY_TYPE_DEPRECATED     = 4
+    CURRENCY_TYPE_NON_DEPRECATED = 8
+    CURRENCY_TYPE_ALL = (2**31) - 1
+
+    class << self
+      # Returns the default currency code for a locale, e.g. "USD" for "en_US"
+      def for_locale(locale)
+        ptr = UCharPointer.new(4)
+        length = Lib.check_error do |status|
+          Lib.ucurr_forLocale(locale.to_s, ptr, 4, status)
+        end
+        ptr.utf8_string(length)
+      end
+
+      # Returns an array of ISO 4217 currency code strings.
+      # currency_type: :all (default), :common, :uncommon, :deprecated, :non_deprecated
+      def available(currency_type = :all)
+        flag = case currency_type
+               when :common         then CURRENCY_TYPE_COMMON
+               when :uncommon       then CURRENCY_TYPE_UNCOMMON
+               when :deprecated     then CURRENCY_TYPE_DEPRECATED
+               when :non_deprecated then CURRENCY_TYPE_NON_DEPRECATED
+               else CURRENCY_TYPE_ALL
+               end
+
+        enum_ptr = Lib.check_error { |status| Lib.ucurr_openISOCurrencies(flag, status) }
+        begin
+          Lib.enum_ptr_to_array(enum_ptr)
+        ensure
+          Lib.uenum_close(enum_ptr)
+        end
+      end
+
+      # Convenience: ICU::Currency.symbol('USD', 'en_US') => "$"
+      def symbol(code, locale)
+        new(code).symbol(locale)
+      end
+
+      # Convenience: ICU::Currency.name('USD', 'en') => "US Dollar"
+      def name(code, locale)
+        new(code).name(locale)
+      end
+    end
+
+    attr_reader :code
+
+    def initialize(code)
+      @code = code.to_s.upcase
+    end
+
+    # Currency symbol for the given locale, e.g. "$", "€"
+    def symbol(locale)
+      get_name(locale, :symbol_name)
+    end
+
+    # Narrow (shortest unambiguous) symbol. Requires ICU >= 61.
+    def narrow_symbol(locale)
+      raise('narrow_symbol requires ICU >= 61') if Lib.version.to_a.first < 61
+
+      get_name(locale, :narrow_symbol_name)
+    end
+
+    # Long display name for the given locale, e.g. "US Dollar"
+    def name(locale)
+      get_name(locale, :long_name)
+    end
+
+    # Plural form of the currency name.
+    # plural_count: "zero", "one", "two", "few", "many", "other"
+    def plural_name(locale, plural_count = 'other')
+      raise('plural_name requires ICU >= 4.2') unless Lib.respond_to?(:ucurr_getPluralName)
+
+      is_choice = FFI::MemoryPointer.new(:uint8)
+      len       = FFI::MemoryPointer.new(:int32_t)
+
+      ptr = Lib.check_error do |status|
+        Lib.ucurr_getPluralName(currency_uchar, locale.to_s, is_choice, plural_count.to_s, len, status)
+      end
+      ptr.read_array_of_uint16(len.read_int32).pack('U*')
+    end
+
+    # Number of decimal digits used when displaying this currency.
+    # usage: :standard (default) or :cash
+    def fraction_digits(usage = :standard)
+      if usage == :cash && Lib.respond_to?(:ucurr_getDefaultFractionDigitsForUsage)
+        Lib.check_error { |status| Lib.ucurr_getDefaultFractionDigitsForUsage(currency_uchar, :cash, status) }
+      else
+        Lib.check_error { |status| Lib.ucurr_getDefaultFractionDigits(currency_uchar, status) }
+      end
+    end
+
+    # ISO 4217 numeric code, e.g. 840 for USD. Requires ICU >= 49.
+    def numeric_code
+      raise('numeric_code requires ICU >= 49') unless Lib.respond_to?(:ucurr_getNumericCode)
+
+      Lib.ucurr_getNumericCode(currency_uchar)
+    end
+
+    def to_s
+      @code
+    end
+
+    private
+
+    def currency_uchar
+      UCharPointer.from_utf8(@code, 4)
+    end
+
+    def get_name(locale, style)
+      is_choice = FFI::MemoryPointer.new(:uint8)
+      len       = FFI::MemoryPointer.new(:int32_t)
+
+      ptr = Lib.check_error do |status|
+        Lib.ucurr_getName(currency_uchar, locale.to_s, style, is_choice, len, status)
+      end
+      ptr.read_array_of_uint16(len.read_int32).pack('U*')
+    end
+  end
+end

data/lib/ffi-icu/duration_formatting.rb

@@ -262,36 +262,12 @@ module ICU
         result.string
       end
 
-      def number_formatter(skeleton)
-        @number_formatters[skeleton] ||= begin
-          skeleton_uchar = UCharPointer.from_string(skeleton)
-          FFI::AutoPointer.new(
-            Lib.check_error do |error|
-              Lib.unumf_openForSkeletonAndLocale(skeleton_uchar, skeleton_uchar.length_in_uchars,
-                                                 @locale, error)
-            end,
-            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
+        (@number_formatters[skeleton] ||= NumberFormatting::SkeletonFormatter.new(@locale, skeleton)).format(value)
       end
 
       def format_list(values)
-        value_uchars = values.map(&UCharPointer.method(:from_string))
+        value_uchars = values.map(&UCharPointer.method(:from_utf8))
         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)

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

@@ -32,7 +32,7 @@ module ICU
 
       def self.read_uchar_buffer(length, &)
         buf, len = read_uchar_buffer_as_ptr_impl(length, &)
-        buf.string(len)
+        buf.utf8_string(len)
       end
 
       def self.read_uchar_buffer_as_ptr(length, &)

data/lib/ffi-icu/lib.rb

@@ -19,18 +19,23 @@ module ICU
                         elsif FFI::Platform::IS_WINDOWS
                           ENV['PATH'].split(File::PATH_SEPARATOR)
                         else
+                          multiarch_paths = Dir['/usr/lib/*-linux-gnu']
+                          multiarch_paths.sort_by! do |path|
+                            File.basename(path).start_with?("#{FFI::Platform::ARCH}-") ? 0 : 1
+                          end
+
                           [
                             '/usr/local/{lib64,lib}',
                             '/opt/local/{lib64,lib}',
                             '/usr/{lib64,lib}'
-                          ] + Dir['/usr/lib/*-linux-gnu'] # for Debian Multiarch http://wiki.debian.org/Multiarch
+                          ] + multiarch_paths # for Debian Multiarch http://wiki.debian.org/Multiarch
                         end
     end
 
     def self.find_lib(lib)
-      Dir.glob(search_paths.map do |path|
-        File.expand_path(File.join(path, lib))
-      end).first
+      search_paths.lazy.filter_map do |path|
+        Dir.glob(File.expand_path(File.join(path, lib))).first
+      end.first
     end
 
     def self.load_icu
@@ -120,6 +125,7 @@ module ICU
 
     def self.check_error
       ptr = FFI::MemoryPointer.new(:int)
+      ptr.write_int(0)
       ret = yield(ptr)
       error_code = ptr.read_int
 
@@ -203,6 +209,10 @@ module ICU
 
     typedef VersionInfo, :version
 
+    attach_function :u_getVersion,      "u_getVersion#{suffix}",      [:version], :void
+    attach_function :u_versionToString, "u_versionToString#{suffix}", [:version, :pointer], :void
+    version ||= self.version.to_s
+
     attach_function :u_errorName,     "u_errorName#{suffix}",     [:int], :string
     attach_function :uenum_count,     "uenum_count#{suffix}",     [:pointer, :pointer], :int
     attach_function :uenum_close,     "uenum_close#{suffix}",     [:pointer], :void
@@ -210,9 +220,6 @@ module ICU
     attach_function :u_charsToUChars, "u_charsToUChars#{suffix}", [:string, :pointer, :int32_t], :void
     attach_function :u_UCharsToChars, "u_UCharsToChars#{suffix}", [:pointer, :string, :int32_t], :void
 
-    attach_function :u_getVersion,      "u_getVersion#{suffix}",      [:version], :void
-    attach_function :u_versionToString, "u_versionToString#{suffix}", [:version, :pointer], :void
-
     #
     # Locale
     #
@@ -345,16 +352,51 @@ module ICU
     attach_function :ucol_getAttribute,     "ucol_getAttribute#{suffix}",     [:pointer, :int, :pointer], :int
     attach_function :ucol_setAttribute,     "ucol_setAttribute#{suffix}",     [:pointer, :int, :int, :pointer], :void
 
+    # Currency
+    #
+    # https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/ucurr_8h.html
+    #
+
+    enum :ucurr_name_style, [
+      :symbol_name,         0,   # "$"
+      :long_name,           1,   # "US Dollar"
+      :narrow_symbol_name,  4,   # shortest unambiguous symbol (ICU >= 61)
+      :formal_symbol_name,  5,   # banking context (ICU >= 68)
+      :variant_symbol_name, 6    # regional variant (ICU >= 68)
+    ]
+
+    enum :ucurrency_usage, [
+      :standard, 0,  # UCURR_USAGE_STANDARD
+      :cash,     1   # UCURR_USAGE_CASH
+    ]
+
+    attach_function :ucurr_getName, "ucurr_getName#{suffix}",
+                    [:pointer, :string, :ucurr_name_style, :pointer, :pointer, :pointer], :pointer
+    attach_optional_function :ucurr_getPluralName, "ucurr_getPluralName#{suffix}",
+                             [:pointer, :string, :pointer, :string, :pointer, :pointer], :pointer
+    attach_function :ucurr_forLocale, "ucurr_forLocale#{suffix}",
+                    [:string, :pointer, :int32_t, :pointer], :int32_t
+    attach_function :ucurr_openISOCurrencies, "ucurr_openISOCurrencies#{suffix}",
+                    [:uint32, :pointer], :pointer
+    attach_function :ucurr_getDefaultFractionDigits, "ucurr_getDefaultFractionDigits#{suffix}",
+                    [:pointer, :pointer], :int32_t
+    attach_optional_function :ucurr_getDefaultFractionDigitsForUsage, "ucurr_getDefaultFractionDigitsForUsage#{suffix}",
+                             [:pointer, :ucurrency_usage, :pointer], :int32_t
+    attach_optional_function :ucurr_getNumericCode, "ucurr_getNumericCode#{suffix}",
+                             [:pointer], :int32_t
+
     # Transliteration
     #
     # http://icu-project.org/apiref/icu4c/utrans_8h.html
     #
 
     class UParseError < FFI::Struct
+      U_PARSE_CONTEXT_LEN = 16
+
       layout :line, :int32_t,
              :offset,       :int32_t,
-             :pre_context,  :pointer,
-             :post_context, :pointer
+             :pre_context,  [:uint16, U_PARSE_CONTEXT_LEN],
+             :post_context, [:uint16, U_PARSE_CONTEXT_LEN]
 
       def to_s
         format('#<%<class>s:%<hash>x line: %<line>d offset: %<offset>d',
@@ -362,6 +404,17 @@ module ICU
       end
     end
 
+    # MessageFormat
+    #
+    # https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/umsg_8h.html
+    #
+
+    attach_function :umsg_open, "umsg_open#{suffix}",
+                    [:pointer, :int32_t, :string, :pointer, :pointer], :pointer
+    attach_function :umsg_close, "umsg_close#{suffix}", [:pointer], :void
+    attach_function :umsg_format, "umsg_format#{suffix}",
+                    [:pointer, :pointer, :int32_t, :pointer, :varargs], :int32_t
+
     class UTransPosition < FFI::Struct
       layout :context_start, :int32_t,
              :context_limit, :int32_t,
@@ -444,22 +497,27 @@ module ICU
     attach_function :ubrk_following,      "ubrk_following#{suffix}",      [:pointer, :int32_t], :int32_t
     attach_function :ubrk_isBoundary,     "ubrk_isBoundary#{suffix}",     [:pointer, :int32_t], :int32_t
 
+    # UNUM_FORMAT_STYLE_COUNT is deprecated: "The numeric value may change over time, see ICU ticket #12420."
     enum :number_format_style, [
-      :pattern_decimal,
-      :decimal,
-      :currency,
-      :percent,
-      :scientific,
-      :spellout,
-      :ordinal,
-      :duration,
-      :numbering_system,
-      :pattern_rule_based,
-      :currency_iso,
-      :currency_plural,
-      :format_style_count,
-      :default,
-      :ignore
+      :pattern_decimal, 0,
+      :decimal, 1,
+      :currency, 2,
+      :percent, 3,
+      :scientific, 4,
+      :spellout, 5,
+      :ordinal, 6,
+      :duration, 7,
+      :numbering_system, 8,
+      :pattern_rule_based, 9,
+      :currency_iso, 10,
+      :currency_plural, 11,
+      :currency_accounting, 12,
+      :cash_currency, 13,
+      :decimal_compact_short, 14,
+      :decimal_compact_long, 15,
+      :currency_standard, 16,
+      :default, 1, # UNUM_DEFAULT = UNUM_DECIMAL
+      :ignore, 0 # UNUM_IGNORE = UNUM_PATTERN_DECIMAL
     ]
     enum :number_format_attribute, [
       :parse_int_only, :grouping_used, :decimal_always_show, :max_integer_digits, :min_integer_digits, :integer_digits,

data/lib/ffi-icu/list_formatting.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ICU
+  module ListFormatting
+    VALID_STYLES = [:and, :or, :unit].freeze
+
+    STYLES_TO_TYPES = {
+      and: :and,
+      or: :or,
+      unit: :units
+    }.freeze
+
+    def self.format(items, locale:, style: :and)
+      raise(ArgumentError, "Unknown style #{style}") unless VALID_STYLES.include?(style)
+      raise(ArgumentError, 'items must be strings') unless items.all?(String)
+
+      return '' if items.empty?
+
+      unless Lib.respond_to?(:ulistfmt_openForType) &&
+             Lib.respond_to?(:ulistfmt_close) &&
+             Lib.respond_to?(:ulistfmt_format)
+        raise('ICU::ListFormatting requires ICU >= 67')
+      end
+
+      formatter = Lib.check_error do |error|
+        Lib.ulistfmt_openForType(locale, STYLES_TO_TYPES.fetch(style), :wide, error)
+      end
+
+      begin
+        value_uchars = items.map { |item| UCharPointer.from_utf8(item) }
+        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 |buffer, error|
+          Lib.ulistfmt_format(
+            formatter,
+            value_uchars_array,
+            value_lengths_array,
+            value_uchars.size,
+            buffer,
+            buffer.length_in_uchars,
+            error
+          )
+        end
+      ensure
+        Lib.ulistfmt_close(formatter)
+      end
+    end
+  end
+end

data/lib/ffi-icu/locale.rb

@@ -45,6 +45,7 @@ module ICU
     attr_reader :id
 
     DISPLAY_CONTEXT = {
+      dialect_names: 1, # UDISPCTX_DIALECT_NAMES = (UDISPCTX_TYPE_DIALECT_HANDLING<<8) + 1
       length_full: 512, # UDISPCTX_LENGTH_FULL  = (UDISPCTX_TYPE_DISPLAY_LENGTH<<8) + 0
       length_short: 513 # UDISPCTX_LENGTH_SHORT = (UDISPCTX_TYPE_DISPLAY_LENGTH<<8) + 1
     }.freeze

data/lib/ffi-icu/message_formatting.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module ICU
+  module MessageFormatting
+    class MessageFormatError < ICU::Error
+    end
+
+    class InvalidPatternError < MessageFormatError
+      attr_reader :locale, :pattern, :parse_error
+
+      def initialize(message, locale:, pattern:, parse_error:)
+        super(message)
+        @locale = locale
+        @pattern = pattern
+        @parse_error = parse_error
+      end
+
+      def offset
+        parse_error[:offset]
+      end
+
+      def line
+        parse_error[:line]
+      end
+    end
+
+    def self.create(pattern, locale:)
+      Formatter.new(pattern, locale:)
+    end
+
+    def self.format(pattern, locale:, arguments:)
+      create(pattern, locale:).format(arguments)
+    end
+
+    # Raises on invalid patterns; use valid? for a predicate.
+    def self.validate(pattern, locale:) # rubocop:disable Naming/PredicateMethod
+      create(pattern, locale:)
+      true
+    end
+
+    def self.valid?(pattern, locale:)
+      validate(pattern, locale:)
+    rescue InvalidPatternError
+      false
+    end
+
+    class Formatter
+      attr_reader :locale, :pattern
+
+      def initialize(pattern, locale:)
+        @pattern = String(pattern)
+        @locale = String(locale)
+        @pattern_pointer = UCharPointer.from_utf8(@pattern)
+        @formatter = open_formatter
+      end
+
+      def format(arguments = [])
+        validate_argument_count!(arguments)
+        typed_arguments = typed_arguments_for(arguments)
+        validate_argument_types!(arguments)
+
+        result = Lib::Util.read_uchar_buffer_as_ptr(0) do |result, status|
+          Lib.umsg_format(
+            @formatter,
+            result,
+            result.length_in_uchars,
+            status,
+            *typed_arguments
+          )
+        end
+        result.utf8_string
+      rescue ICU::Error => e
+        raise MessageFormatError, "could not format message: #{e.message}"
+      end
+
+      private
+
+      def open_formatter
+        parse_error = Lib::UParseError.new
+        status = FFI::MemoryPointer.new(:int32_t)
+        status.write_int32(0)
+        pointer = Lib.umsg_open(
+          @pattern_pointer,
+          @pattern_pointer.length_in_uchars,
+          @locale,
+          parse_error,
+          status
+        )
+
+        error_code = status.read_int32
+        return FFI::AutoPointer.new(pointer, Lib.method(:umsg_close)) unless error_code.positive?
+
+        raise InvalidPatternError.new(
+          "invalid message pattern: #{Lib.u_errorName(error_code)} " \
+          "at line #{parse_error[:line]}, offset #{parse_error[:offset]}",
+          locale: @locale,
+          pattern: @pattern,
+          parse_error: parse_error
+        )
+      end
+
+      def typed_arguments_for(arguments)
+        unless arguments.is_a?(Array)
+          raise ArgumentError, 'MessageFormat arguments must be provided as an Array of numbered values'
+        end
+
+        arguments.flat_map do |argument|
+          case argument
+          when String
+            [:pointer, null_terminated_uchar_pointer(argument)]
+          when Integer, Float, BigDecimal
+            [:double, argument.to_f]
+          else
+            raise ArgumentError, "unsupported MessageFormat argument type: #{argument.class}"
+          end
+        end
+      end
+
+      def validate_argument_count!(arguments)
+        unless arguments.is_a?(Array)
+          raise ArgumentError, 'MessageFormat arguments must be provided as an Array of numbered values'
+        end
+
+        highest_argument = argument_types.keys.max
+        required_count = highest_argument ? highest_argument + 1 : 0
+        return if arguments.length >= required_count
+
+        raise ArgumentError, "MessageFormat pattern requires at least #{required_count} numbered arguments"
+      end
+
+      # Maps each numbered argument in the pattern to its ICU type keyword
+      # (e.g. "plural", "select", "number") or nil for a simple argument.
+      def argument_types
+        types = {}
+        quoted = false
+        chars = @pattern.each_char.to_a
+        index = 0
+
+        while index < chars.length
+          if chars[index] == "'"
+            if chars[index + 1] == "'"
+              index += 2
+              next
+            elsif quoted
+              quoted = false
+            elsif ['{', '}', '#'].include?(chars[index + 1])
+              quoted = true
+            end
+          elsif chars[index] == '{' && !quoted
+            index += 1
+            index += 1 while index < chars.length && chars[index].match?(/\s/)
+            start = index
+            index += 1 while index < chars.length && chars[index].match?(/\d/)
+            next if index == start
+
+            arg_number = chars[start...index].join.to_i
+            index += 1 while index < chars.length && chars[index].match?(/\s/)
+
+            if chars[index] == '}'
+              types[arg_number] = nil unless types.key?(arg_number)
+            elsif chars[index] == ','
+              index += 1
+              index += 1 while index < chars.length && chars[index].match?(/\s/)
+              type_start = index
+              index += 1 while index < chars.length && chars[index].match?(/[A-Za-z]/)
+              type = chars[type_start...index].join.downcase
+              types[arg_number] = (type.empty? ? nil : type) unless types.key?(arg_number)
+            end
+          end
+          index += 1
+        end
+
+        types
+      end
+
+      def validate_argument_types!(arguments)
+        types = argument_types
+        arguments.each_with_index do |argument, index|
+          next unless types.key?(index)
+
+          case expected_kind_for(types[index])
+          when :string
+            unless argument.is_a?(String)
+              raise ArgumentError,
+                    "MessageFormat argument #{index} expects a String, got #{argument.class}"
+            end
+          when :number
+            unless [Integer, Float, BigDecimal].any? { |klass| argument.is_a?(klass) }
+              raise ArgumentError,
+                    "MessageFormat argument #{index} expects a numeric value, got #{argument.class}"
+            end
+          end
+        end
+      end
+
+      # ICU reads each argument slot from the vararg list according to the
+      # pattern: simple and select arguments read a UChar*, while number,
+      # date, time, choice, plural, and selectordinal read a double.
+      def expected_kind_for(type)
+        case type
+        when 'number', 'date', 'time', 'choice', 'plural', 'selectordinal' then :number
+        else :string
+        end
+      end
+
+      def null_terminated_uchar_pointer(string)
+        pointer = UCharPointer.from_utf8(string)
+        terminated = UCharPointer.new(pointer.length_in_uchars + 1)
+        terminated.put_bytes(0, pointer.get_bytes(0, pointer.size))
+        terminated.put_uint16(pointer.size, 0)
+        terminated
+      end
+    end
+  end
+end