ffi-icu 0.5.2 → 0.6.0

data/lib/ffi-icu/locale.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ICU
   class Locale
     class << self
@@ -43,16 +45,16 @@ module ICU
     attr_reader :id
 
     DISPLAY_CONTEXT = {
-      length_full:  512, # UDISPCTX_LENGTH_FULL  = (UDISPCTX_TYPE_DISPLAY_LENGTH<<8) + 0
-      length_short: 513  # UDISPCTX_LENGTH_SHORT = (UDISPCTX_TYPE_DISPLAY_LENGTH<<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
 
     def initialize(id)
       @id = id.to_s
     end
 
     def ==(other)
-      other.is_a?(self.class) && other.id == self.id
+      other.is_a?(self.class) && other.id == id
     end
 
     def base_name
@@ -104,9 +106,9 @@ module ICU
     def display_name_with_context(locale, contexts = [])
       contexts = DISPLAY_CONTEXT.select { |context| contexts.include?(context) }.values
 
-      with_locale_display_name(@id, contexts) do |locale_display_names|
+      with_locale_display_name(locale, contexts) do |locale_display_names|
         Lib::Util.read_uchar_buffer(256) do |buffer, status|
-          Lib.uldn_localeDisplayName(locale_display_names, locale, buffer, buffer.size, status)
+          Lib.uldn_localeDisplayName(locale_display_names, @id, buffer, buffer.size, status)
         end
       end
     end
@@ -183,13 +185,13 @@ module ICU
       end
     end
 
-    def to_language_tag(strict = false)
+    def to_language_tag(strict = false) # rubocop:disable Style/OptionalBooleanParameter
       Lib::Util.read_string_buffer(64) do |buffer, status|
         Lib.uloc_toLanguageTag(@id, buffer, buffer.size, strict ? 1 : 0, status)
       end
     end
 
-    alias_method :to_s, :id
+    alias to_s id
 
     def variant
       Lib::Util.read_string_buffer(64) do |buffer, status|
@@ -238,9 +240,11 @@ module ICU
 
     def with_locale_display_name(locale, contexts)
       pointer = FFI::MemoryPointer.new(:int, contexts.length).write_array_of_int(contexts)
-      locale_display_names = ICU::Lib.check_error { |status| ICU::Lib.uldn_openForContext(locale, pointer, contexts.length, status) }
+      locale_display_names = ICU::Lib.check_error do |status|
+        ICU::Lib.uldn_openForContext(locale, pointer, contexts.length, status)
+      end
 
-      yield locale_display_names
+      yield(locale_display_names)
     ensure
       Lib.uldn_close(locale_display_names) if locale_display_names
     end

data/lib/ffi-icu/normalization.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module ICU
   module Normalization
-
     def self.normalize(input, mode = :default)
-      input_length  = input.jlength
+      input_length  = input.size
       needed_length = out_length = options = 0
       in_ptr        = UCharPointer.from_string(input)
       out_ptr       = UCharPointer.new(out_length)
@@ -14,9 +15,9 @@ module ICU
           needed_length = Lib.unorm_normalize(in_ptr, input_length, mode, options, out_ptr, out_length, error)
         end
       rescue BufferOverflowError
-        raise BufferOverflowError, "needed: #{needed_length}" if retried
+        raise(BufferOverflowError, "needed: #{needed_length}") if retried
 
-        out_ptr       = out_ptr.resized_to needed_length
+        out_ptr       = out_ptr.resized_to(needed_length)
         out_length    = needed_length + 1
 
         retried = true
@@ -25,6 +26,5 @@ module ICU
 
       out_ptr.string
     end
-
-  end # Normalization
-end # ICU
+  end
+end

data/lib/ffi-icu/normalizer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ICU
   class Normalizer
     # support for newer ICU normalization API
@@ -9,7 +11,7 @@ module ICU
     end
 
     def normalize(input)
-      input_length  = input.jlength
+      input_length  = input.size
       in_ptr        = UCharPointer.from_string(input)
       needed_length = capacity = 0
       out_ptr       = UCharPointer.new(needed_length)
@@ -20,10 +22,10 @@ module ICU
           needed_length = Lib.unorm2_normalize(@instance, in_ptr, input_length, out_ptr, capacity, error)
         end
       rescue BufferOverflowError
-        raise BufferOverflowError, "needed: #{needed_length}" if retried
+        raise(BufferOverflowError, "needed: #{needed_length}") if retried
 
         capacity = needed_length
-        out_ptr = out_ptr.resized_to needed_length
+        out_ptr = out_ptr.resized_to(needed_length)
 
         retried = true
         retry
@@ -32,16 +34,20 @@ module ICU
       out_ptr.string
     end
 
-    def is_normailzed?(input)
-      input_length  = input.jlength
+    def normailzed?(input)
+      input_length  = input.size
       in_ptr        = UCharPointer.from_string(input)
 
       Lib.check_error do |error|
-        result = Lib.unorm2_isNormalized(@instance, in_ptr, input_length, error)
+        Lib.unorm2_isNormalized(@instance, in_ptr, input_length, error)
       end
 
       result
     end
 
-  end # Normalizer
-end # ICU
+    def is_normalized?(input) # rubocop:disable Naming/PredicatePrefix
+      Warning.warn('is_normalized? is deprecated and will be removed after v0.7. Please use normalized? instead.')
+      normalized?(input)
+    end
+  end
+end

data/lib/ffi-icu/number_formatting.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'bigdecimal'
 
 module ICU
   module NumberFormatting
     @default_options = {}
-    
+
     def self.create(locale, type = :decimal, options = {})
       case type
       when :currency
@@ -17,7 +19,7 @@ module ICU
       @default_options.clear
     end
 
-    def self.set_default_options(options)
+    def self.set_default_options(options) # rubocop:disable Naming/AccessorMethodName
       @default_options.merge!(options)
     end
 
@@ -38,8 +40,7 @@ module ICU
     end
 
     class BaseFormatter
-
-      def set_attributes(options)
+      def set_attributes(options) # rubocop:disable Naming/AccessorMethodName
         options.each { |key, value| Lib.unum_set_attribute(@f, key, value) }
         self
       end
@@ -47,13 +48,17 @@ module ICU
       private
 
       def make_formatter(type, locale)
-        ptr = Lib.check_error { | error| Lib.unum_open(type, FFI::MemoryPointer.new(4), 0, locale, FFI::MemoryPointer.new(4), error) }
+        ptr = Lib.check_error do |error|
+          Lib.unum_open(type, FFI::MemoryPointer.new(4), 0, locale, FFI::MemoryPointer.new(4), error)
+        end
         FFI::AutoPointer.new(ptr, Lib.method(:unum_close))
       end
     end
 
     class NumberFormatter < BaseFormatter
       def initialize(locale, type = :decimal)
+        super()
+
         @f = make_formatter(type, locale)
       end
 
@@ -75,41 +80,48 @@ module ICU
               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"
+                  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)
+                needed_length = Lib.unum_format_decimal(@f, string_version, string_version.size, out_ptr,
+                                                        needed_length, nil, error)
               end
             when BigDecimal
               string_version = number.to_s('F')
-              if Lib.respond_to? :unum_format_decimal
-                needed_length = Lib.unum_format_decimal(@f, string_version, string_version.bytesize, out_ptr, needed_length, nil, error)
-              else
-                needed_length = Lib.unum_format_double(@f, number.to_f, out_ptr, needed_length, nil, error)
-              end
+              needed_length = if Lib.respond_to?(:unum_format_decimal)
+                                Lib.unum_format_decimal(@f, string_version, string_version.size, out_ptr,
+                                                        needed_length, nil, error)
+                              else
+                                Lib.unum_format_double(@f, number.to_f, out_ptr, needed_length, nil, error)
+                              end
             end
           end
-          out_ptr.string needed_length
+          out_ptr.string(needed_length)
         rescue BufferOverflowError
-          raise BufferOverflowError, "needed: #{needed_length}" if retried
-          out_ptr = out_ptr.resized_to needed_length
+          raise(BufferOverflowError, "needed: #{needed_length}") if retried
+
+          out_ptr = out_ptr.resized_to(needed_length)
           retried = true
           retry
         end
       end
-    end # NumberFormatter
+    end
 
     class CurrencyFormatter < BaseFormatter
       def initialize(locale, style = :default)
-        if %w(iso plural).include?((style || '').to_s)
+        super()
+
+        if ['iso', 'plural'].include?((style || '').to_s)
           if Lib.version.to_a.first >= 53
-            style = "currency_#{style}".to_sym
+            style = :"currency_#{style}"
           else
-            fail "Your version of ICU (#{Lib.version.to_a.join('.')}) does not support #{style} currency formatting (supported only in version >= 53)"
+            raise("Your version of ICU (#{Lib.version.to_a.join('.')}) does not support " \
+                  "#{style} currency formatting (supported only in version >= 53)")
           end
         elsif style && style.to_sym != :default
-          fail "The ffi-icu ruby gem does not support :#{default} currency formatting (only :default, :iso, and :plural)"
+          raise('The ffi-icu ruby gem does not support: ' \
+                "#{default} currency formatting (only :default, :iso, and :plural)")
         else
           style = :currency
         end
@@ -124,16 +136,18 @@ module ICU
 
         begin
           Lib.check_error do |error|
-            needed_length = Lib.unum_format_currency(@f, number, UCharPointer.from_string(currency, 4), out_ptr, needed_length, nil, error)
+            needed_length = Lib.unum_format_currency(@f, number, UCharPointer.from_string(currency, 4), out_ptr,
+                                                     needed_length, nil, error)
           end
           out_ptr.string
         rescue BufferOverflowError
-          raise BufferOverflowError, "needed: #{needed_length}" if retried
-          out_ptr = out_ptr.resized_to needed_length
+          raise(BufferOverflowError, "needed: #{needed_length}") if retried
+
+          out_ptr = out_ptr.resized_to(needed_length)
           retried = true
           retry
         end
       end
-    end # CurrencyFormatter
-  end # Formatting
-end # ICU
+    end
+  end
+end

data/lib/ffi-icu/time_formatting.rb

@@ -1,53 +1,65 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module ICU
   module TimeFormatting
     TZ_MAP = {
-      :generic_location =>   'VVVV',# The generic location format.
-                                    #   Where that is unavailable, falls back to the long localized GMT format ("OOOO";
-                                    #   Note: Fallback is only necessary with a GMT-style Time Zone ID, like Etc/GMT-830.),
-                                    #   This is especially useful when presenting possible timezone choices for user selection,
-                                    #   since the naming is more uniform than the "v" format.
-                                    #   such as "United States Time (New York)", "Italy Time"
-      :generic_long     =>  'vvvv', # The long generic non-location format.
-                                    #   Where that is unavailable, falls back to generic location format ("VVVV")., such as "Eastern Time".
-      :generic_short    =>     'v', # The short generic non-location format.
-                                    #   Where that is unavailable, falls back to the generic location format ("VVVV"),
-                                    #   then the short localized GMT format as the final fallback., such as "ET".
-      :specific_long    =>  'zzzz', # The long specific non-location format.
-                                    #   Where that is unavailable, falls back to the long localized GMT format ("OOOO").
-      :specific_short   =>     'z', # The short specific non-location format.
-                                    #   Where that is unavailable, falls back to the short localized GMT format ("O").
-      :basic            =>     'Z', # The ISO8601 basic format with hours, minutes and optional seconds fields.
-                                    #   The format is equivalent to RFC 822 zone format (when optional seconds field is absent).
-                                    #   This is equivalent to the "xxxx" specifier.
-      :localized_long   =>  'ZZZZ', # The long localized GMT format. This is equivalent to the "OOOO" specifier, such as GMT-8:00
-      :extended         => 'ZZZZZ', # The ISO8601 extended format with hours, minutes and optional seconds fields.
-                                    #   The ISO8601 UTC indicator "Z" is used when local time offset is 0.
-                                    #   This is equivalent to the "XXXXX" specifier, such as -08:00 -07:52:58
-      :localized_short  =>    'O',  # The short localized GMT format, such as GMT-8
-      :localized_longO  => 'OOOO',  # The long localized GMT format, such as GMT-08:00
-      :tz_id_short      =>    'V',  # The short time zone ID. Where that is unavailable,
-                                    #   the special short time zone ID unk (Unknown Zone) is used.
-                                    #   Note: This specifier was originally used for a variant of the short specific non-location format,
-                                    #   but it was deprecated in the later version of this specification. In CLDR 23, the definition
-                                    #   of the specifier was changed to designate a short time zone ID, such as uslax
-      :tz_id_long       =>   'VV',  # The long time zone ID, such as America/Los_Angeles
-      :city_location    =>  'VVV',  # The exemplar city (location) for the time zone. Where that is unavailable,
-                                    #   the localized exemplar city name for the special zone Etc/Unknown is used as the fallback
-                                    #   (for example, "Unknown City"), such as Los Angeles
+      # The generic location format.
+      #   Where that is unavailable, falls back to the long localized GMT format ("OOOO";
+      #   Note: Fallback is only necessary with a GMT-style Time Zone ID, like Etc/GMT-830.),
+      #   This is especially useful when presenting possible timezone choices for user selection,
+      #   since the naming is more uniform than the "v" format.
+      #   such as "United States Time (New York)", "Italy Time"
+      generic_location: 'VVVV',
+      # The long generic non-location format.
+      #   Where that is unavailable, falls back to generic location format ("VVVV")., such as "Eastern Time".
+      generic_long: 'vvvv',
+      # The short generic non-location format.
+      #   Where that is unavailable, falls back to the generic location format ("VVVV"),
+      #   then the short localized GMT format as the final fallback., such as "ET".
+      generic_short: 'v',
+      # The long specific non-location format.
+      #   Where that is unavailable, falls back to the long localized GMT format ("OOOO").
+      specific_long: 'zzzz',
+      # The short specific non-location format.
+      #   Where that is unavailable, falls back to the short localized GMT format ("O").
+      specific_short: 'z',
+      # The ISO8601 basic format with hours, minutes and optional seconds fields.
+      #   The format is equivalent to RFC 822 zone format (when optional seconds field is absent).
+      #   This is equivalent to the "xxxx" specifier.
+      basic: 'Z',
+      # The long localized GMT format. This is equivalent to the "OOOO" specifier, such as GMT-8:00
+      localized_long: 'ZZZZ',
+      # The ISO8601 extended format with hours, minutes and optional seconds fields.
+      #   The ISO8601 UTC indicator "Z" is used when local time offset is 0.
+      #   This is equivalent to the "XXXXX" specifier, such as -08:00 -07:52:58
+      extended: 'ZZZZZ',
+      localized_short: 'O', # The short localized GMT format, such as GMT-8
+      localized_longO: 'OOOO', # The long localized GMT format, such as GMT-08:00
+      # The short time zone ID. Where that is unavailable,
+      #   the special short time zone ID unk (Unknown Zone) is used.
+      #   Note: This specifier was originally used for a variant of the short specific non-location format,
+      #   but it was deprecated in the later version of this specification. In CLDR 23, the definition
+      #   of the specifier was changed to designate a short time zone ID, such as uslax
+      tz_id_short: 'V',
+      tz_id_long: 'VV', # The long time zone ID, such as America/Los_Angeles
+      # The exemplar city (location) for the time zone. Where that is unavailable,
+      #   the localized exemplar city name for the special zone Etc/Unknown is used as the fallback
+      #   (for example, "Unknown City"), such as Los Angeles
       # see: http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
-    }
+      city_location: 'VVV'
+    }.freeze
 
     HOUR_CYCLE_SYMS = {
       'h11' => 'K',
       'h12' => 'h',
       'h23' => 'H',
       'h24' => 'k',
-      :locale => 'j',
-    }
+      :locale => 'j'
+    }.freeze
     @default_options = {}
-    
+
     def self.create(options = {})
       DateTimeFormatter.new(@default_options.merge(options))
     end
@@ -56,17 +68,16 @@ module ICU
       @default_options.clear
     end
 
-    def self.set_default_options(options)
+    def self.set_default_options(options) # rubocop:disable Naming/AccessorMethodName
       @default_options.merge!(options)
     end
 
-    def self.format(dt, options = {})
-      create(@default_options.merge(options)).format(dt)
+    def self.format(datetime, options = {})
+      create(@default_options.merge(options)).format(datetime)
     end
 
     class BaseFormatter
-
-      def set_attributes(options)
+      def set_attributes(options) # rubocop:disable Naming/AccessorMethodName
         options.each { |key, value| Lib.unum_set_attribute(@f, key, value) }
         self
       end
@@ -83,11 +94,11 @@ module ICU
           time_zone = UCharPointer.from_string(time_zone_str)
           tz_len = time_zone_str.size
         else
-          Lib.check_error { | error| 
-            i_len  = 150
+          Lib.check_error do |error|
+            i_len = 150
             time_zone = UCharPointer.new(i_len)
-            tz_len = Lib.ucal_getDefaultTimeZone(time_zone, i_len, error) 
-          }
+            tz_len = Lib.ucal_getDefaultTimeZone(time_zone, i_len, error)
+          end
         end
 
         if skeleton
@@ -97,13 +108,17 @@ module ICU
           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) }
+        ptr = Lib.check_error do |error|
+          Lib.udat_open(time_style, date_style, locale, time_zone, tz_len, pattern_ptr, pattern_len, error)
+        end
         FFI::AutoPointer.new(ptr, Lib.method(:udat_close))
       end
     end
 
     class DateTimeFormatter < BaseFormatter
-      def initialize(options={})
+      def initialize(options = {})
+        super()
+
         time_style  = options[:time]   || :short
         date_style  = options[:date]   || :short
         @locale     = options[:locale] || 'C'
@@ -113,31 +128,29 @@ module ICU
         @hour_cycle = options[:hour_cycle]
 
         if @hour_cycle && !HOUR_CYCLE_SYMS.keys.include?(@hour_cycle)
-          raise ICU::Error.new("Unknown hour cycle #{@hour_cycle}")
+          raise(ICU::Error, "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)    
-          if f1 != f0
-            set_date_format(true, f1)
-          end
+          f1 = update_tz_format(f0, tz_style)
+          set_date_format(true, f1) if f1 != f0
         end
 
         replace_hour_symbol!
       end
 
       def parse(str)
-          str_u = UCharPointer.from_string(str)
-          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)
-          end
+        str_u = UCharPointer.from_string(str)
+        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)
+        end
       end
 
-      def format(dt)
+      def format(datetime)
         needed_length = 0
         out_ptr = UCharPointer.new(needed_length)
 
@@ -145,18 +158,23 @@ module ICU
 
         begin
           Lib.check_error do |error|
-            case dt
+            case datetime
             when Date
-              needed_length = Lib.udat_format(@f, Time.mktime( dt.year, dt.month, dt.day, 0, 0, 0, 0 ).to_f * 1000.0, out_ptr, needed_length, nil, error)
+              needed_length = Lib.udat_format(
+                @f,
+                Time.mktime(datetime.year, datetime.month, datetime.day, 0, 0, 0, 0).to_f * 1000.0,
+                out_ptr, needed_length, nil, error
+              )
             when Time
-              needed_length = Lib.udat_format(@f, dt.to_f * 1000.0, out_ptr, needed_length, nil, error)
+              needed_length = Lib.udat_format(@f, datetime.to_f * 1000.0, out_ptr, needed_length, nil, error)
             end
           end
 
           out_ptr.string
         rescue BufferOverflowError
-          raise BufferOverflowError, "needed: #{needed_length}" if retried
-          out_ptr = out_ptr.resized_to needed_length
+          raise(BufferOverflowError, "needed: #{needed_length}") if retried
+
+          out_ptr = out_ptr.resized_to(needed_length)
           retried = true
           retry
         end
@@ -164,19 +182,23 @@ module ICU
 
       # time-zone formating
       def update_tz_format(format, tz_style)
-        return format if format !~ /(.*?)(\s*(?:[zZOVV]+\s*))(.*?)/
-        pre, tz, suff = $1, $2, $3
+        return format if format !~ /(.*?)(\s*(?:[zZOV]+\s*))(.*?)/
+
+        pre = ::Regexp.last_match(1)
+        tz = ::Regexp.last_match(2)
+        suff = ::Regexp.last_match(3)
         if tz_style == :none
-          tz = ((tz =~ /\s/) && !pre.empty? && !suff.empty?) ? ' ' : ''
+          tz = (tz =~ /\s/) && !pre.empty? && !suff.empty? ? ' ' : ''
         else
           repl = TZ_MAP[tz_style]
-          raise 'no such tz_style' unless repl
-          tz.gsub!(/^(\s*)(.*?)(\s*)$/, '\1'+repl+'\3')
+          raise('no such tz_style') unless repl
+
+          tz.gsub!(/^(\s*)(.*?)(\s*)$/, "\\1#{repl}\\3")
         end
         pre + tz + suff
       end
 
-      def date_format(localized=true)
+      def date_format(localized = true) # rubocop:disable Style/OptionalBooleanParameter
         needed_length = 0
         out_ptr = UCharPointer.new(needed_length)
 
@@ -189,8 +211,9 @@ module ICU
 
           out_ptr.string
         rescue BufferOverflowError
-          raise BufferOverflowError, "needed: #{needed_length}" if retried
-          out_ptr = out_ptr.resized_to needed_length
+          raise(BufferOverflowError, "needed: #{needed_length}") if retried
+
+          out_ptr = out_ptr.resized_to(needed_length)
           retried = true
           retry
         end
@@ -205,26 +228,28 @@ module ICU
       end
 
       def skeleton_format(skeleton_pattern_str, locale)
-          skeleton_pattern_ptr = UCharPointer.from_string(skeleton_pattern_str)
-          skeleton_pattern_len = skeleton_pattern_str.size
+        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)
+        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))
+        udatpg_ptr = Lib.check_error { |error| Lib.udatpg_open(locale, error) }
+        generator = FFI::AutoPointer.new(udatpg_ptr, Lib.method(:udatpg_close))
 
-          retried = false
+        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)
+            needed_length = Lib.udatpg_getBestPattern(generator, skeleton_pattern_ptr, skeleton_pattern_len,
+                                                      pattern_ptr, needed_length, error)
           end
 
-          return needed_length, pattern_ptr
+          [needed_length, pattern_ptr]
         rescue BufferOverflowError
-          raise BufferOverflowError, "needed: #{needed_length}" if retried
-          pattern_ptr = pattern_ptr.resized_to needed_length
+          raise(BufferOverflowError, "needed: #{needed_length}") if retried
+
+          pattern_ptr = pattern_ptr.resized_to(needed_length)
           retried = true
           retry
         end
@@ -255,9 +280,7 @@ module ICU
         # Either ensure the skeleton has, or does not have, am/pm, as appropriate
         if ['h11', 'h12'].include?(@hour_cycle)
           # 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
+          skeleton_str << 'a' if skeleton_str =~ /[hHkKjJ]/ && !skeleton_str.include?('a')
         else
           skeleton_str.gsub!('a', '')
         end
@@ -275,7 +298,7 @@ module ICU
         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])
+          new_pattern_str.gsub!(/[hHkK](?=(?:[^']|'[^']*')*$)/, HOUR_CYCLE_SYMS[resolved_hour_cycle])
         end
 
         # Finally, set the new pattern onto the date time formatter
@@ -325,10 +348,10 @@ module ICU
         pattern     = UCharPointer.from_string(pattern_str)
         pattern_len = pattern_str.size
 
-        Lib.check_error do |error|
-          needed_length = Lib.udat_applyPattern(@f, localized, pattern, pattern_len)
+        Lib.check_error do |_error|
+          Lib.udat_applyPattern(@f, localized, pattern, pattern_len)
         end
       end
-    end # DateTimeFormatter
-  end # Formatting
-end # ICU
+    end
+  end
+end