1 files changed, 36 insertions, 24 deletions
diff --git a/activesupport/lib/active_support/multibyte/chars.rb b/activesupport/lib/active_support/multibyte/chars.rb
index 47336d2143..a42e7f6542 100644
--- a/activesupport/lib/active_support/multibyte/chars.rb
+++ b/activesupport/lib/active_support/multibyte/chars.rb
@@ -6,22 +6,27 @@ require 'active_support/core_ext/module/delegation'
 
 module ActiveSupport #:nodoc:
   module Multibyte #:nodoc:
-    # Chars enables you to work transparently with UTF-8 encoding in the Ruby String class without having extensive
-    # knowledge about the encoding. A Chars object accepts a string upon initialization and proxies String methods in an
-    # encoding safe manner. All the normal String methods are also implemented on the proxy.
+    # Chars enables you to work transparently with UTF-8 encoding in the Ruby
+    # String class without having extensive knowledge about the encoding. A
+    # Chars object accepts a string upon initialization and proxies String
+    # methods in an encoding safe manner. All the normal String methods are also
+    # implemented on the proxy.
     #
-    # String methods are proxied through the Chars object, and can be accessed through the +mb_chars+ method. Methods
-    # which would normally return a String object now return a Chars object so methods can be chained.
+    # String methods are proxied through the Chars object, and can be accessed
+    # through the +mb_chars+ method. Methods which would normally return a
+    # String object now return a Chars object so methods can be chained.
     #
-    #   "The Perfect String  ".mb_chars.downcase.strip.normalize # => "the perfect string"
+    #   'The Perfect String  '.mb_chars.downcase.strip.normalize # => "the perfect string"
     #
-    # Chars objects are perfectly interchangeable with String objects as long as no explicit class checks are made.
-    # If certain methods do explicitly check the class, call +to_s+ before you pass chars objects to them.
+    # Chars objects are perfectly interchangeable with String objects as long as
+    # no explicit class checks are made. If certain methods do explicitly check
+    # the class, call +to_s+ before you pass chars objects to them.
     #
-    #   bad.explicit_checking_method "T".mb_chars.downcase.to_s
+    #   bad.explicit_checking_method 'T'.mb_chars.downcase.to_s
     #
-    # The default Chars implementation assumes that the encoding of the string is UTF-8, if you want to handle different
-    # encodings you can write your own multibyte string handler and configure it through
+    # The default Chars implementation assumes that the encoding of the string
+    # is UTF-8, if you want to handle different encodings you can write your own
+    # multibyte string handler and configure it through
     # ActiveSupport::Multibyte.proxy_class.
     #
     #   class CharsForUTF32
@@ -60,27 +65,30 @@ module ActiveSupport #:nodoc:
         end
       end
 
-      # Returns +true+ if _obj_ responds to the given method. Private methods are included in the search
-      # only if the optional second parameter evaluates to +true+.
+      # Returns +true+ if _obj_ responds to the given method. Private methods
+      # are included in the search only if the optional second parameter
+      # evaluates to +true+.
       def respond_to_missing?(method, include_private)
         @wrapped_string.respond_to?(method, include_private)
       end
 
-      # Returns +true+ when the proxy class can handle the string. Returns +false+ otherwise.
+      # Returns +true+ when the proxy class can handle the string. Returns
+      # +false+ otherwise.
       def self.consumes?(string)
         string.encoding == Encoding::UTF_8
       end
 
-      # Works just like <tt>String#split</tt>, with the exception that the items in the resulting list are Chars
-      # instances instead of String. This makes chaining methods easier.
+      # Works just like <tt>String#split</tt>, with the exception that the items
+      # in the resulting list are Chars instances instead of String. This makes
+      # chaining methods easier.
       #
       #   'Café périferôl'.mb_chars.split(/é/).map { |part| part.upcase.to_s } # => ["CAF", " P", "RIFERÔL"]
       def split(*args)
         @wrapped_string.split(*args).map { |i| self.class.new(i) }
       end
 
-      # Works like like <tt>String#slice!</tt>, but returns an instance of Chars, or nil if the string was not
-      # modified.
+      # Works like like <tt>String#slice!</tt>, but returns an instance of
+      # Chars, or nil if the string was not modified.
       def slice!(*args)
         chars(@wrapped_string.slice!(*args))
       end
@@ -92,8 +100,9 @@ module ActiveSupport #:nodoc:
         chars(Unicode.unpack_graphemes(@wrapped_string).reverse.flatten.pack('U*'))
       end
 
-      # Limits the byte size of the string to a number of bytes without breaking characters. Usable
-      # when the storage for a string is limited for some reason.
+      # Limits the byte size of the string to a number of bytes without breaking
+      # characters. Usable when the storage for a string is limited for some
+      # reason.
       #
       #   'こんにちは'.mb_chars.limit(7).to_s # => "こん"
       def limit(limit)
@@ -137,8 +146,9 @@ module ActiveSupport #:nodoc:
       end
       alias_method :titlecase, :titleize
 
-      # Returns the KC normalization of the string by default. NFKC is considered the best normalization form for
-      # passing strings to databases and validations.
+      # Returns the KC normalization of the string by default. NFKC is
+      # considered the best normalization form for passing strings to databases
+      # and validations.
       #
       # * <tt>form</tt> - The form you want to normalize in. Should be one of the following:
       #   <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>. Default is
@@ -171,9 +181,11 @@ module ActiveSupport #:nodoc:
         Unicode.unpack_graphemes(@wrapped_string).length
       end
 
-      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent resulting in a valid UTF-8 string.
+      # Replaces all ISO-8859-1 or CP1252 characters by their UTF-8 equivalent
+      # resulting in a valid UTF-8 string.
       #
-      # Passing +true+ will forcibly tidy all bytes, assuming that the string's encoding is entirely CP1252 or ISO-8859-1.
+      # Passing +true+ will forcibly tidy all bytes, assuming that the string's
+      # encoding is entirely CP1252 or ISO-8859-1.
       def tidy_bytes(force = false)
         chars(Unicode.tidy_bytes(@wrapped_string, force))
       end