module Mail::Multibyte

Note: this method is a no-op in Ruby 1.9

Removes all invalid characters from the string.

def self.clean(string)
  string
end

def self.clean(string)
  if expression = valid_character
    # Splits the string on character boundaries, which are determined based on $KCODE.
    string.split(//).grep(expression).join
  else
    string
  end
end

information about how to change the default Multibyte behaviour see Mail::Multibyte.
For more information about the methods defined on the Chars proxy see Mail::Multibyte::Chars. For

object. Interoperability problems can be resolved easily with a +to_s+ call.
String and Char work like expected. The bang! methods change the internal string representation in the Chars
The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between

== Interoperability and configuration

name.mb_chars.reverse.length # => 12

method chaining on the result of any of these methods.
All the methods on the Chars proxy which normally return a string will return a Chars object. This allows

== Method chaining

it becomes easy to run one version of your code on multiple Ruby versions.
In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that

name.mb_chars.length # => 12
name.mb_chars.reverse.to_s # => "rellüM sualC"

name.length # => 13
name.reverse # => "rell??M sualC"
name = 'Claus Müller'

class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
In Ruby 1.8 and older it creates and returns an instance of the Mail::Multibyte::Chars class which

+mb_chars+ is a multibyte safe proxy for string methods.

== Multibyte proxy

def self.mb_chars(str)
  if proxy_class.consumes?(str)
    proxy_class.new(str)
  else
    str
  end
end

def self.mb_chars(str)
  if proxy_class.wants?(str)
    proxy_class.new(str)
  else
    str
  end
end

Returns a regular expression that matches valid characters in the current encoding

def self.valid_character
  VALID_CHARACTER[Encoding.default_external.to_s]
end

def self.valid_character
  case $KCODE
  when 'UTF8'
    VALID_CHARACTER['UTF-8']
  when 'SJIS'
    VALID_CHARACTER['Shift_JIS']
  end
end

Verifies the encoding of a string

def self.verify(string)
  string.valid_encoding?
end

def self.verify(string)
  if expression = valid_character
    # Splits the string on character boundaries, which are determined based on $KCODE.
    string.split(//).all? { |c| expression =~ c }
  else
    true
  end
end

Verifies the encoding of the string and raises an exception when it's not valid

def self.verify!(string)
  raise EncodingError.new("Found characters with invalid encoding") unless verify(string)
end