color-japanese 1.0.0

data/test/helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require "color/rgb/jp"
+
+module Fixture
+  module UTF_8
+    SakuraIroKanji = "\xe6\xa1\x9c\xe8\x89\xb2"
+    SakuraIroHiragana = "\xe3\x81\x95\xe3\x81\x8f\xe3\x82\x89\xe3\x81\x84\xe3\x82\x8d"
+    SakuraIroKatakana = "\xe3\x82\xb5\xe3\x82\xaf\xe3\x83\xa9\xe3\x82\xa4\xe3\x83\xad"
+  end
+
+  module Shift_JIS
+    SakuraIroKanji = "\x8d\xf7\x90F"
+    SakuraIroHiragana = "\x82\xb3\x82\xad\x82\xe7\x82\xa2\x82\xeb"
+    SakuraIroKatakana = "\x83T\x83N\x83\x89\x83C\x83\x8d"
+  end
+
+  module EUC_JP
+    SakuraIroKanji = "\xba\xf9\xbf\xa7"
+    SakuraIroHiragana = "\xa4\xb5\xa4\xaf\xa4\xe9\xa4\xa4\xa4\xed"
+    SakuraIroKatakana = "\xa5\xb5\xa5\xaf\xa5\xe9\xa5\xa4\xa5\xed"
+  end
+end

data/test/test_color_name.rb

@@ -0,0 +1,77 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestColorName < Test::Unit::TestCase
+
+  ColorName = Color::RGB::JP::Base::ColorName
+
+  def test_new_and_accessor
+    c = ColorName.new("const", "漢字", "ひらがな", "カタカナ", "romaji")
+    assert_equal("const", c.const_name)
+    assert_equal("漢字", c.kanji)
+    assert_equal("ひらがな", c.hiragana)
+    assert_equal("カタカナ", c.katakana)
+    assert_equal("romaji", c.romaji)
+  end
+
+  def test_encoding
+    c = ColorName.new("SakuraIro", "桜色", "さくらいろ", "サクライロ", "sakura-iro")
+    assert_equal("SakuraIro", c.const_name)
+    assert_equal(Fixture::UTF_8::SakuraIroKanji, c.kanji)
+    assert_equal(Fixture::UTF_8::SakuraIroHiragana, c.hiragana)
+    assert_equal(Fixture::UTF_8::SakuraIroKatakana, c.katakana)
+    assert_equal("sakura-iro", c.romaji)
+
+    assert_equal(Fixture::Shift_JIS::SakuraIroKanji, c.kanji("Shift_JIS"))
+    assert_equal(Fixture::Shift_JIS::SakuraIroHiragana, c.hiragana("Shift_JIS"))
+    assert_equal(Fixture::Shift_JIS::SakuraIroKatakana, c.katakana("Shift_JIS"))
+
+    assert_equal(Fixture::EUC_JP::SakuraIroKanji, c.kanji("EUC-JP"))
+    assert_equal(Fixture::EUC_JP::SakuraIroHiragana, c.hiragana("EUC-JP"))
+    assert_equal(Fixture::EUC_JP::SakuraIroKatakana, c.katakana("EUC-JP"))
+  end
+
+  def test_to_s
+    c = ColorName.new("SakuraIro", "桜色", "さくらいろ", "サクライロ", "sakura-iro")
+    assert_equal("sakura-iro", c.to_s)
+
+    c = ColorName.new("", "", "", "", "kuro")
+    assert_equal("kuro", c.to_s)
+  end
+
+  def test_names_and_to_a
+    c = ColorName.new("SakuraIro", "桜色", "さくらいろ", "サクライロ", "sakura-iro")
+
+    assert_equal([Fixture::UTF_8::SakuraIroKanji,
+                  Fixture::UTF_8::SakuraIroHiragana,
+                  Fixture::UTF_8::SakuraIroKatakana,
+                  "sakura-iro"],
+                 c.names)
+
+    assert_equal([Fixture::Shift_JIS::SakuraIroKanji,
+                  Fixture::Shift_JIS::SakuraIroHiragana,
+                  Fixture::Shift_JIS::SakuraIroKatakana,
+                  "sakura-iro"],
+                 c.names("Shift_JIS"))
+
+    assert_equal([Fixture::EUC_JP::SakuraIroKanji,
+                  Fixture::EUC_JP::SakuraIroHiragana,
+                  Fixture::EUC_JP::SakuraIroKatakana,
+                  "sakura-iro"],
+                 c.names("EUC-JP"))
+
+    assert_equal([Fixture::UTF_8::SakuraIroKanji,
+                  Fixture::UTF_8::SakuraIroHiragana,
+                  Fixture::UTF_8::SakuraIroKatakana,
+                  "sakura-iro"],
+                 c.to_a)
+
+    assert_equal([Fixture::UTF_8::SakuraIroKanji,
+                  Fixture::UTF_8::SakuraIroHiragana,
+                  Fixture::UTF_8::SakuraIroKatakana,
+                  "sakura-iro"],
+                 c.to_a("UTF-8"))
+  end
+
+end

data/test/test_compiler.rb

@@ -0,0 +1,181 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+require "color/rgb/jp/compiler/compiler"
+
+class TestCompiler < Test::Unit::TestCase
+
+  def trad(encoding = "UTF-8", prefix = "##")
+    Color::RGB::JP::Compiler::Compiler.new(
+        Color::RGB::JP::Traditional,
+        encoding, prefix, "test generator")
+  end
+
+  def test_execute
+    r = ""
+    trad.execute(StringIO.new(<<-SRC), StringIO.new(r), true)
+    [##sakura-iro]
+    SRC
+
+    assert_equal(<<-EXPECTED, r)
+    [#fef4f4]
+    EXPECTED
+  end
+
+  def test_execute_sjis
+    $KCODE = "s"
+    c = trad("Shift_JIS")
+    r = ""
+    c.execute(StringIO.new(<<-SRC), StringIO.new(r), true)
+    color: ###{Fixture::Shift_JIS::SakuraIroKanji};
+    background-color: ###{Fixture::Shift_JIS::SakuraIroHiragana};
+    bgcolor="###{Fixture::Shift_JIS::SakuraIroKatakana}"
+    SRC
+
+    assert_equal(<<-EXPECTED, r)
+    color: #fef4f4;
+    background-color: #fef4f4;
+    bgcolor="#fef4f4"
+    EXPECTED
+  end
+
+  def test_execute_utf8
+    $KCODE = "e"
+    c = trad("EUC-JP")
+    r = ""
+    c.execute(StringIO.new(<<-SRC), StringIO.new(r), true)
+    color: ###{Fixture::EUC_JP::SakuraIroKanji};
+    background-color: ###{Fixture::EUC_JP::SakuraIroHiragana};
+    bgcolor="###{Fixture::EUC_JP::SakuraIroKatakana}"
+    SRC
+
+    assert_equal(<<-EXPECTED, r)
+    color: #fef4f4;
+    background-color: #fef4f4;
+    bgcolor="#fef4f4"
+    EXPECTED
+  end
+
+  def test_execute_prefix
+    $KCODE = "u"
+    c = trad("UTF-8", "@@")
+    r = ""
+    c.execute(StringIO.new(<<-SRC), StringIO.new(r), true)
+    [##sakura-iro]
+    [@ @sakura-iro]
+    [@@ sakura-iro]
+    [@@sakura-iro]
+    SRC
+
+    assert_equal(<<-EXPECTED, r)
+    [##sakura-iro]
+    [@ @sakura-iro]
+    [@@ sakura-iro]
+    [#fef4f4]
+    EXPECTED
+  end
+
+  def test_execute_alias
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC), StringIO.new(r), true)
+##alias myred sakura-iro
+##alias mywarn myred
+    [##myred]
+    [##mywarn]
+    SRC
+
+    assert_equal(<<-EXPECTED, r)
+    [#fef4f4]
+    [#fef4f4]
+    EXPECTED
+  end
+
+  def test_execute_trim_mode
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+    ##sakura-iro
+    ##sakura-iro
+    ##sakura-iro
+    SRC
+
+    assert_equal("#fef4f4#fef4f4#fef4f4", r)
+  end
+
+  def test_execute_trim_mode2
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    c.trim_mode = ""
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+    ##sakura-iro
+    ##sakura-iro
+    ##sakura-iro
+    SRC
+
+    assert_equal("\n#fef4f4\n#fef4f4\n#fef4f4\n", r)
+  end
+
+  def test_execute_unknown_color
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+##alias baz bazzz
+##foobar
+##baz
+    SRC
+
+    assert_equal("##foobar##baz", r)
+  end
+
+  def test_execute_erb
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+<%= ##sakura-iro %>
+    SRC
+
+    assert_equal("#fef4f4", r)
+  end
+
+  def test_execute_erb_include_util
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+% include Color::RGB::JP::ERBUtil
+<%= lookup("sakura-iro").name.kanji %>
+    SRC
+
+    assert_equal(Fixture::UTF_8::SakuraIroKanji, r)
+  end
+
+  def test_execute_color_name_in_erb
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+<%= ##sakura-iro.class %>
+<%= ##sakura-iro.html %>
+    SRC
+
+    assert_equal("Color::RGB#fef4f4", r)
+  end
+
+  def test_execute_invalid_erb
+    $KCODE = "u"
+    c = trad("UTF-8", "##")
+    r = ""
+    c.execute(StringIO.new(<<-SRC.gsub(/^    /, "")), StringIO.new(r), true)
+    <%
+    ##sakura-iro
+    SRC
+
+    assert_equal("\nColor::RGB::JP::ERBUtil.to_rgb(%q{sakura-iro})\n", r)
+  end
+end

data/test/test_encode.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestEncode < Test::Unit::TestCase
+
+  include Color::RGB::JP::Base::Encode
+
+  def test_internal_encoding
+    assert_kind_of(String, Color::RGB::JP::Base::Encode::INTERNAL_ENCODING)
+  end
+
+  def test_encode_to_nil
+    assert_nil(encode_to(nil, nil, nil))
+    assert_nil(encode_to("Shift_JIS", "UTF-8", nil))
+
+    assert_equal("あいう", encode_to(nil, nil, "あいう"))
+    assert_equal("あいう", encode_to(nil, "UTF-8", "あいう"))
+    assert_equal("あいう", encode_to("UTF-8", nil, "あいう"))
+    assert_equal("あいう", encode_to("UTF-8", "UTF-8", "あいう"))
+  end
+
+  def test_encode_to
+    assert_equal("あいう", encode_to("UTF-8", "Shift_JIS", "\x82\xa0\x82\xa2\x82\xa4"))
+    assert_equal("あいう", encode_to("UTF-8", "EUC-JP", "\xa4\xa2\xa4\xa4\xa4\xa6"))
+  end
+
+  def test_with_internal_encoding
+    with_internal_encoding(nil, nil) {|v|
+      assert_nil(v)
+    }
+    with_internal_encoding(nil, "Shift_JIS") {|v|
+      assert_nil(v)
+    }
+    with_internal_encoding("\x82\xa0\x82\xa2\x82\xa4", "Shift_JIS") {|v|
+      assert_equal("あいう", v)
+    }
+    with_internal_encoding("あいう", "UTF-8") {|v|
+      assert_equal("あいう", v)
+    }
+  end
+end

data/test/test_jisz8102.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestJISZ8102 < Test::Unit::TestCase
+
+  T = Color::RGB::JP::JISZ8102
+
+  def test_alias
+    assert_same(Color::RGB::JP::JISZ8102, Color::RGB::JP::JIS)
+  end
+
+  def test_bracket_utf8
+    assert_equal(T::SakuraIro, T["sakurairo"])
+    assert_equal(T::SakuraIro, T["SakuraIro"])
+    assert_equal(T::SakuraIro, T["Sakura-Iro"])
+
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroKanji])
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroHiragana])
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroKatakana])
+
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroKanji, "UTF-8"])
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroHiragana, "UTF-8"])
+    assert_equal(T::SakuraIro, T[Fixture::UTF_8::SakuraIroKatakana, "UTF-8"])
+  end
+
+  def test_bracket_sjis
+    assert_equal(T::SakuraIro, T[Fixture::Shift_JIS::SakuraIroKanji, "Shift_JIS"])
+    assert_equal(T::SakuraIro, T[Fixture::Shift_JIS::SakuraIroHiragana, "Shift_JIS"])
+    assert_equal(T::SakuraIro, T[Fixture::Shift_JIS::SakuraIroKatakana, "Shift_JIS"])
+  end
+
+  def test_bracket_eucjp
+    assert_equal(T::SakuraIro, T[Fixture::EUC_JP::SakuraIroKanji, "EUC-JP"])
+    assert_equal(T::SakuraIro, T[Fixture::EUC_JP::SakuraIroHiragana, "EUC-JP"])
+    assert_equal(T::SakuraIro, T[Fixture::EUC_JP::SakuraIroKatakana, "EUC-JP"])
+  end
+
+end

data/test/test_named_rgb.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestNamedRGB < Test::Unit::TestCase
+
+  ColorName = Color::RGB::JP::Base::ColorName
+  NamedRGB = Color::RGB::JP::Base::NamedRGB
+
+  def setup
+    @name = ColorName.new("SakuraIro", "桜色", "さくらいろ", "サクライロ", "sakura-iro")
+    @rgb = Color::RGB.from_html("abcABC")
+    @named_rgb = NamedRGB.new(@name, @rgb)
+  end
+
+  def test_new_and_accessor
+    assert_same(@name, @named_rgb.name)
+    assert_same(@rgb, @named_rgb.rgb)
+  end
+
+  def test_to_s
+    assert_equal("sakura-iro (#abcabc)", @named_rgb.to_s)
+  end
+
+end

data/test/test_pallet.rb

@@ -0,0 +1,78 @@
+# -*- encoding: utf8 -*-
+
+require File.dirname(__FILE__) + '/helper.rb'
+
+class TestPallet < Test::Unit::TestCase
+
+  module MyPallet
+    extend Color::RGB::JP::Base::Pallet
+
+    Foo = define_color("Foo", "abcdef", "風雨", "ふー", "フー", "foo")
+    Bar_A = define_color("Bar_A", "ff00bb", "馬嗚呼", "ばー", "バー", "ba-r")
+    Bar_B = define_color("Bar_B", "ff00bb", "葉嗚呼", "ばー", "バー", "ba-r")
+  end
+
+  module MySakura
+    extend Color::RGB::JP::Base::Pallet
+
+    SakuraIro = c("SakuraIro",
+                  "aabbcc",
+                  Fixture::UTF_8::SakuraIroKanji,
+                  Fixture::UTF_8::SakuraIroHiragana,
+                  Fixture::UTF_8::SakuraIroKatakana,
+                  "sakura-iro")
+  end
+
+  def test_colors
+    assert_equal(3, MyPallet.colors.size)
+    assert_equal("Foo", MyPallet.colors[0].name.const_name)
+    assert_equal("Bar_A", MyPallet.colors[1].name.const_name)
+    assert_equal("Bar_B", MyPallet.colors[2].name.const_name)
+  end
+
+  def test_each
+    t = %W(Foo Bar_A Bar_B)
+    MyPallet.each do |c|
+      assert_equal(t.first ,c.name.const_name)
+      t.shift
+    end
+  end
+
+  def test_enumerable
+    r = MyPallet.find_all {|e| e.name.romaji =~ /f/}
+    assert_equal(1, r.length)
+    assert_equal(MyPallet::Foo, r.first)
+  end
+
+  def test_bracket
+    assert_equal(MyPallet::Foo, MyPallet["foo"])
+
+    assert_equal(MyPallet::Bar_A, MyPallet["ba-r"])
+    assert_equal(MyPallet::Bar_A, MyPallet["ばー"])
+    assert_equal(MyPallet::Bar_A, MyPallet["バー"])
+
+    assert_equal(MyPallet::Bar_A, MyPallet["Bar_A"])
+    assert_equal(MyPallet::Bar_B, MyPallet["Bar_B"])
+
+    assert_equal(MyPallet::Bar_A, MyPallet["馬嗚呼"])
+    assert_equal(MyPallet::Bar_B, MyPallet["葉嗚呼"])
+  end
+
+  def test_bracket_2
+    assert_equal(MyPallet::Bar_A, MyPallet["BAR"])
+    assert_equal(MyPallet::Bar_A, MyPallet["b-a-r-----"])
+  end
+
+  def test_bracket_sjis
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::Shift_JIS::SakuraIroKanji, "Shift_JIS"])
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::Shift_JIS::SakuraIroHiragana, "Shift_JIS"])
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::Shift_JIS::SakuraIroKatakana, "Shift_JIS"])
+  end
+
+  def test_bracket_eucjp
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::EUC_JP::SakuraIroKanji, "EUC-JP"])
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::EUC_JP::SakuraIroHiragana, "EUC-JP"])
+    assert_equal(MySakura::SakuraIro, MySakura[Fixture::EUC_JP::SakuraIroKatakana, "EUC-JP"])
+  end
+
+end