unicode 0.4.4-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 314559dfe96e14c8d0f640f1aa8498fb76fd1b23
+  data.tar.gz: 972889e38f2b9641c5d926b33ee5bd49a3b0df19
+SHA512:
+  metadata.gz: 11aefd96309397148db1cfa440e520775bbc75696eb040375e7ce994781294768f6ed594123f2f131ca90bc215670681472d8aff05e54b8743932f45607160f0
+  data.tar.gz: db4c1e76b612de731e5868fd737bf53e7bf9a55ce12430e47e08f3bc94c8320363d066b1235a4178cd0406aabebe70edccd600198a4582d2c1d73a96951647ec

data/README

@@ -0,0 +1,156 @@
+		   Unicode Library for Ruby
+			Version 0.4.4
+
+		       Yoshida Masato
+
+
+- Introduction
+
+  Unicode string manipulation library for Ruby.
+  This library is based on UAX #15 Unicode Normalization Forms(*1).
+
+    *1 <URL:http://www.unicode.org/unicode/reports/tr15/>
+
+
+- Install
+
+  This can work with ruby-1.8.7 or later. I recommend you to
+  use ruby-1.9.3 or later.
+
+  Make and install usually.
+  For example, when Ruby supports dynamic linking on your OS,
+
+    ruby extconf.rb
+    make
+    make install
+
+  To install using gem, for exapmle:
+
+    gem build unicdoe.gemspac
+    gem install unicode
+
+
+- Usage
+
+  If you do not link this module with Ruby statically, 
+
+    require "unicode"
+
+  before using.
+
+
+- Module Functions
+
+  All parameters of functions must be UTF-8 strings.
+
+  Unicode::strcmp(str1, str2)
+  Unicode::strcmp_compat(str1, str2)
+    Compare Unicode strings with a normalization.
+    strcmp uses the Normalization Form D, strcmp_compat uses
+    Normalization Form KD.
+
+  Unicode::decompose(str)
+  Unicode::decompose_compat(str)
+    Decompose Unicode string. Then the trailing characters
+    are sorted in canonical order.
+    decompose uses the canonical decomposition,
+    decompose_compat uses the compatibility decomposition.
+    The decomposition is based on the character decomposition
+    mapping in UnicodeData.txt and the Hangul decomposition
+    algorithm.
+
+  Unicode::decompose_safe(str)
+    Decompose Unicode string with a non-standard mapping.
+    It does not decompose the characters in
+    CompositionExclusions.txt.
+
+  Unicode::compose(str)
+    Compose Unicode string. Before composing, the trailing
+    characters are sorted in canonical order.
+    The parameter must be decomposed.
+    The composition is based on the reverse of the
+    character decomposition mapping in UnicodeData.txt,
+    CompositionExclusions.txt and the Hangul composition
+    algorithm.
+
+  Unicode::normalize_D(str)  (Unicode::nfd(str))
+  Unicode::normalize_KD(str)  (Unicode::nfkd(str))
+    Normalize Unicode string in form D or form KD.
+    These are aliases of decompose/decompose_compat.
+
+  Unicode::normalize_D_safe(str)  (Unicode::nfd_safe(str))
+    This is an alias of decompose_safe.
+
+  Unicode::normalize_C(str) (Unicode::nfc(str))
+  Unicode::normalize_KC(str) (Unicode::nfkc(str))
+    Normalize Unicode string in form C or form KC.
+      normalize_C  = decompose + compose
+      normalize_KC = decompose_compat + compose
+
+  Unicode::normalize_C_safe(str) (Unicode::nfc_safe(str))
+    Normalize Unicode string with decompose_safe.
+      normalize_C_safe  = decompose_safe + compose
+
+  Unicode::upcase(str)
+  Unicode::downcase(str)
+  Unicode::capitalize(str)
+    Case conversion functions.
+    The mappings that are used by these functions are not normative
+    in UnicodeData.txt.
+
+  Unicode::categories(str)
+  Unicode::abbr_categories(str)
+    Get an array of general category names of the string.
+    get_abbr_categories returns abbreviated names.
+    These can be called with a block.
+
+      Unicode.get_category do |category| p category end
+
+  Unicode::text_elements(str)
+    Get an array of text elements.
+    A text element is a unit that is displayed as a single character.
+    These can be called with a block.
+
+  Unicode::width(str[, cjk])
+    Estimate the display width on the fixed pitch text terminal.
+    It based on Markus Kuhn's mk_wcwidth.
+    If the optional argument 'cjk' is true, East Asian
+    Ambiguous characters are treated as wide characters.
+
+      Unicode.width("\u03b1") #=> 1
+      Unicode.width("\u03b1", true) #=> 2
+
+
+- Bugs
+
+  UAX #15 suggests that the look up for Normalization Form C
+  should not be implemented with a hash of string for better
+  performance.
+
+
+- Copying
+
+  This extension module is copyrighted free software by
+  Yoshida Masato.
+
+  You can redistribute it and/or modify it under the same
+  term as Ruby.
+
+
+- Author
+
+  Yoshida Masato <yoshidam@yoshidam.net>
+
+
+- History
+
+  Feb  7, 2013 version 0.4.4 update unidata.map for Unicode 6.2
+  Aug  8, 2012 version 0.4.3 add categories, text_elements and width
+  Feb 29, 2012 version 0.4.2 add decompose_safe
+  Feb  3, 2012 version 0.4.1 update unidata.map for Unicode 6.1
+  Oct 14, 2010 version 0.4.0 fix the composition algorithm, and support Unicode 6.0
+  Feb 26, 2010 version 0.3.0 fix a capitalize bug and support SpecialCasing
+  Dec 29, 2009 version 0.2.0 update for Ruby 1.9.1 and Unicode 5.2
+  Sep 10, 2005 version 0.1.2 update unidata.map for Unicode 4.1.0
+  Aug 26, 2004 version 0.1.1 update unidata.map for Unicode 4.0.1
+  Nov 23, 1999 version 0.1

data/Rakefile

@@ -0,0 +1,117 @@
+require "rake/clean"
+require "rake/extensiontask"
+require "rubygems/package_task"
+
+CLEAN << "pkg" << "tmp" << "lib/unicode"
+
+UPSTREAM_URL = 'http://www.yoshidam.net/unicode-%s.tar.gz'
+
+gem_spec = eval(File.read(File.expand_path("../unicode.gemspec", __FILE__)))
+
+gem_task = Gem::PackageTask.new(gem_spec) {|pkg|}
+
+Rake::ExtensionTask.new('unicode_native', gem_spec) do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = ['x86-mingw32', 'x86-mswin32-60']
+  ext.ext_dir = "ext/unicode"
+  ext.lib_dir = "lib/unicode"
+end
+
+namespace :gem do
+
+  desc 'Build all gem files'
+  task :all => %w[clean gem gem:java gem:windows]
+
+  java_gem_spec = gem_spec.dup
+  java_gem_spec.platform = 'java'
+  java_gem_spec.extensions.clear
+  java_gem_spec.files.delete_if { |f| f.start_with?('ext/') }
+
+  directory java_gem_dir = gem_task.package_dir
+
+  java_gem_file = File.basename(java_gem_spec.cache_file)
+  java_gem_path = File.join(java_gem_dir, java_gem_file)
+
+  desc "Build the gem file #{java_gem_file}"
+  task :java => java_gem_path
+
+  file java_gem_path => [java_gem_dir] + java_gem_spec.files do
+    lib_file = 'lib/unicode.rb'
+    tmp_file = "#{lib_file}.tmp-#{$$}"
+
+    begin
+      mv lib_file, tmp_file
+
+      File.write(lib_file, <<-EOT)
+  module Unicode
+
+    extend self
+
+    def upcase(str)
+      str.to_java.to_upper_case
+    end
+
+    def downcase(str)
+      str.to_java.to_lower_case
+    end
+
+  end
+      EOT
+
+      Gem::Package.build(java_gem_spec)
+
+      mv java_gem_file, java_gem_dir
+    ensure
+      mv tmp_file, lib_file if File.exist?(tmp_file)
+    end
+  end
+
+  desc "Build native gems for Windows"
+  task :windows do
+    ENV["RUBY_CC_VERSION"] = "1.8.7:1.9.3"
+    sh "rake cross compile"
+    sh "rake cross native gem"
+  end
+
+end
+
+desc "Update from upstream"
+task :update, [:version] do |t, args|
+  require 'zlib'
+  require 'open-uri'
+  require 'archive/tar/minitar'
+
+  unless version = args.version || ENV['UPSTREAM_VERSION']
+    abort "Please specify UPSTREAM_VERSION. See #{gem_spec.homepage}."
+  end
+
+  io = begin
+    open(url = UPSTREAM_URL % version)
+  rescue OpenURI::HTTPError
+    abort "Upstream version not found: #{url}. See #{gem_spec.homepage}."
+  end
+
+  Archive::Tar::Minitar.open(Zlib::GzipReader.new(io)) { |tar|
+    basedir = File.expand_path('..', __FILE__)
+
+    extract = lambda { |entry, name, dir|
+      puts "Extracting `#{name}' to `#{dir || '.'}'..."
+      tar.extract_entry(dir ? File.join(basedir, dir) : basedir, entry)
+    }
+
+    tar.each { |entry|
+      entry.name.sub!(/\Aunicode\//, '')
+
+      case name = entry.full_name
+        when /\Atools\/|\.gemspec\z/, 'README'
+          extract[entry, name, nil]
+        when /\.(?:[ch]|map)\z/, 'extconf.rb'
+          extract[entry, name, 'ext/unicode']
+        when /\Atest/
+          extract[entry, name, 'test']
+        else
+          puts "Skipping `#{name}'..."
+      end
+    }
+  }
+end

data/lib/unicode.rb

@@ -0,0 +1,13 @@
+  module Unicode
+
+    extend self
+
+    def upcase(str)
+      str.to_java.to_upper_case
+    end
+
+    def downcase(str)
+      str.to_java.to_lower_case
+    end
+
+  end

data/test/test.rb

@@ -0,0 +1,69 @@
+#! /usr/local/bin/ruby -KU
+# -*- coding: utf-8 -*-
+
+require 'unicode'
+
+## dump Unicode string
+class String
+  def udump
+    ustr = self.unpack("U*")
+    ret = []
+    ustr.each do |e|
+      if e.is_a?(Integer)
+        ret << "U+%04X" % e
+      else
+        ret << e
+      end
+    end
+    ret
+  end
+end
+
+
+print "Canonical decomposition vs compatibility decomposition\n"
+p Unicode::decompose("⑽ o\xef\xac\x83ce").udump
+p Unicode::decompose_compat("⑽ o\xef\xac\x83ce")
+
+print "Canonical equivalent vs Compatibility equivalent\n"
+p Unicode::strcmp("ｶﾞ", "ガ")
+p Unicode::strcmp("ガ", "ｶﾞ")
+p Unicode::strcmp_compat("ｶﾞ", "ガ")
+
+print "Decomposition/composition\n"
+p Unicode::normalize_D([0x63, 0x301, 0x327].pack("U*")).udump
+p Unicode::normalize_D([0x63, 0x327, 0x301].pack("U*")).udump
+p Unicode::normalize_D([0x107, 0x327].pack("U*")).udump
+p Unicode::normalize_D([0xe7, 0x301].pack("U*")).udump
+p Unicode::normalize_C([0x63, 0x301, 0x327].pack("U*")).udump
+p Unicode::normalize_C([0x63, 0x327, 0x301].pack("U*")).udump
+p Unicode::normalize_C([0x107, 0x327].pack("U*")).udump
+p Unicode::normalize_C([0xe7, 0x301].pack("U*")).udump
+
+print "Kana Normalization\n"
+p Unicode::normalize_D("ｶﾞガ").udump
+p Unicode::normalize_C("ｶﾞガ").udump
+p Unicode::normalize_KD("ｶﾞガ").udump
+p Unicode::normalize_KC("ｶﾞガ").udump
+
+print "Hangul\n"
+p "요시담".udump
+p Unicode::normalize_D("요시담").udump
+p Unicode::normalize_C("요시담").udump
+
+print "Composition Exclusion\n"
+print "   ANGSTROM SIGN [U+212B]\n"
+p Unicode::normalize_D([0x212b].pack("U")).udump
+p Unicode::normalize_C([0x212b].pack("U")).udump
+print "   LATIN CAPITAL LETTER A WITH RING ABOVE [U+00C5]\n"
+p Unicode::normalize_D([0x00c5].pack("U")).udump
+p Unicode::normalize_C([0x00c5].pack("U")).udump
+
+print "Case conversion\n"
+p Unicode::normalize_C(Unicode::upcase([0x63, 0x301, 0x327, 0xff41].pack("U*"))).udump
+p Unicode::normalize_C(Unicode::downcase([0x43, 0x301, 0x327, 0xff21].pack("U*"))).udump
+p Unicode::capitalize([0x1f1, 0x41, 0x61, 0xff21].pack("U*")).udump
+
+
+## Local variables:
+## coding: utf-8
+## End:

data/tools/README

@@ -0,0 +1,7 @@
+The bundled unidata.map is created from UnicodeData.txt,
+DerivedNormalizationProps.txt, SpecialCasing.txt and EastAsianWidth.txt
+of Unicode 6.0.
+
+To update unidata.map,
+
+  ruby mkunidata.rb UnicodeData.txt DerivedNormalizationProps.txt SpecialCasing.txt EastAsianWidth.txt  > unidata.map

data/tools/mkunidata.rb

@@ -0,0 +1,293 @@
+#! /usr/local/bin/ruby -KU
+
+#if $KCODE != 'UTF8'
+#  raise "$KCODE must be UTF8"
+#end
+
+HEAD=<<EOS
+/*
+ * UnicodeData
+ * Copyright 1999, 2004, 2010, 2012 by yoshidam
+ *
+ */
+
+#ifndef _UNIDATA_MAP
+#define _UNIDATA_MAP
+
+EOS
+
+HEAD1=<<EOS
+
+enum GeneralCategory {
+  /* Letter */
+  c_Lu = 1, c_Ll, c_Lt, c_LC, c_Lm, c_Lo,
+  /* Mark */
+  c_Mn, c_Mc, c_Me,
+  /* Number */
+  c_Nd, c_Nl, c_No,
+  /* Punctuation */
+  c_Pc, c_Pd, c_Ps, c_Pe, c_Pi, c_Pf, c_Po,
+  /* Symbol */
+  c_Sm, c_Sc, c_Sk, c_So,
+  /* Separator */
+  c_Zs, c_Zl, c_Zp,
+  /* Other */
+  c_Cc, c_Cf, c_Cs, c_Co, c_Cn
+};
+
+const char* const gencat_abbr[] = {
+  "", /* 0 */
+  /* Letter */
+  "Lu", "Ll", "Lt", "LC", "Lm", "Lo",
+  /* Mark */
+  "Mn", "Mc", "Me",
+  /* Number */
+  "Nd", "Nl", "No",
+  /* Punctuation */
+  "Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po",
+  /* Symbol */
+  "Sm", "Sc", "Sk", "So",
+  /* Separator */
+  "Zs", "Zl", "Zp",
+  /* Other */
+  "Cc", "Cf", "Cs", "Co", "Cn"
+};
+
+const char* const gencat_long[] = {
+  "",
+  "Uppercase_Letter",
+  "Lowercase_Letter",
+  "Titlecase_Letter",
+  "Cased_Letter",
+  "Modifier_Letter",
+  "Other_Letter",
+  "Nonspacing_Mark",
+  "Spacing_Mark",
+  "Enclosing_Mark",
+  "Decimal_Number",
+  "Letter_Number",
+  "Other_Number",
+  "Connector_Punctuation",
+  "Dash_Punctuation",
+  "Open_Punctuation",
+  "Close_Punctuation",
+  "Initial_Punctuation",
+  "Final_Punctuation",
+  "Other_Punctuation",
+  "Math_Symbol",
+  "Currency_Symbol",
+  "Modifier_Symbol",
+  "Other_Symbol",
+  "Space_Separator",
+  "Line_Separator",
+  "Paragraph_Separator",
+  "Control",
+  "Format",
+  "Surrogate",
+  "Private_Use",
+  "Unassigned"
+};
+
+enum EastAsianWidth {
+  w_N = 1, w_A, w_H, w_W, w_F, w_Na
+};
+
+struct unicode_data {
+  const int code;
+  const char* const canon;
+  const char* const compat;
+  const char* const uppercase;
+  const char* const lowercase;
+  const char* const titlecase;
+  const unsigned char combining_class;
+  const unsigned char exclusion;
+  const unsigned char general_category;
+  const unsigned char east_asian_width;
+};
+
+static const struct unicode_data unidata[] = {
+EOS
+
+TAIL=<<EOS
+};
+
+#endif
+EOS
+
+def hex2str(hex)
+  if hex.nil? || hex == ''
+    return [nil, nil]
+  end
+  canon = ""
+  compat = ""
+  chars = hex.split(" ")
+  if chars[0] =~ /^[0-9A-F]{4,6}$/
+    chars.each do |c|
+      canon << [c.hex].pack("U")
+    end
+    compat = canon
+  elsif chars[0] =~ /^<.+>$/
+    chars.shift
+    chars.each do |c|
+      compat << [c.hex].pack("U")
+    end
+    canon = nil
+  else
+    raise "unknown value: " + hex
+  end
+  [canon, compat]
+end
+
+def hex_or_nil(str)
+  return nil if str.nil? || str == ''
+  ret = ""
+  chars = str.split(" ")
+  chars.each do |c|
+    ret << [c.hex].pack("U")
+  end
+  return ret
+end
+
+def printstr(str)
+  return "NULL" if !str
+  ret = ""
+  str.each_byte do |c|
+    if c >= 32 && c < 127 && c != 34 && c != 92
+      ret << c
+    else
+      ret << format("\\%03o", c)
+    end
+  end
+  return '"' + ret + '"'
+end
+
+if ARGV.length != 4
+  puts "Usage: #{$0} <UnicodeData.txt> <DerivedNormalizationProps.txt> <SpecialCasing.txt> <EastAsianWidth.txt>"
+  exit 0
+end
+
+## scan Composition Exclusions
+exclusion = {}
+open(ARGV[1]) do |f|
+  while l = f.gets
+    next if l =~ /^\#/ || l =~ /^$/
+    next if l !~ /Full_Composition_Exclusion/
+    code, = l.split(/\s/)
+    if code =~ /^[0-9A-F]+$/
+      code = code.hex
+      exclusion[code] = true
+    elsif code =~ /^([0-9A-F]+)\.\.([0-9A-F]+)$/
+#      p [$1, $2]
+      scode = $1.hex
+      ecode = $2.hex
+      for code in scode..ecode
+        exclusion[code] = true
+      end
+    end
+  end
+end
+
+## scan Special Casing
+casing = {}
+open(ARGV[2]) do |f|
+  while l = f.gets
+    l.chomp!
+    next if l =~ /^\#/ || l =~ /^$/
+    l =~ /^(.*)#\s*(.*)$/
+    l = $1
+    comment = $2
+    code,lower,title,upper,cond = l.split(/;\s/)
+    next if cond
+    lower = nil if code == lower
+    title = nil if code == title
+    upper = nil if code == upper
+    code = code.hex
+    casing[code] = [hex_or_nil(lower), hex_or_nil(title), hex_or_nil(upper)]
+  end
+end
+
+## scan UnicodeData
+udata = {}
+range_data = []
+open(ARGV[0]) do |f|
+  while l = f.gets
+    l.chomp!
+    code, charname, gencat, ccclass, bidicat,decomp,
+      dec, digit, num, mirror, uni1_0, comment, upcase,
+      lowcase, titlecase = l.split(";", 15);
+    code = code.hex
+    ccclass = ccclass.to_i
+    canon, compat = hex2str(decomp)
+    upcase = hex_or_nil(upcase)
+    lowcase = hex_or_nil(lowcase)
+    titlecase = hex_or_nil(titlecase)
+    udata[code] = [ccclass, canon, compat, upcase, lowcase, titlecase, gencat]
+    if charname =~ /^<(.*, (First|Last))>$/
+      charname = $1.upcase.gsub(/,? /, '_')
+      range_data << [charname, code]
+    end
+  end
+end
+
+## scan EastAsianWidth
+ea_width = {}
+open(ARGV[3]) do |f|
+  while l = f.gets
+    l.chomp!
+    next if l =~ /^\#/ || l =~ /^$/
+    l =~ /^(.*)\s+#\s*(.*)$/
+    l = $1
+    comment = $2
+    code,width = l.split(/;/)
+    if code =~ /\.\./
+      start_code, end_code = code.split('..')
+      start_code = start_code.hex
+      end_code = end_code.hex
+      (start_code..end_code).each do |code|
+        ea_width[code] = width
+      end
+      next
+    end
+    code = code.hex
+    ea_width[code] = width
+  end
+end
+
+print HEAD
+range_data.each do |charname, code|
+  printf("#define %s\t(0x%04x)\n", charname, code)
+end
+
+print HEAD1
+udata.sort.each do |code, data|
+  ccclass, canon, compat, upcase, lowcase, titlecase, gencat = data
+  ## Exclusions
+  ex = 0
+  if exclusion[code]  ## Script-specifics or Post Composition Version
+    ex = 1
+  elsif canon =~ /^.$/ ## Singltons
+    ex = 2
+  elsif !canon.nil?
+    starter = canon.unpack("U*")[0]
+    if udata[starter][0] != 0 ## Non-stater decompositions
+      ex = 3
+    end
+  end
+  ## Special Casing
+  if casing[code]
+    lowcase = casing[code][0] if casing[code][0]
+    titlecase = casing[code][1] if casing[code][1]
+    upcase = casing[code][2] if casing[code][2]
+  end
+  width = 'N'
+  if ea_width[code]
+    width = ea_width[code]
+  end
+
+  printf("  { 0x%04x, %s, %s, %s, %s, %s, %d, %d, c_%s, w_%s }, \n",
+         code, printstr(canon),
+         printstr(compat), printstr(upcase), printstr(lowcase),
+         printstr(titlecase), ccclass, ex, gencat, width)
+end
+printf("  { -1, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0 }\n")
+print TAIL

data/tools/normtest.rb

@@ -0,0 +1,111 @@
+#! /usr/local/bin/ruby -KU
+
+## Conformance test with NormaliztionTest.txt
+## Copyrigth 2010 yoshidam
+
+require 'unicode'
+
+TESTFILE = "NormalizationTest.txt"
+
+def from_hex(str)
+  ret = ""
+  chars = str.split(" ")
+  chars.each do |c|
+    ret << [c.hex].pack("U")
+  end
+  return ret
+end
+
+def to_hex(str)
+  ret = ""
+  str = str.unpack('U*')
+  str.each do |c|
+    ret += sprintf("%04X ", c)
+  end
+  ret
+end
+
+open(TESTFILE) do |f|
+  while l = f.gets
+    next if l =~ /^#/
+    l.chomp
+    if l =~ /^@/
+      puts l
+      next
+    end
+    c1, c2, c3, c4, c5 = l.split(';')
+    code = c1
+    c1 = from_hex(c1)
+    c2 = from_hex(c2)
+    c3 = from_hex(c3)
+    c4 = from_hex(c4)
+    c5 = from_hex(c5)
+    ## NFC TEST
+    if c2 == Unicode.nfc(c1) && c2 == Unicode.nfc(c2) &&
+        c2 == Unicode.nfc(c3) &&
+        c4 == Unicode.nfc(c4) && c4 == Unicode.nfc(c4)
+      ##puts "NFC OK: " + code
+    else
+      puts "NFC NG: " + to_hex(c1)
+      printf("  c2=%s NFC(c1)=%s NFC(c2)=%s NFC(c3)=%s\n",
+             to_hex(c2),
+             to_hex(Unicode.nfc(c1)),
+             to_hex(Unicode.nfc(c2)),
+             to_hex(Unicode.nfc(c3)))
+      printf("  c4=%s NFC(c4)=%s NFC(c5)=%s\n",
+             to_hex(c4),
+             to_hex(Unicode.nfc(c4)),
+             to_hex(Unicode.nfc(c5)))
+    end
+
+    ## NFD TEST
+    if c3 == Unicode.nfd(c1) && c3 == Unicode.nfd(c2) &&
+        c3 == Unicode.nfd(c3) &&
+        c5 == Unicode.nfd(c4) && c5 == Unicode.nfd(c5)
+      ##puts "NFD OK: " + code
+    else
+      puts "NFD NG: " + to_hex(c1)
+      printf("  c3=%s NFD(c1)=%s NFD(c2)=%s NFD(c3)=%s\n",
+             to_hex(c3),
+             to_hex(Unicode.nfd(c1)),
+             to_hex(Unicode.nfd(c2)),
+             to_hex(Unicode.nfd(c3)))
+      printf("  c5=%s NFD(c4)=%s NFD(c5)=%s\n",
+             to_hex(c5),
+             to_hex(Unicode.nfd(c4)),
+             to_hex(Unicode.nfd(c5)))
+    end
+
+    ## NFKC TEST
+    if c4 == Unicode.nfkc(c1) && c4 == Unicode.nfkc(c2) &&
+        c4 == Unicode.nfkc(c3) &&
+        c4 == Unicode.nfkc(c4) && c4 == Unicode.nfkc(c5)
+      ##puts "NFKC OK: " + code
+    else
+      puts "NFKC NG: " + to_hex(c1)
+      printf("  c4=%s NFKC(c1)=%s NFKC(c2)=%s NFKC(c3)=%s NFKC(c4)=%s NFKC(c5)=%s\n",
+             to_hex(c4),
+             to_hex(Unicode.nfkc(c1)),
+             to_hex(Unicode.nfkc(c2)),
+             to_hex(Unicode.nfkc(c3)),
+             to_hex(Unicode.nfkc(c4)),
+             to_hex(Unicode.nfkc(c5)))
+    end
+
+    ## NFKD TEST
+    if c5 == Unicode.nfkd(c1) && c5 == Unicode.nfkd(c2) &&
+        c5 == Unicode.nfkd(c3) &&
+        c5 == Unicode.nfkd(c4) && c5 == Unicode.nfkd(c5)
+      ##puts "NFKD OK: " + code
+    else
+      puts "NFKD NG: " + to_hex(c1)
+      printf("  c5=%s NFKD(c1)=%s NFKD(c2)=%s NFKD(c3)=%s NFKD(c4)=%s NFKD(c5)=%s\n",
+             to_hex(c5),
+             to_hex(Unicode.nfkd(c1)),
+             to_hex(Unicode.nfkd(c2)),
+             to_hex(Unicode.nfkd(c3)),
+             to_hex(Unicode.nfkd(c4)),
+             to_hex(Unicode.nfkd(c5)))
+    end
+  end
+end

data/unicode.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{unicode}
+  s.version = "0.4.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Yoshida Masato}]
+  s.date = %q{2013-02-07}
+  s.email = %q{yoshidam@yoshidam.net}
+  s.licenses = %w[Ruby]
+  s.extensions = %w[ext/unicode/extconf.rb]
+  s.extra_rdoc_files = [%q{README}]
+  s.files = %w[
+    README Rakefile unicode.gemspec lib/unicode.rb
+    test/test.rb tools/README tools/mkunidata.rb tools/normtest.rb
+    ext/unicode/extconf.rb ext/unicode/unicode.c ext/unicode/unidata.map
+    ext/unicode/ustring.c ext/unicode/ustring.h ext/unicode/wstring.c ext/unicode/wstring.h
+  ]
+  s.homepage = %q{http://www.yoshidam.net/Ruby.html#unicode}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{Unicode normalization library.}
+  s.description = %q{Unicode normalization library.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+  end
+end
+

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: unicode
+version: !ruby/object:Gem::Version
+  version: 0.4.4
+platform: java
+authors:
+- Yoshida Masato
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-07 00:00:00.000000000 Z
+dependencies: []
+description: Unicode normalization library.
+email: yoshidam@yoshidam.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- README
+- Rakefile
+- lib/unicode.rb
+- test/test.rb
+- tools/README
+- tools/mkunidata.rb
+- tools/normtest.rb
+- unicode.gemspec
+homepage: http://www.yoshidam.net/Ruby.html#unicode
+licenses:
+- Ruby
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 3
+summary: Unicode normalization library.
+test_files: []