color_converters 0.1.2 → 0.1.4

data/lib/color_converters/converters/cielch_converter.rb

@@ -1,52 +1,61 @@
-module ColorConverters
-  class CielchConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:l, :c, :h, :space] == [] && color_input[:space].to_s == 'cie'
-    end
-
-    def self.bounds
-      { l: [0.0, 100.0], c: [0.0, 100.0], h: [0.0, 360.0] }
-    end
-
-    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])
-    end
-
-    def input_to_rgba(color_input)
-      lab_hash = CielchConverter.cielch_to_cielab(color_input)
-      xyz_hash = CielabConverter.cielab_to_xyz(lab_hash)
-      XyzConverter.new(xyz_hash, limit_override: true).rgba
-    end
-
-    def self.cielch_to_cielab(color_input)
-      l = color_input[:l].to_f
-      c = color_input[:c].to_f
-      h = color_input[:h].to_f
-
-      h_rad = h * (Math::PI / 180.0)
-
-      a = c * Math.cos(h_rad)
-      b = c * Math.sin(h_rad)
-
-      { l: l, a: a, b: b }
-    end
-
-    def self.cielab_to_cielch(lab_array)
-      l, aa, bb = lab_array
-
-      c = ((aa**2) + (bb**2))**0.5
-
-      h_rad = Math.atan2(bb, aa)
-      h = h_rad * (180.0 / Math::PI)
-
-      h %= 360
-
-      [l, c, h]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class CielchConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:l, :c, :h, :space] == [] && colour_input[:space].to_s == 'cie'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], c: [0.0, 150.0], h: [0.0, 360.0] }
+    end
+
+    private
+
+    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(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(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)
+
+      a = c * Math.cos(h_rad).to_d
+      b = c * Math.sin(h_rad).to_d
+
+      [l, a, b]
+    end
+
+    def self.cielab_to_cielch(lab_array)
+      l, aa, bb = lab_array.map(&:to_d)
+
+      e = 0.0015.to_d; # if chroma is smaller than this, set hue to 0 [https://www.w3.org/TR/css-color-4/#color-conversion-code]
+
+      c = ((aa**2.to_d) + (bb**2.to_d))**0.5.to_d
+
+      h_rad = Math.atan2(bb, aa).to_d
+      h = h_rad * (180.0.to_d / Math::PI.to_d)
+
+      h %= 360
+
+      h = 0 if c < e
+
+      [l, c, h]
+    end
+  end
+end

data/lib/color_converters/converters/cmyk_converter.rb

@@ -1,56 +1,59 @@
-module ColorConverters
-  class CmykConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:c, :m, :y, :k] == []
-    end
-
-    def self.bounds
-      { c: [0.0, 100.0], m: [0.0, 100.0], y: [0.0, 100.0], k: [0.0, 100.0] }
-    end
-
-    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])
-    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
-
-      c /= 100.0
-      m /= 100.0
-      y /= 100.0
-      k /= 100.0
-
-      r = (255 * (1.0 - [1.0, c * (1.0 - k) + k].min)).round(IMPORT_DP)
-      g = (255 * (1.0 - [1.0, m * (1.0 - k) + k].min)).round(IMPORT_DP)
-      b = (255 * (1.0 - [1.0, y * (1.0 - k) + k].min)).round(IMPORT_DP)
-
-      { r: r, g: g, b: b, a: 1.0 }
-    end
-
-    def self.rgb_to_cmyk(rgb_array_frac)
-      r, g, b = rgb_array_frac
-
-      k = (1.0 - [r, g, b].max)
-      k_frac = k == 1.0 ? 1.0 : 1.0 - k
-
-      c = (1.0 - r - k) / k_frac
-      m = (1.0 - g - k) / k_frac
-      y = (1.0 - b - k) / k_frac
-
-      c *= 100
-      m *= 100
-      y *= 100
-      k *= 100
-
-      [c, m, y, k]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class CmykConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:c, :m, :y, :k] == []
+    end
+
+    def self.bounds
+      { c: [0.0, 100.0], m: [0.0, 100.0], y: [0.0, 100.0], k: [0.0, 100.0] }
+    end
+
+    private
+
+    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(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
+      y /= 100.0
+      k /= 100.0
+
+      r = (255 * (1.0 - [1.0, c * (1.0 - k) + k].min))
+      g = (255 * (1.0 - [1.0, m * (1.0 - k) + k].min))
+      b = (255 * (1.0 - [1.0, y * (1.0 - k) + k].min))
+
+      [r, g, b, 1.0]
+    end
+
+    def self.rgb_to_cmyk(rgb_array_frac)
+      r, g, b = rgb_array_frac
+
+      k = (1.0 - [r, g, b].max)
+      k_frac = k == 1.0 ? 1.0 : 1.0 - k
+
+      c = (1.0 - r - k) / k_frac
+      m = (1.0 - g - k) / k_frac
+      y = (1.0 - b - k) / k_frac
+
+      c *= 100
+      m *= 100
+      y *= 100
+      k *= 100
+
+      [c, m, y, k]
+    end
+  end
+end

data/lib/color_converters/converters/hex_converter.rb

@@ -1,32 +1,45 @@
-module ColorConverters
-  class HexConverter < BaseConverter
-    def self.matches?(color)
-      return false unless color.is_a?(String)
-
-      color.include?('#') && [4, 7, 9].include?(color.length)
-    end
-
-    private
-
-    def validate_input(color_input)
-      # TODO
-      true
-    end
-
-    def input_to_rgba(color_input)
-      color_input = self.normalize_hex(color_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: r, g: g, b: b, a: a }
-    end
-
-    def 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
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class HexConverter < BaseConverter
+    def self.matches?(colour)
+      return false unless colour.is_a?(String)
+
+      colour.include?('#') && [4, 7, 9].include?(colour.length)
+    end
+
+    private
+
+    def validate_input(_colour_input)
+      # TODO
+      [] # to return no errors
+    end
+
+    def input_to_rgba(colour_input)
+      HexConverter.hex_to_rgba(colour_input)
+    end
+
+    def self.hex_to_rgba(hex_input)
+      hex_input = self.normalize_hex(hex_input)
+
+      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 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
+end

data/lib/color_converters/converters/hsl_converter.rb

@@ -1,64 +1,68 @@
-module ColorConverters
-  class HslConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:h, :s, :l] == [] || color_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] }
-    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])
-    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
-
-      return greyscale(l, a) if s.zero?
-
-      t2 = if l < 0.5
-             l * (1 + s)
-           else
-             l + s - l * s
-           end
-
-      t1 = 2 * l - t2
-
-      rgb = [0, 0, 0]
-
-      (0..2).each do |i|
-        t3 = h + 1 / 3.0 * - (i - 1)
-        t3 < 0 && t3 += 1
-        t3 > 1 && t3 -= 1
-
-        val = if 6 * t3 < 1
-                t1 + (t2 - t1) * 6 * t3
-              elsif 2 * t3 < 1
-                t2
-              elsif 3 * t3 < 2
-                t1 + (t2 - t1) * (2 / 3.0 - t3) * 6
-              else
-                t1
-              end
-
-        rgb[i] = (val * 255).round(IMPORT_DP)
-      end
-
-      { r: rgb[0], g: rgb[1], b: rgb[2], a: a }
-    end
-
-    def greyscale(luminosity, alpha)
-      rgb_equal_value = (luminosity * 255).round(IMPORT_DP)
-      { r: rgb_equal_value, g: rgb_equal_value, b: rgb_equal_value, a: alpha }
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class HslConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      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], a: [0.0, 1.0] }
+    end
+
+    private
+
+    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(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?
+
+      t2 = if l < 0.5
+             l * (1 + s)
+           else
+             l + s - l * s
+           end
+
+      t1 = 2 * l - t2
+
+      rgb = [0, 0, 0]
+
+      (0..2).each do |i|
+        t3 = h + 1 / 3.0 * - (i - 1)
+        t3.negative? && t3 += 1
+        t3 > 1 && t3 -= 1
+
+        val = if 6 * t3 < 1
+                t1 + (t2 - t1) * 6 * t3
+              elsif 2 * t3 < 1
+                t2
+              elsif 3 * t3 < 2
+                t1 + (t2 - t1) * (2 / 3.0 - t3) * 6
+              else
+                t1
+              end
+
+        rgb[i] = (val * 255)
+      end
+
+      [rgb[0], rgb[1], rgb[2], a]
+    end
+
+    def greyscale(luminosity, alpha)
+      rgb_equal_value = (luminosity * 255).round(IMPORT_DP)
+
+      [rgb_equal_value, rgb_equal_value, rgb_equal_value, alpha]
+    end
+  end
+end

data/lib/color_converters/converters/hsl_string_converter.rb

@@ -1,25 +1,46 @@
-module ColorConverters
-  class HslStringConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(String)
-
-      color_input.include?('hsl(') || color_input.include?('hsla(')
-    end
-
-    private
-
-    def validate_input(color_input)
-      true
-    end
-
-    def input_to_rgba(color_input)
-      matches = color_input.match(/hsla?\(([0-9.,%\s]+)\)/)
-      raise InvalidColorError unless matches
-
-      h, s, l, a = matches[1].split(',').map(&:strip)
-      raise InvalidColorError unless h.present? && s.present? && l.present?
-
-      HslConverter.new(h: h, s: s, l: l, a: a).rgba
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class HslStringConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('hsl(') || colour_input.include?('hsla(')
+    end
+
+    def self.bounds
+      HslConverter.bounds
+    end
+
+    private
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('hsla(') ? [:h, :s, :l, :a] : [:h, :s, :l]
+      colour_input = HslStringConverter.sanitize_input(colour_input)
+
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
+
+      return errors if errors.present?
+
+      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]).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
+  end
+end

data/lib/color_converters/converters/hsv_converter.rb

@@ -1,58 +1,60 @@
-module ColorConverters
-  class HsvConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:h, :s, :v] == [] || color_input.keys - [:h, :s, :b] == []
-    end
-
-    def self.bounds
-      { h: [0.0, 360.0], s: [-128.0, 127.0], v: [-128.0, 127.0], b: [-128.0, 127.0] }
-    end
-
-    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
-    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
-
-      h /= 360
-      s /= 100
-      v /= 100
-
-      i = (h * 6).floor
-      f = h * 6 - i
-
-      p = v * (1 - s)
-      q = v * (1 - f * s)
-      t = v * (1 - (1 - f) * s)
-
-      p = (p * 255).round(IMPORT_DP)
-      q = (q * 255).round(IMPORT_DP)
-      t = (t * 255).round(IMPORT_DP)
-      v = (v * 255).round(IMPORT_DP)
-
-      case i % 6
-      when 0
-        { r: v, g: t, b: p, a: 1.0 }
-      when 1
-        { r: q, g: v, b: p, a: 1.0 }
-      when 2
-        { r: p, g: v, b: t, a: 1.0 }
-      when 3
-        { r: p, g: q, b: v, a: 1.0 }
-      when 4
-        { r: t, g: p, b: v, a: 1.0 }
-      when 5
-        { r: v, g: p, b: q, a: 1.0 }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class HsvConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:h, :s, :v] == [] || colour_input.keys - [:h, :s, :b] == []
+    end
+
+    def self.bounds
+      { h: [0.0, 360.0], s: [-128.0, 127.0], v: [-128.0, 127.0], b: [-128.0, 127.0] }
+    end
+
+    private
+
+    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(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
+      v /= 100
+
+      i = (h * 6).floor
+      f = h * 6 - i
+
+      p = v * (1 - s)
+      q = v * (1 - f * s)
+      t = v * (1 - (1 - f) * s)
+
+      p = (p * 255).round(IMPORT_DP)
+      q = (q * 255).round(IMPORT_DP)
+      t = (t * 255).round(IMPORT_DP)
+      v = (v * 255).round(IMPORT_DP)
+
+      case i % 6
+      when 0
+        [v, t, p, 1.0]
+      when 1
+        [q, v, p, 1.0]
+      when 2
+        [p, v, t, 1.0]
+      when 3
+        [p, q, v, 1.0]
+      when 4
+        [t, p, v, 1.0]
+      when 5
+        [v, p, q, 1.0]
+      end
+    end
+  end
+end