color_converters 0.1.4 → 0.1.5

data/lib/color_converters/converters/cielch_converter.rb

@@ -1,61 +1,65 @@
-# 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
+# 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 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(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,59 +1,63 @@
-# 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
+# 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 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(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,45 +1,49 @@
-# 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
+# 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 clamp_input(colour_input)
+    #   colour_input # return it as it was
+    # end
+
+    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,68 +1,72 @@
-# 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
+# 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 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(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,46 +1,61 @@
-# 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
+# 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 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)
+
+      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] }, 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