Encodings and Unicode

# frozen_string_literal: true

precomposed = "Caf\u{E9}"
decomposed = "Cafe\u{301}"

# Characters (code points), bytes and grapheme clusters are three different counts.
precomposed.length # => 4
precomposed.bytesize # => 5
decomposed.length # => 5
decomposed.bytesize # => 6
decomposed.grapheme_clusters.length # => 4

precomposed.codepoints # => [67, 97, 102, 233]
decomposed.codepoints # => [67, 97, 102, 101, 769]
precomposed.bytes # => [67, 97, 102, 195, 169]
decomposed.bytes # => [67, 97, 102, 101, 204, 129]

# Two strings that look identical but are different sequences of code points.
precomposed.eql?(decomposed) # => false
precomposed.unicode_normalize(:nfd).eql?(decomposed) # => true
precomposed.eql?(decomposed.unicode_normalize(:nfc)) # => true

# One user-perceived character can be many code points.
family = "\u{1F468}\u{200D}\u{1F469}\u{200D}\u{1F467}"
family.length # => 5
family.bytesize # => 18
family.grapheme_clusters.length # => 1
family.codepoints.map { |cp| format("U+%04X", cp) } # => ["U+1F468", "U+200D", "U+1F469", "U+200D", "U+1F467"]

flag = "\u{1F1EA}\u{1F1F8}"
flag.length # => 2
flag.grapheme_clusters.length # => 1

# frozen_string_literal: true

Encoding.list.size # => 103
Encoding.name_list.size # => 175
Encoding::UTF_8.name # => "UTF-8"
Encoding::UTF_8.names # => ["UTF-8", "CP65001", "locale", "external", "filesystem"]
Encoding::UTF_8.to_s # => "UTF-8"
Encoding::UTF_8.inspect # => "#<Encoding:UTF-8>"

# ASCII-8BIT was renamed BINARY in the display (3.4); both names find the same object.
Encoding::BINARY.inspect # => "#<Encoding:BINARY (ASCII-8BIT)>"
Encoding::BINARY.equal?(Encoding::ASCII_8BIT) # => true
Encoding::BINARY.name # => "ASCII-8BIT"
Encoding::BINARY.names # => ["ASCII-8BIT", "BINARY"]

# Lookup is case-insensitive and understands aliases and the special names.
Encoding.find("utf-8").name # => "UTF-8"
Encoding.find("CP1252").name # => "Windows-1252"
Encoding.aliases["SJIS"] # => "Windows-31J"
Encoding.find("locale").name # => "UTF-8"
Encoding.find("external").name # => "UTF-8"
Encoding.find("internal") # => nil
Encoding.find(Encoding::UTF_8).name # => "UTF-8"

begin
  Encoding.find("utf-9")
rescue ArgumentError => e
  e.message # => "unknown encoding name - utf-9"
end

# Properties used when deciding whether two strings can be combined.
Encoding::UTF_8.ascii_compatible? # => true
Encoding::UTF_16LE.ascii_compatible? # => false
Encoding::UTF_16.dummy? # => true
Encoding::UTF_8.dummy? # => false
Encoding::ISO_2022_JP.dummy? # => true

# frozen_string_literal: true

# No magic comment: the script encoding of a file is UTF-8 (since Ruby 2.0).
__ENCODING__.name # => "UTF-8"
"abc".encoding # => #<Encoding:UTF-8>
"caf\u{E9}".encoding # => #<Encoding:UTF-8>
"caf\xC3\xA9".encoding # => #<Encoding:UTF-8>
"caf\xC3\xA9".valid_encoding? # => true
"caf\xE9".encoding # => #<Encoding:UTF-8>
"caf\xE9".valid_encoding? # => false
:abc.encoding # => #<Encoding:US-ASCII>
label = "caf\u{E9}"
label.to_sym.encoding # => #<Encoding:UTF-8>
/abc/.encoding # => #<Encoding:US-ASCII>
/caf\u{E9}/.encoding # => #<Encoding:UTF-8>
"caf\u{E9}".b.encoding # => #<Encoding:BINARY (ASCII-8BIT)>
String.new.encoding # => #<Encoding:BINARY (ASCII-8BIT)>
String.new("").encoding # => #<Encoding:UTF-8>
String.new(capacity: 16).encoding # => #<Encoding:BINARY (ASCII-8BIT)>
String.new(encoding: "UTF-8").encoding # => #<Encoding:UTF-8>

# encoding: iso-8859-1
# frozen_string_literal: true

# The script encoding decides how string, symbol and regexp literals are labelled.
__ENCODING__.name # => "ISO-8859-1"
"abc".encoding # => #<Encoding:ISO-8859-1>
"caf\xE9".encoding # => #<Encoding:ISO-8859-1>
"caf\xE9".valid_encoding? # => true
"caf\xE9".encode("UTF-8") # => "café"
"caf\u{E9}".encoding # => #<Encoding:UTF-8>
:abc.encoding # => #<Encoding:US-ASCII>
label = "caf\xE9"
label.to_sym.encoding # => #<Encoding:ISO-8859-1>
/abc/.encoding # => #<Encoding:US-ASCII>

# encoding: us-ascii
# frozen_string_literal: true

__ENCODING__.name # => "US-ASCII"
"abc".encoding # => #<Encoding:US-ASCII>
"abc\u{E9}".encoding # => #<Encoding:UTF-8>
"abc\xE9".encoding # => #<Encoding:BINARY (ASCII-8BIT)>
"abc\xE9".valid_encoding? # => true
:abc.encoding # => #<Encoding:US-ASCII>

# frozen_string_literal: true

p Encoding.default_external, Encoding.default_internal, __ENCODING__

$ LC_ALL=C ruby show.rb
#<Encoding:US-ASCII>
nil
#<Encoding:UTF-8>

$ LC_ALL=C.UTF-8 ruby show.rb
#<Encoding:UTF-8>
nil
#<Encoding:UTF-8>

$ LC_ALL=C.UTF-8 ruby -E ISO-8859-1:UTF-8 show.rb
#<Encoding:ISO-8859-1>
#<Encoding:UTF-8>
#<Encoding:UTF-8>

$ LC_ALL=C ruby --external-encoding=UTF-8 show.rb
#<Encoding:UTF-8>
nil
#<Encoding:UTF-8>

$ LC_ALL=C.UTF-8 ruby -U show.rb
#<Encoding:UTF-8>
#<Encoding:UTF-8>
#<Encoding:UTF-8>

$ RUBYOPT=-EUTF-8 LC_ALL=C ruby show.rb
#<Encoding:UTF-8>
nil
#<Encoding:UTF-8>

$ ruby -Ke show.rb
#<Encoding:EUC-JP>
nil
#<Encoding:EUC-JP>

$ LC_ALL=C ruby -e 'p __ENCODING__'
#<Encoding:US-ASCII>

# frozen_string_literal: true

$stdout.set_encoding("ISO-8859-1")
puts "caf\u{E9}"

$ ruby out.rb | od -An -c
   c   a   f 351  \n

# frozen_string_literal: true

p ARGV.first, ARGV.first.encoding, ENV.fetch("SHELF_OWNER").encoding
p Encoding.default_external, $stdout.external_encoding

$ SHELF_OWNER=García LC_ALL=C.UTF-8 ruby argv.rb Zoë
"Zoë"
#<Encoding:UTF-8>
#<Encoding:UTF-8>
#<Encoding:UTF-8>
nil

$ SHELF_OWNER=Garcia LC_ALL=C ruby argv.rb Zoe
"Zoe"
#<Encoding:US-ASCII>
#<Encoding:US-ASCII>
#<Encoding:US-ASCII>
nil

# frozen_string_literal: true

line = $stdin.gets
p line.encoding, line.valid_encoding?, line.bytes
p $stdin.external_encoding, $stdin.internal_encoding

$ printf 'caf\351\n' | LC_ALL=C.UTF-8 ruby stdin.rb
#<Encoding:UTF-8>
false
[99, 97, 102, 233, 10]
#<Encoding:UTF-8>
nil

$ printf 'caf\351\n' | LC_ALL=C.UTF-8 ruby -E ISO-8859-1 stdin.rb
#<Encoding:ISO-8859-1>
true
[99, 97, 102, 233, 10]
#<Encoding:ISO-8859-1>
nil

$ printf 'caf\351\n' | LC_ALL=C.UTF-8 ruby -E ISO-8859-1:UTF-8 stdin.rb
#<Encoding:UTF-8>
true
[99, 97, 102, 195, 169, 10]
#<Encoding:ISO-8859-1>
#<Encoding:UTF-8>

# frozen_string_literal: true

utf8 = "caf\u{E9}"
latin1 = utf8.encode("ISO-8859-1")
ascii = "cafe"

# ASCII-only strings are compatible with every ASCII-compatible encoding.
Encoding.compatible?(utf8, ascii) # => #<Encoding:UTF-8>
Encoding.compatible?(ascii, latin1) # => #<Encoding:ISO-8859-1>
Encoding.compatible?(utf8, latin1) # => nil
Encoding.compatible?("", latin1) # => #<Encoding:ISO-8859-1>
Encoding.compatible?(utf8, :cafe) # => #<Encoding:UTF-8>
Encoding.compatible?(utf8, 42) # => nil
(ascii + latin1).encoding # => #<Encoding:ISO-8859-1>
(utf8 + ascii).encoding # => #<Encoding:UTF-8>

# Two non-ASCII strings in different encodings cannot be combined.
begin
  utf8 + latin1
rescue Encoding::CompatibilityError => e
  e.message # => "incompatible character encodings: UTF-8 and ISO-8859-1"
end

begin
  "#{utf8} - #{latin1}"
rescue Encoding::CompatibilityError => e
  e.message # => "incompatible character encodings: UTF-8 and ISO-8859-1"
end

begin
  [utf8, latin1].join
rescue Encoding::CompatibilityError => e
  e.message # => "incompatible character encodings: UTF-8 and ISO-8859-1"
end

# Same characters, different bytes: not equal, and not the same hash key.
latin1.bytes # => [99, 97, 102, 233]
utf8.bytes # => [99, 97, 102, 195, 169]
utf8.eql?(latin1) # => false
{ utf8 => 1 }.key?(latin1) # => false

# ASCII-only strings compare equal across ASCII-compatible encodings.
ascii.eql?(ascii.encode("ISO-8859-1")) # => true
ascii.eql?(ascii.encode("UTF-16LE")) # => false
ascii.hash.eql?(ascii.b.hash) # => true
utf8.eql?(utf8.b) # => false

# Appending an Integer appends a code point in the receiver's encoding.
(+"" << 0x1F600).encoding # => #<Encoding:UTF-8>
(+"".b << 233).bytes # => [233]
(+"x".encode("US-ASCII") << 233).encoding # => #<Encoding:BINARY (ASCII-8BIT)>

# frozen_string_literal: true

# Unicode escapes: \u{...} takes one or more code points separated by spaces.
"\u{48 49}".codepoints # => [72, 73]
"\u{1F600}".bytes # => [240, 159, 152, 128]
"\u{1F600}".encoding # => #<Encoding:UTF-8>
?\u{E9}.bytes # => [195, 169]

# String#ord and Integer#chr convert between a character and its code point.
"\u{E9}".ord # => 233
233.chr(Encoding::UTF_8) # => "é"
0x1F600.chr("UTF-8") # => "😀"
65.chr.encoding # => #<Encoding:US-ASCII>
233.chr.encoding # => #<Encoding:BINARY (ASCII-8BIT)>
233.chr.valid_encoding? # => true

outcomes = [
  -> { 0x1F600.chr },
  -> { 0x110000.chr("UTF-8") },
  -> { 0xD800.chr("UTF-8") },
  -> { "".ord },
  -> { "\xFF".ord }
].map do |attempt|
  attempt.call
rescue StandardError => e
  "#{e.class}: #{e.message}"
end
outcomes.to_a
# => ["RangeError: 128512 out of char range", "RangeError: 1114112 out of char range",
#     "RangeError: invalid codepoint 0xD800 in UTF-8", "ArgumentError: empty string",
#     "ArgumentError: invalid byte sequence in UTF-8"]

# pack and unpack use "U" for UTF-8 code points and "C" for bytes.
"na\u{EF}ve".unpack("U*") # => [110, 97, 239, 118, 101]
"na\u{EF}ve".unpack("C*") # => [110, 97, 195, 175, 118, 101]
[110, 97, 239, 118, 101].pack("U*") # => "naïve"
[110, 97, 239, 118, 101].pack("C*").encoding # => #<Encoding:BINARY (ASCII-8BIT)>
[110, 97, 239, 118, 101].pack("U*").encoding # => #<Encoding:UTF-8>
["abc"].pack("m0").encoding # => #<Encoding:US-ASCII>

# Iterating the three views of a string.
text = "Cafe\u{301}"
text.each_char.to_a # => ["C", "a", "f", "e", "́"]
text.each_codepoint.to_a # => [67, 97, 102, 101, 769]
text.each_grapheme_cluster.to_a # => ["C", "a", "f", "é"]
text.each_byte.to_a.length # => 6

# frozen_string_literal: true

# A converter keeps state, so it can transcode a stream that arrives in arbitrary chunks.
converter = Encoding::Converter.new("ISO-8859-1", "UTF-8")
converter.source_encoding # => #<Encoding:ISO-8859-1>
converter.destination_encoding # => #<Encoding:UTF-8>
converter.convpath # => [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>]]

chunks = ["Gabriel Garc", "\xEDa M", "\xE1rquez"].map(&:b)
decoded = chunks.sum("") { |chunk| converter.convert(chunk) } + converter.finish
decoded.to_s # => "Gabriel García Márquez"

# Characters split across chunk boundaries are held back until they are complete.
utf8_stream = Encoding::Converter.new("UTF-8", "UTF-16LE")
euro = "\u{20AC}"
pieces = euro.b.chars
pieces.map { |piece| utf8_stream.convert(piece).bytes } # => [[], [], [172, 32]]
utf8_stream.finish.bytes # => []

# Converters can chain through UTF-8 when no direct converter exists.
steps = Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP")
steps.map { |pair| pair.map(&:name) } # => [["ISO-8859-1", "UTF-8"], ["UTF-8", "EUC-JP"]]

# Options are the same ones String#encode accepts.
lossy = Encoding::Converter.new("UTF-8", "ISO-8859-1", undef: :replace, replace: "?")
lossy.convert("na\u{EF}ve \u{2603}").encode("UTF-8") # => "naïve ?"

# Errors can be inspected instead of raised, using the low-level API.
strict = Encoding::Converter.new("UTF-8", "ISO-8859-1")
destination = +""
strict.primitive_convert(+"ok \u{2603} not ok", destination) # => :undefined_conversion
destination.encoding # => #<Encoding:ISO-8859-1>
strict.last_error.class # => Encoding::UndefinedConversionError
strict.last_error.message # => "U+2603 from UTF-8 to ISO-8859-1"
strict.primitive_errinfo.first(3) # => [:undefined_conversion, "UTF-8", "ISO-8859-1"]

# Lookup failures.
begin
  Encoding::Converter.new("UTF-8", "no-such-encoding")
rescue Encoding::ConverterNotFoundError => e
  e.message # => "code converter not found (UTF-8 to no-such-encoding)"
end

# frozen_string_literal: true

text = "na\u{EF}ve caf\u{E9}"
text.length # => 10
text.bytesize # => 12

# getbyte, setbyte and byteslice work on bytes, whatever the encoding.
text.getbyte(2) # => 195
text.byteslice(0, 2) # => "na"
text.byteslice(2, 2) # => "ï"
text.byteslice(0, 3).valid_encoding? # => false
text.byteslice(1..) # => "aïve café"
text.getbyte(100) # => nil

# byteindex and byterindex (3.2) return byte offsets, and raise if the offset splits a character.
text.byteindex("caf") # => 7
text.index("caf") # => 6
text.byterindex("a") # => 8

begin
  text.byteindex("v", 3)
rescue IndexError => e
  e.message # => "offset 3 does not land on character boundary"
end

# bytesplice (3.2) replaces a byte range; (3.3) it can copy a range from another string.
copy = text.dup
copy.bytesplice(0, 2, "NA")
copy.to_s # => "NAïve café"
copy.bytesplice(0, 2, "nan", 0, 2)
copy.to_s # => "naïve café"
copy.bytesplice(2...4, "i")
copy.to_s # => "naive café"

begin
  copy.bytesplice(10, 1, "x")
rescue IndexError => e
  e.message # => "offset 10 does not land on character boundary"
end

# setbyte changes one byte in place and can corrupt a multibyte character.
bytes = text.dup
bytes.setbyte(0, 0x4E)
bytes.to_s # => "Naïve café"
bytes.setbyte(3, 0x41)
bytes.valid_encoding? # => false

# append_as_bytes (3.4) adds raw bytes with no encoding check or conversion.
packet = String.new(encoding: Encoding::BINARY)
packet.append_as_bytes("OK", 0x20, "\u{E9}", 0x1_FF)
packet.bytes # => [79, 75, 32, 195, 169, 255]
packet.encoding # => #<Encoding:BINARY (ASCII-8BIT)>

utf8 = +"caf"
utf8.append_as_bytes(0xC3)
utf8.valid_encoding? # => false
utf8.append_as_bytes(0xA9)
utf8.valid_encoding? # => true

# Cutting at a byte limit without splitting a character.
truncate = ->(string, limit) { string.byteslice(0, limit).scrub("") }
truncate.call(text, 11) # => "naïve caf"
truncate.call(text, 10) # => "naïve caf"
truncate.call("\u{1F600}\u{1F600}", 6) # => "😀"

# frozen_string_literal: true

hex = ->(text) { text.codepoints.map { |cp| format("%04X", cp) } }
forms = %i[nfc nfd nfkc nfkd]
table = ->(text) { forms.to_h { |form| [form, hex.call(text.unicode_normalize(form))] } }

# Code points of three characters under the four normalization forms.
table.call("e\u{301}") # => {nfc: ["00E9"], nfd: ["0065", "0301"], nfkc: ["00E9"], nfkd: ["0065", "0301"]}
table.call("\u{FB01}") # => {nfc: ["FB01"], nfd: ["FB01"], nfkc: ["0066", "0069"], nfkd: ["0066", "0069"]}
table.call("\u{BD}") # => {nfc: ["00BD"], nfd: ["00BD"], nfkc: ["0031", "2044", "0032"], nfkd: ["0031", "2044", "0032"]}

"\u{FB01}".unicode_normalize(:nfkc) # => "fi"
"\u{FF32}\u{FF55}\u{FF42}\u{FF59}".unicode_normalize(:nfkc) # => "Ruby"
"\u{BD}".unicode_normalize(:nfkc) # => "1⁄2"
"\u{2460}".unicode_normalize(:nfkd) # => "1"
"\u{D55C}".unicode_normalize(:nfd).codepoints.length # => 3

# The default form is NFC. The angstrom sign has a singleton decomposition.
"\u{212B}".unicode_normalize.codepoints # => [197]
"A\u{30A}".unicode_normalize.codepoints # => [197]

# Check before normalizing.
"e\u{301}".unicode_normalized? # => false
"e\u{301}".unicode_normalize.unicode_normalized? # => true
"e\u{301}".unicode_normalized?(:nfd) # => true

# unicode_normalize! works in place and returns the receiver.
title = +"Cafe\u{301}"
title.unicode_normalize!.equal?(title) # => true
title.length # => 4

# UTF-16 and UTF-32 strings are normalized too; other encodings are refused.
"e\u{301}".encode("UTF-16LE").unicode_normalize.bytes # => [233, 0]

begin
  "caf\u{E9}".encode("ISO-8859-1").unicode_normalize
rescue Encoding::CompatibilityError => e
  e.message # => "Unicode Normalization not appropriate for ISO-8859-1"
end

begin
  "caf\u{E9}".unicode_normalize(:nfx)
rescue ArgumentError => e
  e.message # => "Invalid normalization form nfx."
end

begin
  "caf\xE9".unicode_normalize
rescue ArgumentError => e
  e.message # => "invalid byte sequence in UTF-8"
end

# Normalization is not case folding or accent removal: it keeps the letters.
"\u{C9}COLE".unicode_normalize(:nfd).codepoints.first(2) # => [69, 769]

# frozen_string_literal: true

# Full Unicode case mapping is the default and can change the length.
"stra\u{DF}e".upcase # => "STRASSE"
"stra\u{DF}e".upcase.length # => 7
"\u{FB01}".upcase # => "FI"
"\u{149}".upcase.codepoints # => [700, 78]

# :ascii restricts the mapping to A-Z and a-z.
"stra\u{DF}e \u{E9}cole".upcase(:ascii) # => "STRAßE éCOLE"
"\u{C9}COLE Ruby".downcase(:ascii) # => "École ruby"

# Titlecase letters exist for digraphs: capitalize uses them, upcase does not.
"\u{1C6}".capitalize # => "Dž"
"\u{1C6}".upcase # => "DŽ"
"\u{1C5}".swapcase # => "dŽ"
"\u{1C6}ungla".capitalize # => "Džungla"

# :turkic maps dotted and dotless I the Turkish and Azeri way.
"I".downcase # => "i"
"I".downcase(:turkic) # => "ı"
"i".upcase(:turkic) # => "İ"
"\u{130}".downcase.codepoints # => [105, 775]
"\u{130}".downcase(:turkic) # => "i"

# Context-dependent rules, such as the final form of Greek sigma, are not applied.
"\u{391}\u{3A3}".downcase # => "ασ"
"\u{3A3}\u{391}".downcase # => "σα"

# :fold is a downcase-only option meant for caseless comparison.
"Stra\u{DF}e".downcase # => "straße"
"Stra\u{DF}e".downcase(:fold) # => "strasse"
"\u{3C2}".downcase(:fold).eql?("\u{3C3}".downcase(:fold)) # => true

# casecmp? folds with full Unicode rules, casecmp only the ASCII letters.
"Stra\u{DF}e".casecmp?("STRASSE") # => true
"Stra\u{DF}e".casecmp("STRASSE") # => 1
"\u{C9}cole".casecmp?("\u{E9}COLE") # => true
"\u{C9}cole".casecmp("\u{E9}COLE") # => -1
"abc".casecmp?(42) # => nil

# Invalid combinations of options are rejected.
messages = [:foo, %i[fold ascii]].map do |mapping|
  "abc".downcase(*mapping)
rescue ArgumentError => e
  e.message
end
messages.to_a # => ["invalid option", "too many options"]

begin
  "abc".upcase(:fold)
rescue ArgumentError => e
  e.message # => "option :fold only allowed for downcasing"
end

# Non-ASCII mapping covers the Unicode encodings and ISO-8859; BINARY strings map only ASCII letters.
"caf\u{E9}".encode("ISO-8859-1").upcase.encode("UTF-8") # => "CAFÉ"
"caf\u{E9}".b.upcase.bytes # => [67, 65, 70, 195, 169]

# frozen_string_literal: true

title = "Cr\u{E8}me br\u{FB}l\u{E9}e na\u{EF}ve"

# \w, \d and \s are ASCII-only unless (?u) is given; POSIX brackets and \p{} are Unicode-aware.
title.scan(/\w+/) # => ["Cr", "me", "br", "l", "e", "na", "ve"]
title.scan(/(?u)\w+/) # => ["Crème", "brûlée", "naïve"]
title.scan(/[[:alpha:]]+/) # => ["Crème", "brûlée", "naïve"]
title.scan(/\p{Alpha}+/) # => ["Crème", "brûlée", "naïve"]
title.scan(/\p{Lu}/) # => ["C"]
title.scan(/\b\p{Alpha}/) # => ["C", "b", "n"]

# Scripts, general categories and properties.
mixed = "\u{65E5}\u{672C}\u{8A9E} text \u{41F}\u{440}\u{438}\u{432}\u{435}\u{442}"
mixed.scan(/\p{Han}+|\p{Cyrillic}+/) # => ["日本語", "Привет"]
"caf\u{E9}".match?(/\A\p{Ll}+\z/) # => true
"caf\u{E9}".match?(/\A\p{^ASCII}+\z/) # => false
"\u{20AC}5 \u{A3}7".scan(/\p{Sc}/) # => ["€", "£"]
"x\u{2192}y".scan(/\p{Sm}|\p{So}/) # => ["→"]
"ok \u{1F600} \u{1F44D}".scan(/\p{Emoji_Presentation}/) # => ["😀", "👍"]

# \X matches one extended grapheme cluster, \R any line break sequence.
"e\u{301}a\u{1F1EA}\u{1F1F8}".scan(/\X/).length # => 3
"one\r\ntwo\nthree".split(/\R/) # => ["one", "two", "three"]

# Strip combining marks after decomposition.
"Cr\u{E8}me".unicode_normalize(:nfd).gsub(/\p{M}/, "") # => "Creme"

# A regexp has an encoding too: ASCII-only sources are US-ASCII and match anything compatible.
/abc/.encoding # => #<Encoding:US-ASCII>
/abc/.fixed_encoding? # => false
/caf\u{E9}/.encoding # => #<Encoding:UTF-8>
/caf\u{E9}/.fixed_encoding? # => true
/abc/n.encoding # => #<Encoding:US-ASCII>
/abc/u.fixed_encoding? # => true

latin1 = "caf\u{E9}".encode("ISO-8859-1")
begin
  latin1.match?(/caf\u{E9}/)
rescue Encoding::CompatibilityError => e
  e.message # => "incompatible encoding regexp match (UTF-8 regexp with ISO-8859-1 string)"
end

latin1.match?(Regexp.new("caf\u{E9}".encode("ISO-8859-1"))) # => true
Regexp.new("caf\u{E9}".encode("ISO-8859-1")).encoding # => #<Encoding:ISO-8859-1>

# Unknown property names are rejected when the regexp is compiled.
begin
  Regexp.new('\p{Nope}')
rescue RegexpError => e
  e.message # => "invalid character property name {Nope}: /\\p{Nope}/"
end