red-colors 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41b270524325cebd81989dc494c23c3204517e6416d12c860c3bf678004fa0e6
-  data.tar.gz: 605e7d7c3388fb95231e3fe24e3435799a631d8f8c2a4852741a449942ce7be7
+  metadata.gz: febec52016fd90dc6df804546e49649f6e887dbb80a200d95f97ca75cb558f09
+  data.tar.gz: 3535fdd548ae4cef6584f3991abca0e1e51e207f2e8e3dac19c0aae12ad44ab2
 SHA512:
-  metadata.gz: 28bad73970d8198db20f0605b0766b3aba050a7487380784539a36143daa3b4bbe351776adf6497439648bc37336fce104eda9de40ab10be3d42dc720cfb63d7
-  data.tar.gz: 6dbc678e7e3f8fa386bc1b5cd0adc941d3636b8a4c44f570f2eab919f41e966fafafb7cbdcbf347e379e7527fdd60923da0d7984764e48fff59df42f80d01d9b
+  metadata.gz: beb0692ed1779dbc6c33d6404ceee91c263a602536ad90edc3da61de0236985c4f40591ec38a9d4218972623311a5d218a4c43394617dfe0422e051e2ef415ce
+  data.tar.gz: 2aa6b5acaaa962cfee4ca23e315b3e6294eeda1a17937600d4d6ec9cc00c10deaefa8d9099a3e251371b9cf1e7beec9a5b77639499274d0394831c5b7af1f0ed

data/doc/text/news.md

@@ -0,0 +1,23 @@
+# News
+
+## 0.4.0 - 2024-02-18
+
+### Improvements
+
+  * Added support for CSS3 syntax.
+    * GH-5
+    * GH-12
+    * Patch by Ben Bowers.
+
+  * Suppressed warnings.
+    * GH-16
+    * Reported by rubyFeedback.
+
+### Fixes
+
+  * Fixed wrong `Colors::Xterm256#to_grey_level` conversion.
+
+### Thanks
+
+  * Ben Bowers
+  * rubyFeedback

data/lib/colors/colormap_data/matplotlib_builtin.rb

@@ -956,7 +956,7 @@ module Colors
       a_data = data[a_key]
       b_data = data[b_key]
       a_listed = a_data.is_a?(Hash) && a_data.key?(:listed)
-      b_listed = a_data.is_a?(Hash) && a_data.key?(:listed)
+      b_listed = b_data.is_a?(Hash) && b_data.key?(:listed)
       case
       when !a_listed && b_listed
         -1

data/lib/colors/colormap_registry.rb

@@ -30,7 +30,6 @@ module Colors
       end
 
       if @registry.key?(name)
-        existing = @registry[name]
         if BUILTIN_COLORMAPS.key?(name)
           unless override_builtin
             raise ArgumentError,

data/lib/colors/convert.rb

@@ -150,6 +150,12 @@ module Colors
       dot_product(RGB2XYZ, srgb_to_linear_srgb(r, g, b))
     end
 
+    def rgb_to_greyscale(r, g, b)
+      r, g, b = srgb_to_linear_srgb(r, g, b)
+      a = RGB2XYZ[1]
+      (a[0]*r + a[1]*g + a[2]*b).clamp(0, 1)
+    end
+
     def rgb_to_xterm256(r, g, b)
       i = closest_xterm256_rgb_index(r)
       j = closest_xterm256_rgb_index(g)

data/lib/colors/css.rb

@@ -0,0 +1,63 @@
+module Colors
+  module CSS
+    # Factory method for generating RGB/RGBA/HSL/HSLA Objects.
+    # Parsing based on spec https://www.w3.org/TR/css-color-3 ; section 4.2
+    def self.parse(css_string)
+      error_message = "must be a string of `rgb(rr,gg,bb)`, `rgba(rr,gg,bb,aa)`, `hsl(hh,ss,ll)`, or `hsla(hh,ss,ll,aa)` form"
+      unless css_string.respond_to?(:to_str)
+        raise ArgumentError, "#{error_message}: #{css_string.inspect}"
+      end
+
+      css_string = css_string.to_str.strip
+
+      matcher = /\A((?:rgb|hsl)a?)\(([^)]+)\)\z/.match(css_string)
+      unless matcher
+        raise ArgumentError, "#{error_message}: #{css_string.inspect}"
+      end
+
+      color_space, args_string = matcher[1..2]
+      args = args_string.strip.split(/\s*,\s*/)
+      has_alpha = color_space.end_with?("a") # rgba/hsla
+      if has_alpha && args.length != 4
+        raise ArgumentError, "Expecting 4 fields for #{color_space}(): #{css_string.inspect}"
+      elsif !has_alpha && args.length != 3
+        raise ArgumentError, "Expecting 3 fields for #{color_space}(): #{css_string.inspect}"
+      end
+
+      case color_space
+      when "rgb", "rgba"
+        rgb, alpha = args[0, 3], args[3]
+        num_percent_vals = rgb.count {|v| v.end_with?("%") }
+        # CSS3 allows RGB values to be specified with all 3 as a percentage "##%"
+        # or all as integer values without '%' sign.
+        if num_percent_vals.zero?
+          # interpret as integer values in range of 0..255
+          r, g, b = rgb.map {|strval| strval.to_i.clamp(0, 255) }
+          # Note, RGBA.new expects all values to be integers or floats.
+          # For this case, we also turn the alpha-value into an int range 0..255
+          # to match the r,g,b values.
+          a = has_alpha && (alpha.to_r.clamp(0r, 1r) * 255).to_i
+        elsif num_percent_vals == 3
+          r, g, b = rgb.map {|strval| (strval.to_r / 100).clamp(0r, 1r) }
+          a = has_alpha && alpha.to_r.clamp(0r, 1r)
+        else
+          raise ArgumentError, "Invalid mix of percent and integer values: #{css_string.inspect}"
+        end
+        return has_alpha ? RGBA.new(r, g, b, a) : RGB.new(r, g, b)
+      when "hsl", "hsla"
+        hue, sat, light, alpha = *args
+        # CSS3 Hue values are an angle, unclear if we should convert to Integer or Rational here.
+        h = hue.to_r
+        s, l = [sat, light].map {|strval| (strval.to_r / 100).clamp(0r, 1r) }
+        if has_alpha
+          a = alpha.to_r.clamp(0r, 1r)
+          return HSLA.new(h, s, l, a)
+        else
+          return HSL.new(h, s, l)
+        end
+      else
+        raise ArgumentError, "Unknown color space: #{css_string.inspect}"
+      end
+    end
+  end
+end

data/lib/colors/linear_segmented_colormap.rb

@@ -80,8 +80,6 @@ module Colors
         raise ArgumentError, "data array must consist of 3-length arrays"
       end
 
-      shape = [ary.length, 3]
-
       x, y0, y1 = ary.transpose
 
       if x[0] != 0.0 || x[-1] != 1.0

data/lib/colors/version.rb

@@ -1,3 +1,3 @@
 module Colors
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/colors/xterm256.rb

@@ -42,7 +42,8 @@ module Colors
     def to_grey_level
       if code < 232
         r, g, b = to_rgb_components
-        x, y, z = Convet.rgb_to_xyz(r, g, b)
+        y = Convert.rgb_to_greyscale(r, g, b)
+        canonicalize_component_to_rational(y, :grey)
       else
         grey = 10*(code - 232) + 8
         canonicalize_component_from_integer(grey, :grey)

data/lib/colors.rb

@@ -4,6 +4,7 @@ require_relative "colors/convert"
 require_relative "colors/helper"
 
 require_relative "colors/abstract_color"
+require_relative "colors/css"
 require_relative "colors/hsl"
 require_relative "colors/hsla"
 require_relative "colors/husl"

data/red-colors.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.files += Dir.glob("doc/text/*")
   spec.test_files += Dir.glob("test/**/*")
 
+  spec.add_runtime_dependency("json")
   spec.add_runtime_dependency("matrix")
 
   spec.add_development_dependency("bundler")

data/test/run.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-# TODO
-# $VERBOSE = true
+$VERBOSE = true
 
 require "pathname"
 

data/test/test-css.rb

@@ -0,0 +1,174 @@
+class ColorsCSSParserTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case("rgb") do
+    test("simple in-range integer values") do
+      ref = Colors::RGB.new(1, 0, 255)
+      css = Colors::CSS.parse("rgb(1,0,255)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::RGB.new(255, 0, 0)
+      css = Colors::CSS.parse("rgb(   300 ,0,0)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("rgb(   255 , -10,0)")
+      assert_near(ref, css)
+    end
+
+    test("in-range percent values") do
+      ref = Colors::RGB.new(0, 0.55, 1)
+      css = Colors::CSS.parse("rgb(0%,55%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range percent values") do
+      ref = Colors::RGB.new(0r, 0r, 1r)
+      css = Colors::CSS.parse("rgb(0%,0%,110%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("rgb(-10%,0%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "mixed pct/int" do
+        Colors::CSS.parse("rgb(50%,0 ,0)")
+      end
+      assert_raises ArgumentError, "too few args" do
+        Colors::CSS.parse("rgb(50%,0%)")
+      end
+      assert_raises ArgumentError, "too many args" do
+        Colors::CSS.parse("rgb(50%,0%,6%,0)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        Colors::CSS.parse("rgb(50% 0% 6%)")
+      end
+    end
+  end
+
+  sub_test_case("rgba") do
+    test("integer values, int alpha") do
+      ref = Colors::RGBA.new(1r, 0r, 1r, 1r)
+      css = Colors::CSS.parse("rgba(255,0,255,1)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 0r, 1r, 0r)
+      css = Colors::CSS.parse("rgba(255,0,255,0)")
+      assert_near(ref, css)
+    end
+
+    test("integer values, float alpha") do
+      ref = Colors::RGBA.new(255, 0, 255, 127)
+      css = Colors::CSS.parse("rgba(255,0,255 ,   0.5)")
+      assert_near(ref, css)
+    end
+
+    test("clamp out of range alpha values") do
+      ref = Colors::RGBA.new(1r, 0, 1r, 1r)
+      css = Colors::CSS.parse("rgba(255,0,255,2.0)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 127/255r, 123/255r, 0.0)
+      css = Colors::CSS.parse("rgba(255, 127, 123,-0.1)")
+      assert_near(ref, css)
+    end
+
+    test("percent values, int alpha") do
+      ref = Colors::RGBA.new(1r, 0r, 0.25r, 1r)
+      css = Colors::CSS.parse("rgba(100%,0%,25%,1)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 0.33r, 0.02r, 0r)
+      css = Colors::CSS.parse("rgba(100% , 33%,2%,0)")
+      assert_near(ref, css)
+    end
+
+    test("percent values, float alpha") do
+      ref = Colors::RGBA.new(0.5r, 0, 0.06, 1/2r)
+      css = Colors::CSS.parse("rgba(50%,0%,6% ,0.5)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "mixed pct/int" do
+        Colors::CSS.parse("rgba(50%,0,6 ,0.5)")
+      end
+      assert_raises ArgumentError, "too few args" do
+        Colors::CSS.parse("rgba(50%,0%,6%)")
+      end
+      assert_raises ArgumentError, "too many args" do
+        Colors::CSS.parse("rgba(50%,0%,6%,0.5, 0.5)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        Colors::CSS.parse("rgba(50%,0%,6% 0.5)")
+      end
+    end
+  end
+
+  sub_test_case("hsl") do
+    test("in-range hsl") do
+      ref = Colors::HSL.new(180, 0, 0.5)
+      css = Colors::CSS.parse("hsl( 180, 0% , 50% )")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::HSL.new(180, 0, 0.5)
+      css = Colors::CSS.parse("hsl(-180,0%,50%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(180,-10%,50%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(540,-10%,50%)")
+      assert_near(ref, css)
+      ref = Colors::HSL.new(0, 1.0, 1.0)
+      css = Colors::CSS.parse("hsl(0,100%,100%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(360,100%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "too many args" do
+        css = Colors::CSS.parse("hsl( 180, 0% , 50%, 50% )")
+      end
+      assert_raises ArgumentError, "too few args" do
+        css = Colors::CSS.parse("hsl( 180, 0%)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        css = Colors::CSS.parse("hsl( 180, 0% 50% )")
+      end
+    end
+  end
+
+  sub_test_case("hsla") do
+    test("in-range hsla") do
+      ref = Colors::HSLA.new(180, 0, 0.5, 1.0)
+      css = Colors::CSS.parse("hsla( 180, 0% , 50%,1.0)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::HSLA.new(180, 0, 0.5, 0.1)
+      css = Colors::CSS.parse("hsla(-180,0%,50%,0.1)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(180,-10%,50%, 0.1)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(540,-10%,50%, 0.1)")
+      assert_near(ref, css)
+      ref = Colors::HSLA.new(0, 1.0, 1.0, 0.0)
+      css = Colors::CSS.parse("hsla(0,100%,100%,0.0)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(360,100%,100%, 0.0)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "too many args" do
+        css = Colors::CSS.parse("hsla( 180, 0% , 50%, 0.0, 0.0 )")
+      end
+      assert_raises ArgumentError, "too few args" do
+        css = Colors::CSS.parse("hsla( 180, 0%, 0.0)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        css = Colors::CSS.parse("hsla( 180, 0% 50% 0.0 )")
+      end
+    end
+  end
+end

data/test/test-xterm256.rb

@@ -44,7 +44,9 @@ class ColorsXterm256Test < Test::Unit::TestCase
     assert { Colors::Xterm256.new(16) != Colors::Xterm256.new(17) }
   end
 
-  data do
+  RGB2GREY = [0.21263900587151035754r, 0.71516867876775592746r, 0.07219231536073371500r]
+
+  data(keep: true) do
     data_set = {}
     # colors 16-231 are a 6x6x6 color cube
     (0...6).each do |r|
@@ -55,7 +57,10 @@ class ColorsXterm256Test < Test::Unit::TestCase
           green = (g > 0) ? 40*g + 55 : g
           blue  = (b > 0) ? 40*b + 55 : b
           label = "Color #{code} is rgb(#{red}, #{green}, #{blue})"
-          data_set[label] = [code, Colors::RGB.new(red, green, blue)]
+          rgb = Colors::RGB.new(red, green, blue)
+          red, green, blue = Colors::Convert.srgb_to_linear_srgb(*rgb.components)
+          grey = RGB2GREY[0]*red + RGB2GREY[1]*green + RGB2GREY[2]*blue
+          data_set[label] = [code, rgb, grey]
         end
       end
     end
@@ -63,14 +68,23 @@ class ColorsXterm256Test < Test::Unit::TestCase
     (0...24).each do |y|
       code = 232 + y
       level = 10*y + 8
+      grey = level/255r
       label = "Color #{code} is gray(#{level})"
-      data_set[label] = [code, Colors::RGB.new(level, level, level)]
+      data_set[label] = [code, Colors::RGB.new(level, level, level), grey]
     end
     data_set
   end
+
   def test_to_rgb(data)
-    code, rgb = data
+    code, rgb, _grey = data
     assert_equal(rgb,
                  Colors::Xterm256.new(code).to_rgb)
   end
+
+  def test_to_grey_level(data)
+    code, _rgb, grey = data
+    assert_in_delta(grey,
+                    Colors::Xterm256.new(code).to_grey_level,
+                    1e-12)
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: red-colors
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kenta Murata
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-14 00:00:00.000000000 Z
+date: 2024-02-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: matrix
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +138,7 @@ files:
 - data/colormaps/twilight.json
 - data/colormaps/viridis.json
 - data/colormaps/vlag.json
+- doc/text/news.md
 - lib/colors.rb
 - lib/colors/abstract_color.rb
 - lib/colors/alpha_component.rb
@@ -134,6 +149,7 @@ files:
 - lib/colors/colormap_data/seaborn_builtin.rb
 - lib/colors/colormap_registry.rb
 - lib/colors/convert.rb
+- lib/colors/css.rb
 - lib/colors/helper.rb
 - lib/colors/hsl.rb
 - lib/colors/hsla.rb
@@ -151,6 +167,7 @@ files:
 - red-colors.gemspec
 - test/helper.rb
 - test/run.rb
+- test/test-css.rb
 - test/test-hsl.rb
 - test/test-hsla.rb
 - test/test-husl.rb
@@ -165,7 +182,7 @@ homepage: https://github.com/red-data-tools/red-colors
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -180,14 +197,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.5.1
+signing_key:
 specification_version: 4
 summary: Red Colors provides a wide array of features for dealing with colors. This
   includes conversion between colorspaces, desaturation, and parsing colors.
 test_files:
 - test/helper.rb
 - test/run.rb
+- test/test-css.rb
 - test/test-hsl.rb
 - test/test-hsla.rb
 - test/test-husl.rb