color_converters 0.1.3 → 0.1.5

data/lib/color_converters/converters/hsl_string_converter.rb

@@ -1,27 +1,61 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class HslStringConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(String)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('hsl(') || colour_input.include?('hsla(')
+    end
 
-      color_input.include?('hsl(') || color_input.include?('hsla(')
+    def self.bounds
+      HslConverter.bounds
     end
 
     private
 
-    def validate_input(_color_input)
-      true
-    end
+    # def clamp_input(colour_input)
+    #   colour_input = HslStringConverter.sanitize_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.to_f.clamp(*HslConverter.bounds[key]) }
+    #   HslStringConverter.rgb_to_rgbstring([colour_input[:h], colour_input[:s], colour_input[:l]], colour_input[:a])
+    # end
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('hsla(') ? [:h, :s, :l, :a] : [:h, :s, :l]
+      colour_input = HslStringConverter.sanitize_input(colour_input)
 
-    def input_to_rgba(color_input)
-      matches = color_input.match(/hsla?\(([0-9.,%\s]+)\)/)
-      raise InvalidColorError unless matches
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
 
-      h, s, l, a = matches[1].split(',').map(&:strip)
-      raise InvalidColorError unless h.present? && s.present? && l.present?
+      return errors if errors.present?
 
-      rgba = HslConverter.new(h: h, s: s, l: l, a: a).rgba
+      HslStringConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      colour_input = HslStringConverter.sanitize_input(colour_input)
+
+      rgba = HslConverter.new({ h: colour_input[:h], s: colour_input[:s], l: colour_input[:l], a: colour_input[:a] }, limit_override: true).rgba
 
       [rgba[:r], rgba[:g], rgba[:b], rgba[:a]]
     end
+
+    def self.sanitize_input(colour_input)
+      matches = colour_input.match(/hsla?\(([0-9.,%\s]+)\)/) || []
+      h, s, l, a = matches[1]&.split(',')&.map(&:strip)
+      { h: h, s: s, l: l, a: a }
+    end
+
+    # def self.rgb_to_hslstring(rgb_array_frac, alpha)
+    #   r, g, b = rgb_array_frac
+    #   if alpha == 1.0
+    #     "hsl(#{[r, g, b].join(', ')})"
+    #   else
+    #     "hsla(#{[r, g, b, alpha].join(', ')})"
+    #   end
+    # end
   end
 end

data/lib/color_converters/converters/hsv_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class HsvConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
 
-      color_input.keys - [:h, :s, :v] == [] || color_input.keys - [:h, :s, :b] == []
+      colour_input.keys - [:h, :s, :v] == [] || colour_input.keys - [:h, :s, :b] == []
     end
 
     def self.bounds
@@ -12,16 +14,20 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = HsvConverter.bounds
-      light = (color_input[:v].present? && color_input[:v].to_f.between?(*bounds[:v])) || (color_input[:b].present? && color_input[:b].to_f.between?(*bounds[:v]))
-      color_input[:h].to_f.between?(*bounds[:h]) && color_input[:s].to_f.between?(*bounds[:s]) && light
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*HsvConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      HsvConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].blank? || colour_input[key].to_f.between?(*range)
+      end.compact
     end
 
-    def input_to_rgba(color_input)
-      h = color_input[:h].to_f
-      s = color_input[:s].to_f
-      v = (color_input[:v] || color_input[:b]).to_f
+    def input_to_rgba(colour_input)
+      h = colour_input[:h].to_f
+      s = colour_input[:s].to_f
+      v = (colour_input[:v] || colour_input[:b]).to_f
 
       h /= 360
       s /= 100

data/lib/color_converters/converters/name_converter.rb

@@ -1,185 +1,69 @@
+# frozen_string_literal: true
+
+require 'color_swatch_collection'
+
 module ColorConverters
   class NameConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(String)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
 
-      self.color_names.include?(color_input.downcase.to_sym)
+      !colour_input.include?('#') && !colour_input.include?('rgb') && !colour_input.include?('hsl')
     end
 
-    def self.rgb_to_name(rgb_array)
-      r, g, b = rgb_array
+    def self.rgb_to_name(rgb_array, fuzzy = false)
+      if fuzzy
+        source_colour = ColorConverters::Color.new({ r: rgb_array[0], g: rgb_array[1], b: rgb_array[2] })
+
+        collection_colours = []
 
-      name = self.color_names.find { |_k, v| v == [r.round, g.round, b.round] }
-      name.present? ? name[0].to_s : nil
+        ::ColorSwatchCollection.list_collections.each do |collection_name|
+          collection_colours += self.add_colour_distances_to_collection(Object.const_get("::ColorSwatchCollection::#{collection_name.capitalize}").colours, source_colour)
+        end
+
+        collection_colours.min_by { |swatch| swatch[:distance] }.dig(:name)
+      else
+        ::ColorSwatchCollection.get_from_hex(HexConverter.rgb_to_hex(rgb_array)).dig(:name)
+      end
     end
 
     private
 
-    def validate_input(_color_input)
-      # TODO: validate against list of keys?
-      true
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*CielchConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      self.class.match_name_from_palettes(colour_input).present? ? [] : ['name could not be found across colour collections']
     end
 
-    def input_to_rgba(color_input)
-      found_colour = self.class.color_names[color_input.downcase.to_sym]
-      raise InvalidColorError unless found_colour.present?
+    def input_to_rgba(colour_input)
+      found_colour = self.class.match_name_from_palettes(colour_input) || ''
 
-      r, g, b = found_colour
+      HexConverter.hex_to_rgba(found_colour) if found_colour.present?
+    end
 
-      [r, g, b, 1.0]
+    # this is a checking for a direct naming match against the ColorSwatchCollection
+    def self.match_name_from_palettes(colour_name)
+      ::ColorSwatchCollection.get_from_name(colour_name).dig(:hex)
     end
 
-    # TODO: use color_namer_ruby gem instead, but that gem also uses this gem
-    def self.color_names
-      {
-        aliceblue: [240, 248, 255],
-        antiquewhite: [250, 235, 215],
-        aqua: [0, 255, 255],
-        aquamarine: [127, 255, 212],
-        azure: [240, 255, 255],
-        beige: [245, 245, 220],
-        bisque: [255, 228, 196],
-        black: [0, 0, 0],
-        blanchedalmond: [255, 235, 205],
-        blue: [0, 0, 255],
-        blueviolet: [138, 43, 226],
-        brown: [165, 42, 42],
-        burlywood: [222, 184, 135],
-        cadetblue: [95, 158, 160],
-        chartreuse: [127, 255, 0],
-        chocolate: [210, 105, 30],
-        coral: [255, 127, 80],
-        cornflowerblue: [100, 149, 237],
-        cornsilk: [255, 248, 220],
-        crimson: [220, 20, 60],
-        cyan: [0, 255, 255],
-        darkblue: [0, 0, 139],
-        darkcyan: [0, 139, 139],
-        darkgoldenrod: [184, 134, 11],
-        darkgray: [169, 169, 169],
-        darkgreen: [0, 100, 0],
-        darkgrey: [169, 169, 169],
-        darkkhaki: [189, 183, 107],
-        darkmagenta: [139, 0, 139],
-        darkolivegreen: [85, 107, 47],
-        darkorange: [255, 140, 0],
-        darkorchid: [153, 50, 204],
-        darkred: [139, 0, 0],
-        darksalmon: [233, 150, 122],
-        darkseagreen: [143, 188, 143],
-        darkslateblue: [72, 61, 139],
-        darkslategray: [47, 79, 79],
-        darkslategrey: [47, 79, 79],
-        darkturquoise: [0, 206, 209],
-        darkviolet: [148, 0, 211],
-        deeppink: [255, 20, 147],
-        deepskyblue: [0, 191, 255],
-        dimgray: [105, 105, 105],
-        dimgrey: [105, 105, 105],
-        dodgerblue: [30, 144, 255],
-        firebrick: [178, 34, 34],
-        floralwhite: [255, 250, 240],
-        forestgreen: [34, 139, 34],
-        fuchsia: [255, 0, 255],
-        gainsboro: [220, 220, 220],
-        ghostwhite: [248, 248, 255],
-        gold: [255, 215, 0],
-        goldenrod: [218, 165, 32],
-        gray: [128, 128, 128],
-        green: [0, 128, 0],
-        greenyellow: [173, 255, 47],
-        grey: [128, 128, 128],
-        honeydew: [240, 255, 240],
-        hotpink: [255, 105, 180],
-        indianred: [205, 92, 92],
-        indigo: [75, 0, 130],
-        ivory: [255, 255, 240],
-        khaki: [240, 230, 140],
-        lavender: [230, 230, 250],
-        lavenderblush: [255, 240, 245],
-        lawngreen: [124, 252, 0],
-        lemonchiffon: [255, 250, 205],
-        lightblue: [173, 216, 230],
-        lightcoral: [240, 128, 128],
-        lightcyan: [224, 255, 255],
-        lightgoldenrodyellow: [250, 250, 210],
-        lightgray: [211, 211, 211],
-        lightgreen: [144, 238, 144],
-        lightgrey: [211, 211, 211],
-        lightpink: [255, 182, 193],
-        lightsalmon: [255, 160, 122],
-        lightseagreen: [32, 178, 170],
-        lightskyblue: [135, 206, 250],
-        lightslategray: [119, 136, 153],
-        lightslategrey: [119, 136, 153],
-        lightsteelblue: [176, 196, 222],
-        lightyellow: [255, 255, 224],
-        lime: [0, 255, 0],
-        limegreen: [50, 205, 50],
-        linen: [250, 240, 230],
-        magenta: [255, 0, 255],
-        maroon: [128, 0, 0],
-        mediumaquamarine: [102, 205, 170],
-        mediumblue: [0, 0, 205],
-        mediumorchid: [186, 85, 211],
-        mediumpurple: [147, 112, 219],
-        mediumseagreen: [60, 179, 113],
-        mediumslateblue: [123, 104, 238],
-        mediumspringgreen: [0, 250, 154],
-        mediumturquoise: [72, 209, 204],
-        mediumvioletred: [199, 21, 133],
-        midnightblue: [25, 25, 112],
-        mintcream: [245, 255, 250],
-        mistyrose: [255, 228, 225],
-        moccasin: [255, 228, 181],
-        navajowhite: [255, 222, 173],
-        navy: [0, 0, 128],
-        oldlace: [253, 245, 230],
-        olive: [128, 128, 0],
-        olivedrab: [107, 142, 35],
-        orange: [255, 165, 0],
-        orangered: [255, 69, 0],
-        orchid: [218, 112, 214],
-        palegoldenrod: [238, 232, 170],
-        palegreen: [152, 251, 152],
-        paleturquoise: [175, 238, 238],
-        palevioletred: [219, 112, 147],
-        papayawhip: [255, 239, 213],
-        peachpuff: [255, 218, 185],
-        peru: [205, 133, 63],
-        pink: [255, 192, 203],
-        plum: [221, 160, 221],
-        powderblue: [176, 224, 230],
-        purple: [128, 0, 128],
-        red: [255, 0, 0],
-        rosybrown: [188, 143, 143],
-        royalblue: [65, 105, 225],
-        saddlebrown: [139, 69, 19],
-        salmon: [250, 128, 114],
-        sandybrown: [244, 164, 96],
-        seagreen: [46, 139, 87],
-        seashell: [255, 245, 238],
-        sienna: [160, 82, 45],
-        silver: [192, 192, 192],
-        skyblue: [135, 206, 235],
-        slateblue: [106, 90, 205],
-        slategray: [112, 128, 144],
-        slategrey: [112, 128, 144],
-        snow: [255, 250, 250],
-        springgreen: [0, 255, 127],
-        steelblue: [70, 130, 180],
-        tan: [210, 180, 140],
-        teal: [0, 128, 128],
-        thistle: [216, 191, 216],
-        tomato: [255, 99, 71],
-        turquoise: [64, 224, 208],
-        violet: [238, 130, 238],
-        wheat: [245, 222, 179],
-        white: [255, 255, 255],
-        whitesmoke: [245, 245, 245],
-        yellow: [255, 255, 0],
-        yellowgreen: [154, 205, 50]
-      }
+    def self.add_colour_distances_to_collection(collection_colours, source_colour)
+      collection_colours.map do |swatch|
+        swatch[:distance] = self.distance_between_colours(ColorConverters::Color.new(swatch.dig(:hex)), source_colour)
+      end
+
+      collection_colours
+    end
+
+    def self.distance_between_colours(comparison_colour, source_colour)
+      # https://en.wikipedia.org/wiki/Euclidean_distance#Higher_dimensions
+      # https://www.baeldung.com/cs/compute-similarity-of-colours
+      # TODO: allow the type of matching to be set via config. Use HSL for now as it's far faster than CIELab
+      conversion_1 = comparison_colour.hsl
+      conversion_2 = source_colour.hsl
+
+      keys = conversion_1.keys
+      Math.sqrt((conversion_1[keys[0]] - conversion_2[keys[0]])**2 + (conversion_1[keys[1]] - conversion_2[keys[1]])**2 + (conversion_1[keys[2]] - conversion_2[keys[2]])**2)
     end
   end
 end

data/lib/color_converters/converters/null_converter.rb

@@ -1,16 +1,22 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class NullConverter < BaseConverter
-    def self.matches?(_color_input)
+    def self.matches?(_colour_input)
       true
     end
 
     private
 
-    def validate_input(_color_input)
-      false
+    # def clamp_input(colour_input)
+    #   colour_input
+    # end
+
+    def validate_input(_colour_input)
+      ['did not recognise colour input']
     end
 
-    def input_to_rgba(_color_input)
+    def input_to_rgba(_colour_input)
       raise InvalidColorError
     end
   end

data/lib/color_converters/converters/oklab_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class OklabConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
 
-      color_input.keys - [:l, :a, :b, :space] == [] && color_input[:space].to_s == 'ok'
+      colour_input.keys - [:l, :a, :b, :space] == [] && colour_input[:space].to_s == 'ok'
     end
 
     def self.bounds
@@ -12,22 +14,27 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = OklabConverter.bounds
-      color_input[:l].to_f.between?(*bounds[:l]) && color_input[:a].to_f.between?(*bounds[:a]) && color_input[:b].to_f.between?(*bounds[:b])
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*OklabConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      OklabConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
     end
 
-    def input_to_rgba(color_input)
-      x, y, z = OklabConverter.oklab_to_xyz(color_input)
+    def input_to_rgba(colour_input)
+      x, y, z = OklabConverter.oklab_to_xyz(colour_input)
       r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
 
       [r, g, b, 1.0]
     end
 
-    def self.oklab_to_xyz(color_input)
-      l = color_input[:l].to_d
-      a = color_input[:a].to_d
-      b = color_input[:b].to_d
+    def self.oklab_to_xyz(colour_input)
+      l = colour_input[:l].to_d
+      a = colour_input[:a].to_d
+      b = colour_input[:b].to_d
 
       # Now, scale l to a decimal
       l /= 100.0.to_d
@@ -41,9 +48,9 @@ module ColorConverters
 
       l_lms, m_lms, s_lms = (lab_to_lms_matrix * ::Matrix.column_vector([l, a, b])).to_a.flatten
 
-      l_lms **= 3.to_d
-      m_lms **= 3.to_d
-      s_lms **= 3.to_d
+      l_lms **= 3.0.to_d
+      m_lms **= 3.0.to_d
+      s_lms **= 3.0.to_d
 
       lms_to_xyz_matrix = ::Matrix[
         [1.2268798758459243.to_d, -0.5578149944602171.to_d, 0.2813910456659647.to_d],
@@ -77,9 +84,10 @@ module ColorConverters
 
       l_lms, m_lms, s_lms = (xyz_to_lms_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
 
-      l_lms **= (1.0.to_d / 3.0.to_d)
-      m_lms **= (1.0.to_d / 3.0.to_d)
-      s_lms **= (1.0.to_d / 3.0.to_d)
+      cube_root = (1.0.to_d / 3.0.to_d)
+      l_lms **= cube_root
+      m_lms **= cube_root
+      s_lms **= cube_root
 
       lms_to_lab_matrix = ::Matrix[
         [0.2104542683093140.to_d, 0.7936177747023054.to_d, -0.0040720430116193.to_d],

data/lib/color_converters/converters/oklch_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class OklchConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
 
-      color_input.keys - [:l, :c, :h, :space] == [] && color_input[:space].to_s == 'ok'
+      colour_input.keys - [:l, :c, :h, :space] == [] && colour_input[:space].to_s == 'ok'
     end
 
     def self.bounds
@@ -12,23 +14,28 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = OklchConverter.bounds
-      color_input[:l].to_f.between?(*bounds[:l]) && color_input[:c].to_f.between?(*bounds[:c]) && color_input[:h].to_f.between?(*bounds[:h])
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*OklchConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      OklchConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
     end
 
-    def input_to_rgba(color_input)
-      l, a, b = OklchConverter.oklch_to_oklab(color_input)
+    def input_to_rgba(colour_input)
+      l, a, b = OklchConverter.oklch_to_oklab(colour_input)
       x, y, z = OklabConverter.oklab_to_xyz({ l: l, a: a, b: b })
       r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
 
       [r, g, b, 1.0]
     end
 
-    def self.oklch_to_oklab(color_input)
-      l = color_input[:l].to_d
-      c = color_input[:c].to_d
-      h = color_input[:h].to_d
+    def self.oklch_to_oklab(colour_input)
+      l = colour_input[:l].to_d
+      c = colour_input[:c].to_d
+      h = colour_input[:h].to_d
 
       h_rad = h * (Math::PI.to_d / 180.0.to_d)
 

data/lib/color_converters/converters/rgb_converter.rb

@@ -1,27 +1,34 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class RgbConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
 
-      color_input.keys - [:r, :g, :b] == [] || color_input.keys - [:r, :g, :b, :a] == []
+      colour_input.keys - [:r, :g, :b] == [] || colour_input.keys - [:r, :g, :b, :a] == []
     end
 
     def self.bounds
-      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0] }
+      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0], a: [0.0, 1.0] }
     end
 
     private
 
-    def validate_input(color_input)
-      bounds = RgbConverter.bounds
-      color_input[:r].to_f.between?(*bounds[:r]) && color_input[:g].to_f.between?(*bounds[:g]) && color_input[:b].to_f.between?(*bounds[:b])
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*RgbConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      RgbConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
     end
 
-    def input_to_rgba(color_input)
-      r = color_input[:r].to_f
-      g = color_input[:g].to_f
-      b = color_input[:b].to_f
-      a = (color_input[:a] || 1.0).to_f
+    def input_to_rgba(colour_input)
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
 
       [r, g, b, a]
     end
@@ -43,7 +50,7 @@ module ColorConverters
 
           # IMPORTANT NUMERICAL NOTE:
           # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
+          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
           #
           # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
           # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
@@ -78,7 +85,7 @@ module ColorConverters
 
           # IMPORTANT NUMERICAL NOTE:
           # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
+          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used colour science libraries (like Bruce Lindbloom's).
           #
           # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
           # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
@@ -90,7 +97,7 @@ module ColorConverters
         end
       end
 
-      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit color components.
+      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit colour components.
       r *= 255.0.to_d
       g *= 255.0.to_d
       b *= 255.0.to_d

data/lib/color_converters/converters/rgb_string_converter.rb

@@ -1,32 +1,64 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class RgbStringConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(String)
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('rgb(') || colour_input.include?('rgba(')
+    end
 
-      color_input.include?('rgb(') || color_input.include?('rgba(')
+    def self.bounds
+      RgbConverter.bounds
     end
 
     private
 
-    def validate_input(_color_input)
-      true
-    end
+    # def clamp_input(colour_input)
+    #   colour_input = RgbStringConverter.sanitize_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.to_f.clamp(*RgbConverter.bounds[key]) }
+    #   RgbStringConverter.rgb_to_rgbstring([colour_input[:r], colour_input[:g], colour_input[:b]], colour_input[:a])
+    # end
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('rgba(') ? [:r, :g, :b, :a] : [:r, :g, :b]
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
 
-    def input_to_rgba(color_input)
-      matches = color_input.match(/rgba?\(([0-9.,\s]+)\)/)
-      raise InvalidColorError unless matches
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
 
-      r, g, b, a = matches[1].split(',').map(&:strip)
-      raise InvalidColorError unless r.present? && g.present? && b.present?
+      return errors if errors.present?
 
-      a ||= 1.0
+      RgbStringConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
 
-      r = r.to_f
-      g = g.to_f
-      b = b.to_f
-      a = a.to_f
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
 
       [r, g, b, a]
     end
+
+    def self.sanitize_input(colour_input)
+      matches = colour_input.match(/rgba?\(([0-9.,%\s]+)\)/) || []
+      r, g, b, a = matches[1]&.split(',')&.map(&:strip)
+      { r: r, g: g, b: b, a: a }
+    end
+
+    # def self.rgb_to_rgbstring(rgb_array_frac, alpha)
+    #   r, g, b = rgb_array_frac
+    #   if alpha == 1.0
+    #     "rgb(#{[r, g, b].join(', ')})"
+    #   else
+    #     "rgba(#{[r, g, b, alpha].join(', ')})"
+    #   end
+    # end
   end
 end