8:                def self.apply(obj, enc)
 9:                        @encoding_methods[enc][obj]
10:                end

11:                def self.encoding_method(enc)
12:                        @encoding_methods[enc]
13:                end

5:                def self.register(enc, &block)
6:                        @encoding_methods[enc] = block
7:                end

49:                 def check_encoding str
50:                         # We have to recognize UTF-16, LSB UTF-16, and UTF-8
51:                         return UTF_16 if str[0] == 254 && str[1] == 255
52:                         return UNILE if str[0] == 255 && str[1] == 254
54:                         return $1.upcase if $1
55:                         return UTF_8
56:                 end

19:     def decode_ascii(str)
20:       str.unpack('C*').pack('U*')
21:     end

6:       def decode_eucjp(str)
7:         Uconv::euctou8(str)
8:       end

19:       def decode_eucjp(str)
20:         NKF.nkf(EUCTOU8, str)
21:       end

6:     def decode_iconv(str)
7:       Iconv.conv(UTF_8, @encoding, str)
8:     end

6:       def decode_sjis content
7:         Uconv::sjistou8(content)
8:       end

19:       def decode_sjis(str)
20:         NKF.nkf(SJISTOU8, str)
21:       end

18:     def decode_unile(str)
19:       array_enc=str.unpack('C*')
20:       array_utf8 = []
21:       2.step(array_enc.size-1, 2){|i| 
22:         array_utf8 << (array_enc.at(i) + array_enc.at(i+1)*0x100)
23:       }
24:       array_utf8.pack('U*')
25:     end

18:     def decode_utf16(str)
19:       array_enc=str.unpack('C*')
20:       array_utf8 = []
21:       2.step(array_enc.size-1, 2){|i| 
22:         array_utf8 << (array_enc.at(i+1) + array_enc.at(i)*0x100)
23:       }
24:       array_utf8.pack('U*')
25:     end

7:     def decode_utf8(str)
8:       str
9:     end

 4:     def encode_ascii content
 5:       array_utf8 = content.unpack('U*')
 6:       array_enc = []
 7:       array_utf8.each do |num|
 8:         if num <= 0x7F
 9:           array_enc << num
10:         else
11:           # Numeric entity (&#nnnn;); shard by  Stefan Scholl
12:           array_enc.concat "&\##{num};".unpack('C*')
13:         end
14:       end
15:       array_enc.pack('C*')
16:     end

23:       def encode_eucjp content
24:         NKF.nkf(U8TOEUC, content)
25:       end

10:       def encode_eucjp content
11:         Uconv::u8toeuc(content)
12:       end

10:     def encode_iconv(content)
11:       Iconv.conv(@encoding, UTF_8, content)
12:     end

10:       def encode_sjis(str)
11:         Uconv::u8tosjis(str)
12:       end

23:       def encode_sjis content
24:         NKF.nkf(U8TOSJIS, content)
25:       end

 3:     def encode_unile content
 4:       array_utf8 = content.unpack("U*")
 5:       array_enc = []
 6:       array_utf8.each do |num|
 7:         if ((num>>16) > 0)
 8:           array_enc << ??
 9:           array_enc << 0
10:         else
11:           array_enc << (num & 0xFF)
12:           array_enc << (num >> 8)
13:         end
14:       end
15:       array_enc.pack('C*')
16:     end

 3:     def encode_utf16 content
 4:       array_utf8 = content.unpack("U*")
 5:       array_enc = []
 6:       array_utf8.each do |num|
 7:         if ((num>>16) > 0)
 8:           array_enc << 0
 9:           array_enc << ??
10:         else
11:           array_enc << (num >> 8)
12:           array_enc << (num & 0xFF)
13:         end
14:       end
15:       array_enc.pack('C*')
16:     end

3:     def encode_utf8 content
4:       content
5:     end

23:                 def encoding=( enc )
24:                         old_verbosity = $VERBOSE
25:                         begin
26:                                 $VERBOSE = false
27:                                 return if defined? @encoding and enc == @encoding
28:                                 if enc
29:                                         raise ArgumentError, "Bad encoding name #{enc}" unless /\A[\w-]+\z/n =~ enc
30:                                         @encoding = enc.upcase.untaint
31:                                 else
32:                                         @encoding = UTF_8
33:                                 end
34:                                 err = nil
35:                                 [@encoding, "ICONV"].each do |enc|
36:                                         begin
38:                                                 return Encoding.apply(self, enc)
39:                                         rescue LoadError, Exception => err
40:                                                 end
41:                                         end
42:                                 puts err.message
43:                                 raise ArgumentError, "No decoder found for encoding #@encoding.  Please install iconv."
44:                         ensure
45:                                 $VERBOSE = old_verbosity
46:                         end
47:                 end