red-colors 0.1.0

data/test/test-husl.rb

@@ -0,0 +1,241 @@
+class ColorsHUSLTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case(".new") do
+    test("with integer values") do
+      c = Colors::HUSL.new(1, 128, 255)
+      assert_equal(1r, c.hue)
+      assert_equal(128/255r, c.saturation)
+      assert_equal(255/255r, c.lightness)
+
+      c = Colors::HUSL.new(-1, 128, 255)
+      assert_equal(359r, c.hue)
+
+      c = Colors::HUSL.new(361, 128, 255)
+      assert_equal(1r, c.hue)
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, 0x100, 0)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, 0, 0x100)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, -1, 0)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, 0, -1)
+      end
+    end
+
+    test("with float values") do
+      c = Colors::HUSL.new(0.0.next_float, 0.55, 1)
+      assert_equal(0.0.next_float.to_r, c.hue)
+      assert_equal(0.55.to_r, c.saturation)
+      assert_equal(1.0.to_r, c.lightness)
+
+      c = Colors::HUSL.new(-0.1, 0.55, 1)
+      assert_equal(360 - 0.1, c.hue)
+
+      c = Colors::HUSL.new(360.1, 0.55, 1)
+      assert_equal(Rational(360.1) - 360, c.hue)
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0.0, 1.0.next_float, 0.0)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0.0, 0.0, 1.0.next_float)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, -0.1, 0)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0, 0, -0.1)
+      end
+    end
+
+    test("with rational values") do
+      c = Colors::HUSL.new(1r, 500/1000r, 1)
+      assert_equal(1r, c.hue)
+      assert_equal(500/1000r, c.saturation)
+      assert_equal(1r, c.lightness)
+
+      c = Colors::HUSL.new(-1r, 500/1000r, 1)
+      assert_equal(359r, c.hue)
+
+      c = Colors::HUSL.new(361r, 500/1000r, 1)
+      assert_equal(1r, c.hue)
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0r, 1001/1000r, 0r)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0r, 0r, 1001/1000r)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0r, -1/1000r, 0r)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::HUSL.new(0r, 0r, -1/1000r)
+      end
+    end
+  end
+
+  test("#hue=") do
+    c = Colors::HUSL.new(0, 0, 0)
+    c.hue = 1r
+    assert_equal(1r, c.hue)
+    c.hue = 1.0r
+    assert_equal(1r, c.hue)
+    c.hue = 1
+    assert_equal(1r, c.hue)
+    c.hue = -1
+    assert_equal(359r, c.hue)
+    c.hue = 360
+    assert_equal(0r, c.hue)
+    c.hue = 361
+    assert_equal(1r, c.hue)
+  end
+
+  test("#saturation=") do
+    c = Colors::HUSL.new(0, 0, 0)
+    c.saturation = 1r
+    assert_equal(1r, c.saturation)
+    c.saturation = 1.0r
+    assert_equal(1r, c.saturation)
+    c.saturation = 1
+    assert_equal(1/255r, c.saturation)
+    assert_raise(ArgumentError) do
+      c.saturation = 1001/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.saturation = -1/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.saturation = -0.1
+    end
+    assert_raise(ArgumentError) do
+      c.saturation = 1.0.next_float
+    end
+    assert_raise(ArgumentError) do
+      c.saturation = 256
+    end
+    assert_raise(ArgumentError) do
+      c.saturation = -1
+    end
+  end
+
+  test("#lightness=") do
+    c = Colors::HUSL.new(0, 0, 0)
+    c.lightness = 1r
+    assert_equal(1r, c.lightness)
+    c.lightness = 1.0r
+    assert_equal(1r, c.lightness)
+    c.lightness = 1
+    assert_equal(1/255r, c.lightness)
+    assert_raise(ArgumentError) do
+      c.lightness = 1001/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.lightness = -1/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.lightness = -0.1
+    end
+    assert_raise(ArgumentError) do
+      c.lightness = 1.0.next_float
+    end
+    assert_raise(ArgumentError) do
+      c.lightness = 256
+    end
+    assert_raise(ArgumentError) do
+      c.lightness = -1
+    end
+  end
+
+  test("==") do
+    assert { Colors::HUSL.new(0, 0, 0) == Colors::HUSL.new(0, 0, 0) }
+    #assert { Colors::HUSL.new(0, 0, 0) == Colors::HUSLA.new(0, 0, 0, 1r) }
+  end
+
+  test("!=") do
+    assert { Colors::HUSL.new(0, 0, 0) != Colors::HUSL.new(1, 0, 0) }
+    assert { Colors::HUSL.new(0, 0, 0) != Colors::HUSL.new(0, 1, 0) }
+    assert { Colors::HUSL.new(0, 0, 0) != Colors::HUSL.new(0, 0, 1) }
+    #assert { Colors::HUSL.new(0, 0, 0) != Colors::HUSLA.new(0, 0, 0, 0) }
+  end
+
+  test("#desaturate") do
+    c = Colors::HUSL.from_rgb(1r, 1r, 0r).desaturate(0.8)
+    assert_instance_of(Colors::HUSL, c)
+    assert_near(Colors::HUSL.new(85.87432021817473r, 0.9838589961976354r, 0.8850923805142681r), c)
+  end
+
+  test("to_husl") do
+    black = Colors::HUSL.new(0, 0, 0)
+    assert_same(black, black.to_hsl)
+  end
+
+  test(".from_rgb") do
+    # black
+    assert_equal(Colors::HUSL.new(0, 0, 0),
+                 Colors::HUSL.from_rgb(0, 0, 0))
+    # red
+    assert_near(Colors::HUSL.new(12.177050630061776r, 1r, 0.5323711559542933r),
+                Colors::HUSL.from_rgb(1r, 0, 0))
+    ## yellow
+    assert_near(Colors::HUSL.new(85.87432021817473r, 1r, 0.9713855934179674r),
+                Colors::HUSL.from_rgb(1r, 1r, 0))
+    ## green
+    assert_near(Colors::HUSL.new(127.71501294924047r, 1r, 0.8773551910965973r),
+                Colors::HUSL.from_rgb(0r, 1r, 0))
+    ## cyan
+    assert_near(Colors::HUSL.new(192.17705063006116r, 1r, 0.9111475231670507r),
+                Colors::HUSL.from_rgb(0r, 1r, 1r))
+    ## blue
+    assert_near(Colors::HUSL.new(265.8743202181779r, 1r, 0.3230087290398002r),
+                Colors::HUSL.from_rgb(0r, 0r, 1r))
+    ## magenta
+    assert_near(Colors::HUSL.new(307.7150129492436r, 1r, 0.60322731354551294r),
+                Colors::HUSL.from_rgb(1r, 0r, 1r))
+    ## white
+    assert_near(Colors::HUSL.new(0r, 0r, 1r),
+                Colors::HUSL.from_rgb(1r, 1r, 1r))
+  end
+
+  test("to_rgb") do
+    # black
+    assert_equal(Colors::RGB.new(0, 0, 0),
+                 Colors::HUSL.new(0, 0, 0).to_rgb)
+    # red
+    assert_near(Colors::RGB.new(1r, 0, 0),
+                Colors::HUSL.new(12.177050630061776r, 1r, 0.5323711559542933r).to_rgb)
+    # yellow
+    assert_near(Colors::RGB.new(1r, 1r, 0),
+                Colors::HUSL.new(85.87432021817473r, 1r, 0.9713855934179674r).to_rgb)
+    # green
+    assert_near(Colors::RGB.new(0r, 1r, 0),
+                Colors::HUSL.new(127.71501294924047r, 1r, 0.8773551910965973r).to_rgb)
+    # cyan
+    assert_near(Colors::RGB.new(0r, 1r, 1r),
+                Colors::HUSL.new(192.17705063006116r, 1r, 0.9111475231670507r).to_rgb)
+    # blue
+    assert_near(Colors::RGB.new(0r, 0r, 1r),
+                Colors::HUSL.new(265.8743202181779r, 1r, 0.3230087290398002r).to_rgb)
+    # magenta
+    assert_near(Colors::RGB.new(1r, 0r, 1r),
+                Colors::HUSL.new(307.7150129492436r, 1r, 0.60322731354551294r).to_rgb)
+    # white
+    assert_near(Colors::RGB.new(1r, 1r, 1r),
+                Colors::HUSL.new(0r, 1r, 1r).to_rgb)
+  end
+end

data/test/test-named-color.rb

@@ -0,0 +1,43 @@
+class ColorsNamedColorTest < Test::Unit::TestCase
+  sub_test_case("Colors[]") do
+    Colors::ColorData::DEFAULT_COLOR_CYCLE.each_with_index do |c, i|
+      name = "C#{i}"
+      expected = Colors::RGB.parse(c)
+      data("Color cycle: #{name}=#{c}", [name, expected])
+    end
+    Colors::ColorData::BASE_COLORS.each do |name, (r, g, b)|
+      expected = Colors::RGB.new(r, g, b)
+      data("Base color: #{name}=(#{r}, #{g}, #{b})", [name, expected])
+    end
+    Colors::ColorData::TABLEAU_COLORS.each do |name, hex_string|
+      expected = Colors::RGB.parse(hex_string)
+      data("Tableau color: #{name}=#{hex_string}", [name, expected])
+      if name.include? "gray"
+        name = name.sub("gray", "grey")
+        data("Tableau color: #{name}=#{hex_string}", [name, expected])
+      end
+    end
+    Colors::ColorData::CSS4_COLORS.each do |name, hex_string|
+      expected = Colors::RGB.parse(hex_string)
+      data("CSS4 color: #{name}=#{hex_string}", [name, expected])
+    end
+    Colors::ColorData::XKCD_COLORS.each do |name, hex_string|
+      expected = Colors::RGB.parse(hex_string)
+      data("XKCD color: #{name}=#{hex_string}", [name, expected])
+      if name.include? "grey"
+        name = name.sub("grey", "gray")
+        data("Tableau color: #{name}=#{hex_string}", [name, expected])
+      end
+    end
+    def test_lookup_named_color(data)
+      name, expected = data
+      assert_equal(expected, Colors[name])
+    end
+  end
+
+  test("Colors::NamedColors.nth_color?") do
+    assert do
+      Colors::NamedColors.nth_color?("C1")
+    end
+  end
+end

data/test/test-rgb.rb

@@ -0,0 +1,294 @@
+class ColorsRGBTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case(".new") do
+    test("with integer values") do
+      c = Colors::RGB.new(1, 128, 255)
+      assert_equal(1/255r, c.red)
+      assert_equal(128/255r, c.green)
+      assert_equal(255/255r, c.blue)
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0, 0, 0x100)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0, 0, -1)
+      end
+    end
+
+    test("with float values") do
+      c = Colors::RGB.new(0.0.next_float, 0.55, 1)
+      assert_equal(0.0.next_float.to_r, c.red)
+      assert_equal(0.55.to_r, c.green)
+      assert_equal(1.0.to_r, c.blue)
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0.0, 0.0, 1.0.next_float)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0, 0, -0.1)
+      end
+    end
+
+    test("with rational values") do
+      c = Colors::RGB.new(1/1000r, 500/1000r, 1)
+      assert_equal(1/1000r, c.red)
+      assert_equal(500/1000r, c.green)
+      assert_equal(1r, c.blue)
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0.0, 0.0, 1001/1000r)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.new(0, 0, -1/1000r)
+      end
+    end
+  end
+
+  test("#red=") do
+    c = Colors::RGB.new(0, 0, 0)
+    c.red = 1r
+    assert_equal(1r, c.red)
+    c.red = 1.0r
+    assert_equal(1r, c.red)
+    c.red = 1
+    assert_equal(1/255r, c.red)
+    assert_raise(ArgumentError) do
+      c.red = 1001/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.red = -1/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.red = -0.1
+    end
+    assert_raise(ArgumentError) do
+      c.red = 1.0.next_float
+    end
+    assert_raise(ArgumentError) do
+      c.red = 256
+    end
+    assert_raise(ArgumentError) do
+      c.red = -1
+    end
+  end
+
+  test("#green=") do
+    c = Colors::RGB.new(0, 0, 0)
+    c.green = 1r
+    assert_equal(1r, c.green)
+    c.green = 1.0r
+    assert_equal(1r, c.green)
+    c.green = 1
+    assert_equal(1/255r, c.green)
+    assert_raise(ArgumentError) do
+      c.green = 1001/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.green = -1/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.green = -0.1
+    end
+    assert_raise(ArgumentError) do
+      c.green = 1.0.next_float
+    end
+    assert_raise(ArgumentError) do
+      c.green = 256
+    end
+    assert_raise(ArgumentError) do
+      c.green = -1
+    end
+  end
+
+  test("#blue=") do
+    c = Colors::RGB.new(0, 0, 0)
+    c.blue = 1r
+    assert_equal(1r, c.blue)
+    c.blue = 1.0r
+    assert_equal(1r, c.blue)
+    c.blue = 1
+    assert_equal(1/255r, c.blue)
+    assert_raise(ArgumentError) do
+      c.blue = 1001/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.blue = -1/1000r
+    end
+    assert_raise(ArgumentError) do
+      c.blue = -0.1
+    end
+    assert_raise(ArgumentError) do
+      c.blue = 1.0.next_float
+    end
+    assert_raise(ArgumentError) do
+      c.blue = 256
+    end
+    assert_raise(ArgumentError) do
+      c.blue = -1
+    end
+  end
+
+  test("==") do
+    assert { Colors::RGB.new(0, 0, 0) == Colors::RGB.new(0, 0, 0) }
+    assert { Colors::RGB.new(0, 0, 0) == Colors::RGBA.new(0, 0, 0, 1r) }
+  end
+
+  test("!=") do
+    assert { Colors::RGB.new(0, 0, 0) != Colors::RGB.new(1, 0, 0) }
+    assert { Colors::RGB.new(0, 0, 0) != Colors::RGB.new(0, 1, 0) }
+    assert { Colors::RGB.new(0, 0, 0) != Colors::RGB.new(0, 0, 1) }
+    assert { Colors::RGB.new(0, 0, 0) != Colors::RGBA.new(0, 0, 0, 0) }
+  end
+
+  test("#desaturate") do
+    c = Colors::RGB.new(1r, 1r, 1r).desaturate(0.8)
+    assert_instance_of(Colors::RGB, c)
+    assert_near(Colors::HSL.new(0r, 0.8r, 1r).to_rgb, c)
+  end
+
+  sub_test_case(".parse") do
+    test("for #rgb") do
+      assert_equal(Colors::RGB.new(0, 0, 0),
+                   Colors::RGB.parse("#000"))
+      assert_equal(Colors::RGB.new(0x33, 0x66, 0x99),
+                   Colors::RGB.parse("#369"))
+      assert_equal(Colors::RGB.new(255, 255, 255),
+                   Colors::RGB.parse("#fff"))
+    end
+
+    test("for #rrggbb") do
+      assert_equal(Colors::RGB.new(0, 0, 0),
+                   Colors::RGB.parse("#000000"))
+      assert_equal(Colors::RGB.new(1, 0, 0),
+                   Colors::RGB.parse("#010000"))
+      assert_equal(Colors::RGB.new(0, 1, 0),
+                   Colors::RGB.parse("#000100"))
+      assert_equal(Colors::RGB.new(0, 0, 1),
+                   Colors::RGB.parse("#000001"))
+    end
+
+
+    test("error cases") do
+      # `#rgba` is error
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#0000")
+      end
+
+      # `#rrggbbaa` is error
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#00000000")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#00")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#00000")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#0000000")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse(nil)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse(1)
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("333")
+      end
+
+      assert_raise(ArgumentError) do
+        Colors::RGB.parse("#xxx")
+      end
+    end
+  end
+
+  test("#to_hex_string") do
+    assert_equal("#000000",
+                 Colors::RGB.new(0, 0, 0).to_hex_string)
+    assert_equal("#ff0000",
+                 Colors::RGB.new(1r, 0, 0).to_hex_string)
+    assert_equal("#00ff00",
+                 Colors::RGB.new(0, 1r, 0).to_hex_string)
+    assert_equal("#0000ff",
+                 Colors::RGB.new(0, 0, 1r).to_hex_string)
+    assert_equal("#ffffff",
+                 Colors::RGB.new(1r, 1r, 1r).to_hex_string)
+    assert_equal("#808080",
+                 Colors::RGB.new(0.5, 0.5, 0.5).to_hex_string)
+    assert_equal("#333333",
+                 Colors::RGB.new(0x33, 0x33, 0x33).to_hex_string)
+  end
+
+  test("to_rgb") do
+    black = Colors::RGB.new(0, 0, 0)
+    assert_same(black, black.to_rgb)
+  end
+
+  test("#to_rgba") do
+    black = Colors::RGB.new(0, 0, 0)
+    assert_equal(Colors::RGBA.new(0, 0, 0, 255),
+                 black.to_rgba)
+    assert_equal(Colors::RGBA.new(0, 0, 0, 0),
+                 black.to_rgba(alpha: 0))
+    assert_equal(Colors::RGBA.new(0, 0, 0, 0.5),
+                 black.to_rgba(alpha: 0.5))
+
+    assert_raise(ArgumentError) do
+      black.to_rgba(alpha: nil)
+    end
+
+    assert_raise(ArgumentError) do
+      black.to_rgba(alpha: 256)
+    end
+
+    assert_raise(ArgumentError) do
+      black.to_rgba(alpha: -0.1)
+    end
+
+    assert_raise(ArgumentError) do
+      black.to_rgba(alpha: 1.0.next_float)
+    end
+  end
+
+  test("#to_hsl") do
+    # black
+    assert_equal(Colors::HSL.new(0r, 0r, 0r),
+                 Colors::RGB.new(0r, 0r, 0r).to_hsl)
+    # red
+    assert_equal(Colors::HSL.new(0r, 1r, 0.5r),
+                 Colors::RGB.new(1r, 0r, 0r).to_hsl)
+    # yellow
+    assert_equal(Colors::HSL.new(60r, 1r, 0.5r),
+                 Colors::RGB.new(1r, 1r, 0r).to_hsl)
+    # green
+    assert_equal(Colors::HSL.new(120r, 1r, 0.5r),
+                 Colors::RGB.new(0r, 1r, 0r).to_hsl)
+    # cyan
+    assert_equal(Colors::HSL.new(180r, 1r, 0.5r),
+                 Colors::RGB.new(0r, 1r, 1r).to_hsl)
+    # blue
+    assert_equal(Colors::HSL.new(240r, 1r, 0.5r),
+                 Colors::RGB.new(0r, 0r, 1r).to_hsl)
+    # magenta
+    assert_equal(Colors::HSL.new(300r, 1r, 0.5r),
+                 Colors::RGB.new(1r, 0r, 1r).to_hsl)
+    # white
+    assert_equal(Colors::HSL.new(0r, 0r, 1r),
+                 Colors::RGB.new(1r, 1r, 1r).to_hsl)
+  end
+end