color_converters 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cff79bc695fab4e8041206a798421948d03eb04933b77274a802f90a0010999
-  data.tar.gz: 1edc8b8811b32ca6ac4d7b9f8347151ab772fa58d52d90ba4cd8f48ab60d889e
+  metadata.gz: bebeb93877646ae484c2432784d6acb4b5a14437024adf5fb4e044f83ccc7de8
+  data.tar.gz: 98c736ac93f9ecbad9a989f0dc53f9a4bc7c6cf699f9cf6f891cfd7df954483a
 SHA512:
-  metadata.gz: a5fe55d89679198c41e0e166dbdae882b11f9396d58710b004707358652c6187e53889d88dd21efbeeee99b7738484a7cd3d71f7cc35496445881a9558fa9543
-  data.tar.gz: 507da4fe02639e97285b5df4ed0e6e5e69fd78f793aa8bc772b2702d72e029f227ce50abf2987ac087fe1b050a06562262ed9660ca8395d6833e528412900852
+  metadata.gz: 44b8fa514afa086c085af17f0d112b2e575d77ec44dba6cedb5d6d2c98987c0da3e0db74a06e72e2f708f8ffd16f258a54a8a79effd2692b1675dfd041975be0
+  data.tar.gz: 1b2a7a03dc0e7aec402e5a289ba692d83ba9d475cdda0e34f6d718abc141c8135dcf49f7b376ab7851e647b6c4f10a69fc7683f5d66a7b3af2ffa7d0c166ee00

data/README.md

@@ -1,15 +1,18 @@
 # Color Converters
 
-> Give me a color and I'll convert it.
+[![Gem Version](https://badge.fury.io/rb/color_converters.svg)](https://badge.fury.io/rb/color_converters)
+![Static Badge](https://img.shields.io/badge/RubyGems-red?link=https%3A%2F%2Frubygems.org%2Fgems%color_converters)
 
-Color Converters is an ruby gem package for use in ruby or other projects that provides conversions for colors to other color spaces.
-Given a color in [Hexadecimal, RGA(A), HSL(A), HSV, HSB, CMYK, XYZ, CIELAB, or OKLCH format](https://github.com/devrieda/color_conversion), it can convert the color to those other spaces.
+> Give me a colour and I'll convert it.
 
-> Lab and LCH color spaces are special in that the perceived difference between two colors is proportional to their Euclidean distance in color space. This special property, called perceptual uniformity, makes them ideal for accurate visual encoding of data. In contrast, the more familiar RGB and HSL color spaces distort data when used for visualization.
+Color Converters is an ruby gem package for use in ruby or other projects that provides conversions for colours to other colour spaces.
+Given a colour in [Hexadecimal, RGA(A), HSL(A), HSV, HSB, CMYK, XYZ, CIELAB, or OKLCH format](https://github.com/devrieda/color_conversion), it can convert the colour to those other spaces.
+
+> Lab and LCH colour spaces are special in that the perceived difference between two colours is proportional to their Euclidean distance in colour space. This special property, called perceptual uniformity, makes them ideal for accurate visual encoding of data. In contrast, the more familiar RGB and HSL colour spaces distort data when used for visualization.
 
 ## Converters
 
-Colors can be converted between the following spaces:
+Colours can be converted between the following spaces:
 
 - hex
 - rgb(a)
@@ -19,8 +22,8 @@ Colors can be converted between the following spaces:
 - xyz
 - cielab
 - cielch
-- oklab (not always reliable)
-- oklch (not always reliable)
+- oklab (not always reliable when going from oklab to the source colour)
+- oklch (not always reliable when going from oklch to the source colour)
 - name
 
 ## Installation
@@ -39,97 +42,98 @@ gem install color_converters
 
 ## Usage
 
-Initialize a color:
+Initialize a colour:
 
 ```ruby
 # from hex
-color = ColorConverters::Color.new("#3366cc")
-color = ColorConverters::Color.new("#36c")
+colour = ColorConverters::Color.new("#3366cc")
+colour = ColorConverters::Color.new("#36c")
 
 # from rgb(a)
-color = ColorConverters::Color.new(r: 51, g: 102, b: 204)
-color = ColorConverters::Color.new(r: 51, g: 102, b: 204, a: 0.5)
+colour = ColorConverters::Color.new(r: 51, g: 102, b: 204)
+colour = ColorConverters::Color.new(r: 51, g: 102, b: 204, a: 0.5)
 
 # from hsl(a)
-color = ColorConverters::Color.new(h: 225, s: 73, l: 57)
-color = ColorConverters::Color.new(h: 225, s: 73, l: 57, a: 0.5)
+colour = ColorConverters::Color.new(h: 225, s: 73, l: 57)
+colour = ColorConverters::Color.new(h: 225, s: 73, l: 57, a: 0.5)
 
 # from hsv/hsb
-color = ColorConverters::Color.new(h: 220, s: 75, v: 80)
-color = ColorConverters::Color.new(h: 220, s: 75, b: 80)
+colour = ColorConverters::Color.new(h: 220, s: 75, v: 80)
+colour = ColorConverters::Color.new(h: 220, s: 75, b: 80)
 
 # from cmyk
-color = ColorConverters::Color.new(c: 74, m: 58, y: 22, k: 3)
+colour = ColorConverters::Color.new(c: 74, m: 58, y: 22, k: 3)
 
 # from xyz
-color = ColorConverters::Color.new(x: 16, y: 44, z: 32)
+colour = ColorConverters::Color.new(x: 16, y: 44, z: 32)
 
 # from cielab
-color = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :cie)
+colour = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :cie)
 
 # from cielch
-color = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :cie)
+colour = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :cie)
 
 # from oklab
-color = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :ok)
+colour = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :ok)
 
 # from oklch
-color = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :ok)
+colour = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :ok)
 
-# from textual color
-color = ColorConverters::Color.new("blue")
+# from textual colour
+colour = ColorConverters::Color.new("blue")
 
 # from a css rgb(a) string
-color = ColorConverters::Color.new("rgb(51, 102, 204)")
-color = ColorConverters::Color.new("rgba(51, 102, 204, 0.5)")
+colour = ColorConverters::Color.new("rgb(51, 102, 204)")
+colour = ColorConverters::Color.new("rgba(51, 102, 204, 0.5)")
 
 # from a css hsl(a) string
-color = ColorConverters::Color.new("hsl(225, 73%, 57%)")
-color = ColorConverters::Color.new("hsl(225, 73%, 57%, 0.5)")
+colour = ColorConverters::Color.new("hsl(225, 73%, 57%)")
+colour = ColorConverters::Color.new("hsl(225, 73%, 57%, 0.5)")
 ```
 
 Converters
 
 ```ruby
-color = ColorConverters::Color.new(r: 70, g: 130, b: 180, a: 0.5)
+colour = ColorConverters::Color.new("rgba(70, 130, 180, 0.5)")
+colour = ColorConverters::Color.new(r: 70, g: 130, b: 180, a: 0.5)
 
-color.alpha
+colour.alpha
 => 0.5
 
-color.rgb
+colour.rgb
 => {:r=>70, :g=>130, :b=>180}
 
-color.hsl
+colour.hsl
 => {:h=>207, :s=>44, :l=>49}
 
-color.hsv
+colour.hsv
 => {:h=>207, :s=>61, :v=>71}
 
-color.hsb
+colour.hsb
 => {:h=>207, :s=>61, :b=>71}
 
-color.cmyk
+colour.cmyk
 => {:c=>61, :m=>28, :y=>0, :k=>29}
 
-color.xyz
+colour.xyz
 => {:x=>33, :y=>21, :z=>54}
 
-color.cielab
+colour.cielab
 => {:l=>52.47, :a=>-4.08, :b=>-32.19}
 
-color.cielch
+colour.cielch
 => {:l=>52.47, :c=>32.45, :h=>262.78}
 
-color.oklab # not always accurate
+colour.oklab # not always accurate
 => {:l=>52.47, :a=>-4.08, :b=>-32.19}
 
-color.oklch # not always accurate
+colour.oklch # not always accurate
 => {:l=>52.47, :c=>32.45, :h=>262.78}
 
-color.hex
+colour.hex
 => "#4682b4"
 
-color.name
+colour.name
 => "steelblue"
 ```
 
@@ -137,26 +141,45 @@ color.name
 
 ### space
 
-As there are certain color spaces that use the same letter keys, there needed to be a way to different between those space.
+As there are certain colour spaces that use the same letter keys, there needed to be a way to different between those space.
 The space parameter allows that, with examples in the usage code above
 
 ```ruby
 ColorConverters::Color.new(l: 64, a: 28, b: -15, space: :cie)
-ColorConverters::Color.new(l: 64, a: 28, b: -15, space: :ok)
+ColorConverters::Color.new(l: 64, a: 0.28, b: -0.15, space: :ok)
 ```
 
 ### limit_override
 
-By default all values are checked to be within the expected number ranges, i.e.; rgb between 0-255 each.
+By default all values are checked to be within the expected number ranges, i.e.; rgb between 0-255 each but there are certain spaces where this is less fixed which this option is purposed for.
 This parameter allows you to ignore those ranges and submit any values you want.
+**WARNING: even if you use this, there may be certain conversions that can not handle the large source values; e.g.**
 
 ```ruby
-ColorConverters::Color.new(r: 270, g: 1300, b: 380, a: 0.5, limit_override: true)
+ColorConverters::Color.new(r: 270, g: 1300, b: 380, a: 0.5, limit_override: true).rgb
+=> {r: 270.0, g: 1300.0, b: 380.0}
+
+ColorConverters::Color.new(x: 174, y: 135, z: 137, limit_override: true).xyz
+=> {x: 91.58, y: 93.06, z: 107.75}
+```
+
+### fuzzy
+
+Name conversions by default look for exact matches between the hex value of the colour
+
+```ruby
+colour = ColorConverters::Color.new(r: 175.8, g: 196.4, b: 222.1)
+
+colour.name
+=> nil
+
+colour.name(fuzzy: true)
+=> 'lightsteelblue'
 ```
 
 ## Development
 
-[Converting Colors](https://convertingcolors.com/) and [Colorffy](https://colorffy.com/) can be usef to help verify results. Different calculators use different exponents and standards so there can be discrepency across them (like this calculator for LCH).
+[Converting Colors](https://convertingcolors.com/) and [Colorffy](https://colorffy.com/) can be used to help verify results. Different calculators use different exponents and standards so there can be discrepency across them (like this calculator for LCH).
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/Rakefile

@@ -1,8 +1,8 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/color_converters/base_converter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/object/blank'
 require 'bigdecimal'
 require 'bigdecimal/util'
 
 module ColorConverters
   class BaseConverter
-    IMPORT_DP = 2
+    IMPORT_DP = 8
     OUTPUT_DP = 2
 
     attr_reader :original_value, :rgba
@@ -20,21 +22,20 @@ module ColorConverters
       BaseConverter.converters << subclass
     end
 
-    def self.factory(color)
-      converter = BaseConverter.converters.find { |klass| klass.matches?(color) }
-      converter.new(color) if converter
+    def self.factory(colour_input, limit_override = false, limit_clamp = false)
+      converter = BaseConverter.converters.find { |klass| klass.matches?(colour_input) }
+      converter&.new(colour_input, limit_override, limit_clamp)
     end
 
-    def initialize(color_input, limit_override = false)
-      @original_value = color_input
+    def initialize(colour_input, limit_override = false, limit_clamp = false)
+      colour_input.delete(:space) if colour_input.is_a?(Hash)
 
-      # self.clamp_input(color_input) if limit_clamp == true
+      # colour_input = self.clamp_input(colour_input) if limit_clamp == true
 
-      if limit_override == false && !self.validate_input(color_input)
-        raise InvalidColorError # validation method is defined in each convertor
-      end
+      validation_errors = self.validate_input(colour_input) # validation method is defined in each convertor
+      raise InvalidColorError, "Invalid color input: #{validation_errors.join(', ')}" if limit_override == false && validation_errors.present?
 
-      r, g, b, a = self.input_to_rgba(color_input) # conversion method is defined in each convertor
+      r, g, b, a = self.input_to_rgba(colour_input) # conversion method is defined in each convertor
 
       @rgba = { r: r.to_f.round(IMPORT_DP), g: g.to_f.round(IMPORT_DP), b: b.to_f.round(IMPORT_DP), a: a.to_f.round(IMPORT_DP) }
     end
@@ -44,15 +45,17 @@ module ColorConverters
     end
 
     def hex
-      "##{'%02x' % @rgba[:r] + '%02x' % @rgba[:g] + '%02x' % @rgba[:b]}"
+      HexConverter.rgb_to_hex(self.rgb_array)
     end
 
+    # not refactored to SubClass methods due to needing so many of the private methods
     def hsl
       @r, @g, @b = self.rgb_array_frac
 
       { h: self.hue.to_f.round(OUTPUT_DP), s: self.hsl_saturation.to_f.round(OUTPUT_DP), l: self.hsl_lightness.to_f.round(OUTPUT_DP) }
     end
 
+    # not refactored to SubClass methods due to needing so many of the private methods
     def hsv
       @r, @g, @b = self.rgb_array
 
@@ -105,8 +108,8 @@ module ColorConverters
       @rgba[:a]
     end
 
-    def name
-      NameConverter.rgb_to_name(self.rgb_array)
+    def name(fuzzy: false)
+      NameConverter.rgb_to_name(self.rgb_array, fuzzy)
     end
 
     protected

data/lib/color_converters/color.rb

@@ -1,10 +1,25 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class Color
     extend Forwardable
     def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :cielch, :oklab, :oklch, :name, :alpha
 
-    def initialize(color)
-      @converter = BaseConverter.factory(color)
+    # the two arguments mean we can support calling styles of a hash of colour keys, flattened hash, and string
+    # colour_input is nil when key-values are passed and must be pulled from the kwargs hash
+    # colour_input is set when a string is passed and kwargs is a hash of the extra options
+    def initialize(colour_input = nil, **kwargs)
+      if colour_input.nil?
+        colour_input = kwargs.except(:limit_override, :limit_clamp)
+        kwargs = kwargs.slice(:limit_override, :limit_clamp)
+      end
+
+      @original_value = colour_input
+
+      limit_override = kwargs.delete(:limit_override) || false
+      limit_clamp = kwargs.delete(:limit_clamp) || false
+
+      @converter = BaseConverter.factory(colour_input, limit_override, limit_clamp)
     end
 
     def ==(other)

data/lib/color_converters/converters/cielab_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class CielabConverter < 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 == 'cie'
+      colour_input.keys - [:l, :a, :b, :space] == [] && colour_input[:space].to_s == 'cie'
     end
 
     def self.bounds
@@ -12,22 +14,27 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = CielabConverter.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(*CielabConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      CielabConverter.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 = CielabConverter.cielab_to_xyz(color_input)
+    def input_to_rgba(colour_input)
+      x, y, z = CielabConverter.cielab_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.cielab_to_xyz(color_input)
-      l = color_input[:l].to_d
-      a = color_input[:a].to_d
-      b = color_input[:b].to_d
+    def self.cielab_to_xyz(colour_input)
+      l = colour_input[:l].to_d
+      a = colour_input[:a].to_d
+      b = colour_input[:b].to_d
 
       yy = (l + 16.0.to_d) / 116.0.to_d
       xx = (a / 500.0.to_d) + yy

data/lib/color_converters/converters/cielch_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class CielchConverter < 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 == 'cie'
+      colour_input.keys - [:l, :c, :h, :space] == [] && colour_input[:space].to_s == 'cie'
     end
 
     def self.bounds
@@ -12,23 +14,28 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = CielchConverter.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(*CielchConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      CielchConverter.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 = CielchConverter.cielch_to_cielab(color_input)
+    def input_to_rgba(colour_input)
+      l, a, b = CielchConverter.cielch_to_cielab(colour_input)
       x, y, z = CielabConverter.cielab_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.cielch_to_cielab(color_input)
-      l = color_input[:l].to_d
-      c = color_input[:c].to_d
-      h = color_input[:h].to_d
+    def self.cielch_to_cielab(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/cmyk_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class CmykConverter < 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 - [:c, :m, :y, :k] == []
+      colour_input.keys - [:c, :m, :y, :k] == []
     end
 
     def self.bounds
@@ -12,16 +14,21 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
-      bounds = CmykConverter.bounds
-      color_input[:c].to_f.between?(*bounds[:c]) && color_input[:m].to_f.between?(*bounds[:m]) && color_input[:y].to_f.between?(*bounds[:y]) && color_input[:k].to_f.between?(*bounds[:k])
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*CmykConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      CmykConverter.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)
-      c = color_input[:c].to_f
-      m = color_input[:m].to_f
-      y = color_input[:y].to_f
-      k = color_input[:k].to_f
+    def input_to_rgba(colour_input)
+      c = colour_input[:c].to_f
+      m = colour_input[:m].to_f
+      y = colour_input[:y].to_f
+      k = colour_input[:k].to_f
 
       c /= 100.0
       m /= 100.0

data/lib/color_converters/converters/hex_converter.rb

@@ -1,31 +1,48 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class HexConverter < BaseConverter
-    def self.matches?(color)
-      return false unless color.is_a?(String)
+    def self.matches?(colour)
+      return false unless colour.is_a?(String)
 
-      color.include?('#') && [4, 7, 9].include?(color.length)
+      colour.include?('#') && [4, 7, 9].include?(colour.length)
     end
 
     private
 
-    def validate_input(_color_input)
+    # def clamp_input(colour_input)
+    #   colour_input # return it as it was
+    # end
+
+    def validate_input(_colour_input)
       # TODO
-      true
+      [] # to return no errors
+    end
+
+    def input_to_rgba(colour_input)
+      HexConverter.hex_to_rgba(colour_input)
     end
 
-    def input_to_rgba(color_input)
-      color_input = self.normalize_hex(color_input)
+    def self.hex_to_rgba(hex_input)
+      hex_input = self.normalize_hex(hex_input)
 
-      r = color_input[0, 2].hex
-      g = color_input[2, 2].hex
-      b = color_input[4, 2].hex
-      a = color_input.length == 8 ? hex[6, 2].hex : 1.0
+      r = hex_input[0, 2].hex
+      g = hex_input[2, 2].hex
+      b = hex_input[4, 2].hex
+      a = hex_input.length == 8 ? hex[6, 2].hex : 1.0
 
       [r, g, b, a]
     end
 
-    def normalize_hex(hex_input)
+    def self.rgb_to_hex(rgb_array)
+      r, g, b = rgb_array
+
+      format('#%<r>02x%<g>02x%<b>02x', r: r, g: g, b: b)
+    end
+
+    def self.normalize_hex(hex_input)
       hex_input = hex_input.gsub('#', '')
+
       (hex_input.length == 3 ? hex_input[0, 1] * 2 + hex_input[1, 1] * 2 + hex_input[2, 1] * 2 : hex_input).downcase
     end
   end

data/lib/color_converters/converters/hsl_converter.rb

@@ -1,27 +1,34 @@
+# frozen_string_literal: true
+
 module ColorConverters
   class HslConverter < 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, :l] == [] || color_input.keys - [:h, :s, :l, :a] == []
+      colour_input.keys - [:h, :s, :l] == [] || colour_input.keys - [:h, :s, :l, :a] == []
     end
 
     def self.bounds
-      { h: [0.0, 360.0], s: [0.0, 100.0], l: [0.0, 100.0] }
+      { h: [0.0, 360.0], s: [0.0, 100.0], l: [0.0, 100.0], a: [0.0, 1.0] }
     end
 
     private
 
-    def validate_input(color_input)
-      bounds = HslConverter.bounds
-      color_input[:h].to_f.between?(*bounds[:h]) && color_input[:s].to_f.between?(*bounds[:s]) && color_input[:l].to_f.between?(*bounds[:l])
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*HslConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      HslConverter.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)
-      h = color_input[:h].to_s.gsub(/[^0-9.]/, '').to_f / 360.0
-      s = color_input[:s].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
-      l = color_input[:l].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
-      a = color_input[:a] ? color_input[:a].to_s.gsub(/[^0-9.]/, '').to_f : 1.0
+    def input_to_rgba(colour_input)
+      h = colour_input[:h].to_s.gsub(/[^0-9.]/, '').to_f / 360.0
+      s = colour_input[:s].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
+      l = colour_input[:l].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
+      a = colour_input[:a] ? colour_input[:a].to_s.gsub(/[^0-9.]/, '').to_f : 1.0
 
       return greyscale(l, a) if s.zero?
 
@@ -37,7 +44,7 @@ module ColorConverters
 
       (0..2).each do |i|
         t3 = h + 1 / 3.0 * - (i - 1)
-        t3 < 0 && t3 += 1
+        t3.negative? && t3 += 1
         t3 > 1 && t3 -= 1
 
         val = if 6 * t3 < 1