inker 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b10c6175394e05edd4ed0b06d2918ef04afbdcea95622e5750c775190e9ab1be
-  data.tar.gz: c7624699d33612900f67e7c56a305c25c9e9383bc0b8018027e824f48232712f
+  metadata.gz: 7370c38d26fedfe8febdbde4adf0ac33839d79407f5241720805c2c2046dc1fe
+  data.tar.gz: ea6515cc1a86c2bdc5496c0887dee380c375013f4fcec864ca58fb91b3f7c4c5
 SHA512:
-  metadata.gz: b09ec678085c9d58e157999e41cfdc6edfb6317dfeec283aa9736319897b387e0eca9d27fbe9344f5143b2b4e864e4c64e991144a72be276712856f13b41e8b2
-  data.tar.gz: 2eb54559b2f4d05cee14c792a1362cb6678e5957e69a776ae87d5ea35f209b1f6ada3c27d4fc9ca3bef82700d57dadbfc8f461dc4d8b61fb00a45c31827c50fc
+  metadata.gz: 77fde4a81b7b6309f35689f9fb4fef1534de80a0bf6668d5707b07ab36803298f91e3aa7af9b0dd4bd3a34e302d562e459c2321a13209bcc78bedf2adb0af926
+  data.tar.gz: a1bee3f124ebfd3f0cfa606fe7274cdce7d8e08bfba1166f9a3b2c8e98d821eaab50bdb153cab252a5f3599eef1a2caa2a0ab56a89de3a39f3c65c3ec05bb684

data/README.md

@@ -95,22 +95,24 @@ Inker implements some useful features for getting useful color info an color man
 
 ### Instance methods
 
-| Method name   | Description                                                       |
-|---------------|-------------------------------------------------------------------|
-| `#red`        | Returns the value of red component in range `0-255`               |
-| `#red=`       | Allows to set a new value for red component in range `0-255`      |
-| `#green`      | Returns the value of green component in range `0-255`             |
-| `#green=`     | Allows to set a new value for green component in range `0-255`    |
-| `#blue`       | Returns the value of blue component in range `0-255`              |
-| `#blue=`      | Allows to set a new value for blue component in range `0-255`     |
-| `#alpha`      | Returns the value of alpha component in range `0.0-1.0`           |
-| `#alpha=`     | Allows to set a new value for alpha component in range `0.0-1.0`  |
-| `#brightness` | Returns the brightness of the color in range `0-255`              |
-| `#dark?`      | Returns a boolean (`true` when color is dark)                     |
-| `#light?`     | Returns a boolean (`true` when color is light)                    |
-| `#lightness`  | Returns the lightness of the color in range `0.0-1.0`             |
-| `#saturation` | Returns the saturation of the color in range `0.0-1.0`            |
-| `#hue`        | Retursn the value of HUE component of the color in range `0-360`  |
+| Method name                    | Description                                                                                                                                 |
+|--------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------|
+| `#red`                         | Returns the value of red component in range `0-255`                                                                                         |
+| `#red=`                        | Allows to set a new value for red component in range `0-255`                                                                                |
+| `#green`                       | Returns the value of green component in range `0-255`                                                                                       |
+| `#green=`                      | Allows to set a new value for green component in range `0-255`                                                                              |
+| `#blue`                        | Returns the value of blue component in range `0-255`                                                                                        |
+| `#blue=`                       | Allows to set a new value for blue component in range `0-255`                                                                               |
+| `#alpha`                       | Returns the value of alpha component in range `0.0-1.0`                                                                                     |
+| `#alpha=`                      | Allows to set a new value for alpha component in range `0.0-1.0`                                                                            |
+| `#brightness`                  | Returns the brightness of the color in range `0-255`                                                                                        |
+| `#dark?`                       | Returns a boolean (`true` when color is dark)                                                                                               |
+| `#light?`                      | Returns a boolean (`true` when color is light)                                                                                              |
+| `#lightness`                   | Returns the lightness of the color in range `0.0-1.0`                                                                                       |
+| `#saturation`                  | Returns the saturation of the color in range `0.0-1.0`                                                                                      |
+| `#hue`                         | Retursn the value of HUE component of the color in range `0-360`                                                                            |
+| `#contrast_ratio(other_color)` | Calculates the contrast ratio between current color end `other_color` [1-21]. A good contrast should return a value between `4.5` and `21`. |
+| `#overlay(other_color)`        | Calculates the result of the overlay between current color end `other_color`                                                                |
 
 ### Class methods
 
@@ -122,6 +124,8 @@ Inker implements some useful features for getting useful color info an color man
 | `Inker::Color.from_hsla(Integer, Float, Float, Float)`      | Same as `Inker::Color.from_hsl`, but has also the alpha component                                       |
 | `Inker::Color.from_custom_string(String, options)`          | Generate a new `Inker::Color` from a custom string, by getting HEX characters from MD5 digest of input string. By setting `:position` option you can change the index of target HEX chars that are used for HEX color generation. (default `position: [0, 29, 14, 30, 28, 31]`)                                                         |
 | `Inker::Color.random`                                       | Generate a random `Inker::Color` instance                                                               |
+| `Inker::Color.contrast_ratio(color1, color2)`               | Calculates the contrast ratio between two colors and returns a value in range `[1-21]`. Colors could be specified as `Inker::Color` instances or strings. |
+| `Inker::Color.overlay(color1, color)`                       | Calculates the result of the overlay between two colors and returns a new `Inker::Color` instance. |
 
 ## Development
 

data/lib/inker/color/serializers.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 module Inker
   class Color
     # This module implements the methods which can be used to serialize
     # a color as string in different formats.
     module Serializers
-
       # Convert color to a HEX color string.
       #
       # @param force_alpha [Boolean] indicates if alpha channel should be included in HEX color string
@@ -11,59 +12,54 @@ module Inker
       # @return [String] a HEX color string
       def hex(force_alpha: false)
         result = hex6
-        result += (alpha * 255).to_i.to_s(16).rjust(2, "0") if alpha < 1 or force_alpha
+        result += (alpha * 255).to_i.to_s(16).rjust(2, '0') if alpha < 1 || force_alpha
 
-        return result
+        result
       end
 
-
       # Convert color to a HEX color string without alpha channel.
       #
       # @return [String] a HEX color string without alpha channel
       def hex6
         result = "#"
-        result += red.to_s(16).rjust(2, "0")
-        result += green.to_s(16).rjust(2, "0")
-        result += blue.to_s(16).rjust(2, "0")
+        result += red.to_s(16).rjust(2, '0')
+        result += green.to_s(16).rjust(2, '0')
+        result += blue.to_s(16).rjust(2, '0')
 
-        return result
+        result
       end
 
-
       # Convert color to RGB color string.
       #
       # @return [String] a RGB color string
       def rgb
-        return "rgb(#{red}, #{green}, #{blue})"
+        "rgb(#{red}, #{green}, #{blue})"
       end
 
-
       # Convert color to RGBA color string.
       #
       # @param alpha_precision [Integer] indicates the precision of alpha value
       #
       # @return [String] a RGBA color string
       def rgba(alpha_precision: 2)
-        return "rgba(#{red}, #{green}, #{blue}, #{alpha.round(alpha_precision)})"
+        "rgba(#{red}, #{green}, #{blue}, #{alpha.round(alpha_precision)})"
       end
 
-
       # Convert color to HSL color string.
       #
       # @return [String] a HSL color string
       def hsl
-        return "hsl(#{hue}, #{(saturation * 100).round}%, #{(lightness * 100).round}%)"
+        "hsl(#{hue}, #{(saturation * 100).round}%, #{(lightness * 100).round}%)"
       end
 
-
       # Convert color to HSL color string.
       #
       # @param alpha_precision [Integer] indicates the precision of alpha value
       #
       # @return [String] a HSL color string
       def hsla(alpha_precision: 2)
-        return "hsl(#{hue}, #{(saturation * 100).round}%, #{(lightness * 100).round}%, #{alpha.round(alpha_precision)})"
+        "hsl(#{hue}, #{(saturation * 100).round}%, #{(lightness * 100).round}%, #{alpha.round(alpha_precision)})"
       end
     end
   end
-end
+end

data/lib/inker/color/tools.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module Inker
   class Color
     # Tools module implements a set of methods useful for color parsing and
     # for getting useful info about color.
     module Tools
       # Regular expression for HEX colors matching
-      HEX_REGEX = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/
+      HEX_REGEX = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/.freeze
 
       # Regular expression for RGB colors matching
-      RGB_REGEX = /^rgb\((\d+,){2}\d+\)$/
+      RGB_REGEX = /^rgb\((\d+,){2}\d+\)$/.freeze
 
       # Regular expression for RGBA colors matching
-      RGBA_REGEX = /^rgba\((\d+,){3}\d+(.\d+)?\)$/
+      RGBA_REGEX = /^rgba\((\d+,){3}\d+(.\d+)?\)$/.freeze
 
       # Regular expression for HSL colors matching
-      HSL_REGEX = /^hsl\((\d+)(,\d+%|,\d+(.\d+)){2}\)$/
+      HSL_REGEX = /^hsl\((\d+)(,\d+%|,\d+(.\d+)){2}\)$/.freeze
 
       # Regular expression for HSLA colors matching
-      HSLA_REGEX = /^hsla\((\d+)(,\d+%|,\d+(.\d+)){2},\d+(.\d+)?\)$/
+      HSLA_REGEX = /^hsla\((\d+)(,\d+%|,\d+(.\d+)){2},\d+(.\d+)?\)$/.freeze
 
       # Calculate the brightness of a color.
       #
@@ -29,7 +31,6 @@ module Inker
         Math.sqrt(0.299 * red**2 + 0.587 * green**2 + 0.114 * blue**2).round
       end
 
-
       # Calculate the lightness of a color from RGB components.
       #
       # @param red [Integer] the value of red component [0-255]
@@ -40,10 +41,9 @@ module Inker
       def lightness(red, green, blue)
         min, max = [red, green, blue].minmax
 
-        return (min + max) / (2.0 * 255)
+        (min + max) / (2.0 * 255)
       end
 
-
       # Calculate the saturation of a color from RGB components.
       #
       # @param red [Integer] the value of red component [0-255]
@@ -53,15 +53,14 @@ module Inker
       # @return [Float] a value in range 0.0-1.0 which indicates the saturation of the color
       def saturation(red, green, blue)
         # return 0 for black and white colors
-        return 0 if red == green and red == blue and (red == 0 or red == 255)
+        return 0 if red == green && red == blue && (red.zero? || red == 255)
 
         lightness = lightness(red, green, blue)
         min, max = [red / 255.0, green / 255.0, blue / 255.0].minmax
 
-        return lightness < 0.5 ? (max - min) / (max + min) : (max - min) / (2.0 - max - min)
+        lightness < 0.5 ? (max - min) / (max + min) : (max - min) / (2.0 - max - min)
       end
 
-
       # Calculate the HUE value of a color from RGB components.
       #
       # @param red [Integer] the value of red component [0-255]
@@ -73,15 +72,34 @@ module Inker
         min, max = [red, green, blue].minmax
 
         numerator = (max - min).to_f
-        return 0 if numerator == 0
+        return 0 if numerator.zero?
+
+        hue = case max
+              when red then (green - blue) / numerator
+              when green then 2 + (blue - red) / numerator
+              when blue then 4 + (red - green) / numerator
+              end
+
+        hue *= 60
 
-        hue = (red == max)   ? (green - blue) / numerator :
-              (green == max) ? 2 + (blue - red) / numerator :
-                               4 + (red - green) / numerator
-        hue = hue * 60
-        return (hue < 0 ? hue + 360 : hue).round
+        (hue.negative? ? hue + 360 : hue).round
       end
 
+      # Calculate the luminance of a color from RGB components.
+      #
+      # @param red [Integer] the value of red component [0-255]
+      # @param green [Integer] the value of green component [0-255]
+      # @param blue [Integer] the value of blue component [0-255]
+      #
+      # @return [Float] a value in range 0.0-1.0 which indicates the luminance of the color
+      def luminance(red, green, blue)
+        components = [red, green, blue].map do |c|
+          value = c / 255.0
+          value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055)**2.4
+        end
+
+        0.2126 * components[0] + 0.7152 * components[1] + 0.0722 * components[2]
+      end
 
       # Get RGB values from a color in HSL format.
       #
@@ -91,83 +109,70 @@ module Inker
       #
       # @return [Hash] a `Hash` which contains the values of RGB components
       def hsl_to_rgb(hue, saturation, lightness)
-        result = nil
-        if saturation == 0
-          # There's no saturation, so it's a gray scale color, which
-          # depends only on brightness
-          brightness = (lightness * 255).round
-
-          # All RGB components are equal to brightness
-          result = {
-            red:   brightness,
-            green: brightness,
-            blue:  brightness
-          }
-        else
-          q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation
-          p = 2 * lightness - q
-          norm_hue = hue / 360.0
-
-          result = {
-            red:   (hue_to_rgb(p, q, norm_hue + 1.0/3.0) * 255).round,
-            green: (hue_to_rgb(p, q, norm_hue) * 255).round,
-            blue:  (hue_to_rgb(p, q, norm_hue - 1.0/3.0) * 255).round
-          }
-        end
+        c, x, m = hue_convert_params(hue, saturation, lightness)
+        weights = hsl_hue_weights(hue, c, x)
 
-        return result
+        {
+          red: ((weights[0] + m) * 255).round,
+          green: ((weights[1] + m) * 255).round,
+          blue: ((weights[2] + m) * 255).round
+        }
       end
 
-
       # Returns a `Boolean` which indicates if color is in HEX format
       #
       # @param color_str [String] a color string
       #
       # @return [Boolean] `true` when color is in HEX format
-      def is_hex?(color_str)
+      def hex?(color_str)
         !!(color_str.to_s.downcase.strip =~ HEX_REGEX)
       end
 
+      alias is_hex? hex?
 
       # Returns a `Boolean` which indicates if color is in RGB format
       #
       # @param color_str [String] a color string
       #
       # @return [Boolean] `true` when color is in RGB format
-      def is_rgb?(color_str)
+      def rgb?(color_str)
         !!(color_str.to_s.downcase.gsub(/\s+/, '') =~ RGB_REGEX)
       end
 
+      alias is_rgb? rgb?
 
       # Returns a `Boolean` which indicates if color is in RGBA format
       #
       # @param color_str [String] a color string
       #
       # @return [Boolean] `true` when color is in RGBA format
-      def is_rgba?(color_str)
+      def rgba?(color_str)
         !!(color_str.to_s.downcase.gsub(/\s+/, '') =~ RGBA_REGEX)
       end
 
+      alias is_rgba? rgba?
 
       # Returns a `Boolean` which indicates if color is in HSL format
       #
       # @param color_str [String] a color string
       #
       # @return [Boolean] `true` when color is in HSL format
-      def is_hsl?(color_str)
+      def hsl?(color_str)
         !!(color_str.to_s.downcase.gsub(/\s+/, '') =~ HSL_REGEX)
       end
 
+      alias is_hsl? hsl?
 
       # Returns a `Boolean` which indicates if color is in HSLA format
       #
       # @param color_str [String] a color string
       #
       # @return [Boolean] `true` when color is in HSLA format
-      def is_hsla?(color_str)
+      def hsla?(color_str)
         !!(color_str.to_s.downcase.gsub(/\s+/, '') =~ HSLA_REGEX)
       end
 
+      alias is_hsla? hsla?
 
       # Generate a random `Inker::Color`.
       #
@@ -175,14 +180,13 @@ module Inker
       #
       # @return [Inker::Color] a random color
       def random(with_alpha: false)
-        prefix = with_alpha ? "rgba" : "rgb"
+        prefix = with_alpha ? 'rgba' : 'rgb'
         values = (1..3).map{ (rand * 255).round }
         values << rand.round(2) if with_alpha
 
-        Inker.color("#{prefix}(#{values.join(",")})")
+        Inker.color("#{prefix}(#{values.join(',')})")
       end
 
-
       # A helper for `Inker::Color` generation from RGB components.
       #
       # @param red [Integer] the value of red component [0-255]
@@ -194,7 +198,6 @@ module Inker
         Inker.color("rgb(#{red}, #{green}, #{blue})")
       end
 
-
       # A helper for `Inker::Color` generation from RGBA components.
       #
       # @param red [Integer] the value of red component [0-255]
@@ -207,7 +210,6 @@ module Inker
         Inker.color("rgba(#{red}, #{green}, #{blue}, #{alpha})")
       end
 
-
       # A helper for `Inker::Color` generation from HSL components.
       #
       # @param hue [Integer] the value of HUE component [0-360]
@@ -219,7 +221,6 @@ module Inker
         Inker.color("hsl(#{hue}, #{saturation}, #{lightness})")
       end
 
-
       # A helper for `Inker::Color` generation from HSLA components.
       #
       # @param hue [Integer] the value of HUE component [0-360]
@@ -232,7 +233,6 @@ module Inker
         Inker.color("hsla(#{hue}, #{saturation}, #{lightness}, #{alpha})")
       end
 
-
       # Use MD5 digest of the string to get hex values from specified positions (by default `[0, 29, 14, 30, 28, 31]`)
       # in order to obtain a color in HEX format which represents the specified string.
       #
@@ -243,10 +243,9 @@ module Inker
       # @return [Inker::Color] a `Inker::Color` object which represents the color associated to input string
       def from_custom_string(custom_string, positions: [0, 29, 14, 30, 28, 31])
         digest = Digest::MD5.hexdigest(custom_string.to_s)
-        Inker.color("##{positions.map{|p| digest[p]}.join}")
+        Inker.color("##{positions.map { |p| digest[p] }.join}")
       end
 
-
       # Parse a color string an return it's RGBA components as a hash.
       #
       # @example
@@ -264,19 +263,19 @@ module Inker
 
         # Try to guess the format of color string and parse it by
         # using the apropriate algorithm
-        if is_hex?(input)
+        if hex?(input)
           # Parse the string as HEX color
           result = parse_hex(input)
-        elsif is_rgb?(input)
+        elsif rgb?(input)
           # Parse the string as RGB color
           result = parse_rgb(input)
-        elsif is_rgba?(input)
+        elsif rgba?(input)
           # Parse the string as RGBA color
           result = parse_rgb(input, is_rgba: true)
-        elsif is_hsl?(input)
+        elsif hsl?(input)
           # Parse the string as HSL color
           result = parse_hsl(input)
-        elsif is_hsla?(input)
+        elsif hsla?(input)
           # Parse the string as HSLA color
           result = parse_hsl(input, is_hsla: true)
         else
@@ -290,9 +289,29 @@ module Inker
         end
 
         # If we didn't have any match, throw an ArgumentError error
-        raise ArgumentError.new("Unknown color format: #{color_str.to_s.strip.inspect}") if result.nil?
+        raise ArgumentError, "Unknown color format: #{color_str.to_s.strip.inspect}" if result.nil?
+
+        result
+      end
+
+      # Calculates the contrast ratio between two colors.
+      #
+      # @param color1 [Inker::Color|String] the first color.
+      # @param color2 [Inker::Color|String] the second color.
+      #
+      # @return [Float] the contrast ratio between the two colors [1.0-21.0].
+      def contrast_ratio(color1, color2)
+        color1.to_color.contrast_ratio(color2)
+      end
 
-        return result
+      # Calculates the result of overlaying two colors.
+      #
+      # @param color1 [Inker::Color|String] the first color.
+      # @param color2 [Inker::Color|String] the second color.
+      #
+      # @return [Inker::Color] the result of overlaying the two colors.
+      def overlay(color1, color2)
+        color1.to_color.overlay(color2)
       end
 
       private
@@ -307,25 +326,18 @@ module Inker
         input = color_str.gsub(/^#/, '')
 
         # Convert to HEX6 when color is in HEX3 format
-        input = input.chars.map{|x| x * 2 }.join if input.length == 3
+        input = input.chars.map { |x| x * 2 }.join if input.length == 3
 
         # Get RGB components
-        result = {
-          red:   Integer(input[0..1], 16),
+        {
+          red: Integer(input[0..1], 16),
           green: Integer(input[2..3], 16),
-          blue:  Integer(input[4..5], 16),
-          alpha: 1.0
+          blue: Integer(input[4..5], 16),
+          # When color is in HEX8 format, get also alpha channel value
+          alpha: input.length == 8 ? Integer(input[6..7], 16) / 255.0 : 1.0
         }
-
-        # When color is in HEX8 format, get also alpha channel value
-        if input.length == 8
-          result[:alpha] = Integer(input[6..7], 16) / 255.0
-        end
-
-        return result
       end
 
-
       # Parse color string as RGB(A) color.
       #
       # @param color_str [String] input RGB(A) color string
@@ -333,17 +345,16 @@ module Inker
       #
       # @return [Hash] a `Hash` which contains RGBA components of parsed color
       def parse_rgb(color_str, is_rgba: false)
-        components = color_str.gsub(/(^rgb(a)?\(|\)$)/, "").split(",")
+        components = color_str.gsub(/(^rgb(a)?\(|\)$)/, '').split(',')
 
-        return {
-          red:   components.shift.to_i,
+        {
+          red: components.shift.to_i,
           green: components.shift.to_i,
-          blue:  components.shift.to_i,
+          blue: components.shift.to_i,
           alpha: (is_rgba ? components.shift.to_f : 1.0)
         }
       end
 
-
       # Parse color string as HSL(A) color.
       #
       # @param color_str [String] input HSL(A) color string
@@ -351,23 +362,22 @@ module Inker
       #
       # @return [Hash] a `Hash` which contains RGBA components of parsed color
       def parse_hsl(color_str, is_hsla: false)
-        components = color_str.gsub(/(^hsl(a)?\(|\)$)/, "").split(",")
+        components = color_str.gsub(/(^hsl(a)?\(|\)$)/, '').split(',')
 
-        hue = components.shift.to_i
+        hue = components.shift.to_i % 360
 
         saturation = components.shift
-        saturation = saturation.include?("%") ? saturation.to_f / 100 : saturation.to_f
+        saturation = saturation.include?('%') ? saturation.to_f / 100 : saturation.to_f
 
         lightness = components.shift
-        lightness = lightness.include?("%") ? lightness.to_f / 100 : lightness.to_f
+        lightness = lightness.include?('%') ? lightness.to_f / 100 : lightness.to_f
 
         result = hsl_to_rgb(hue, saturation, lightness)
         result[:alpha] = is_hsla ? components.shift.to_f : 1.0
 
-        return result
+        result
       end
 
-
       # A helper function which allows to calculate the RGB component value from HSL color.
       #
       # @param p [Float] `2 * lightness -q`
@@ -376,14 +386,43 @@ module Inker
       #
       # @return [Float] a value which represents a RGB component in range 0.0-1.0
       def hue_to_rgb(p, q, t)
-        t += 1 if t < 0
+        t += 1 if t.negative?
         t -= 1 if t > 1
 
-        return p + (q - p) * 6 * t         if t < 1.0 / 6.0
-        return q                           if t < 1.0 / 2.0
-        return p + (q - p) * (2/3 - t) * 6 if t < 2.0 / 3.0
-        return p;
+        return p + (q - p) * 6 * t           if t < 1.0 / 6.0
+        return q                             if t < 1.0 / 2.0
+        return p + (q - p) * (2 / 3 - t) * 6 if t < 2.0 / 3.0
+
+        p
+      end
+
+      # Calculate HUE to RGB conversion params, with will be used to calculate RGB components in
+      # combination with the `hsl_hue_weights` function.
+      #
+      # @param hue [Integer] hue component of HSL color [0-359]
+      # @param saturation [Float] saturation component of HSL color [0.0-1.0]
+      # @param lightness [Float] lightness component of HSL color [0.0-1.0]
+      #
+      # @return [Array<Float>] an array which contains the `c`, `x` and `m` values.
+      def hue_convert_params(hue, saturation, lightness)
+        c = (1 - (2 * lightness - 1).abs) * saturation
+        x = c * (1 - ((hue / 60.0) % 2 - 1).abs)
+        m = lightness - c / 2.0
+
+        [c, x, m]
+      end
+
+      # A helper function
+      def hsl_hue_weights(hue, c, x)
+        case hue
+        when 0..59 then [c, x, 0]
+        when 60..119 then [x, c, 0]
+        when 120..179 then [0, c, x]
+        when 180..239 then [0, x, c]
+        when 240..299 then [x, 0, c]
+        when 300..359 then [c, 0, x]
+        end
       end
     end
   end
-end
+end

data/lib/inker/color.rb

@@ -16,62 +16,87 @@ module Inker
     #
     # @param color_str [String] a color string
     def initialize(color_str)
-      @input = color_str.to_s.downcase.gsub(/\s+/, "")
+      input = color_str.to_s.downcase.gsub(/\s+/, '')
 
-      Color.parse_color(@input).tap do |color|
+      Color.parse_color(input).tap do |color|
         @red   = color[:red]
         @green = color[:green]
         @blue  = color[:blue]
         @alpha = color[:alpha]
       end
 
-      validate_color!
+      validate_color!(input)
     end
 
-    def ==(color)
-      self.red   == color.red   and
-      self.green == color.green and
-      self.blue  == color.blue  and
-      self.alpha == color.alpha
+    def ==(other)
+      red == other.red && green == other.green && blue == other.blue && alpha == other.alpha
     end
 
+    # Get RGBA color components.
+    # @return [Array<Integer>] an array of RGBA color components [red, green, blue, alpha].
+    def components
+      [red, green, blue, alpha]
+    end
+
+    alias to_a components
+
+    # Get a RGBA component by index (0 => red, 1 => green, 2 => blue, 3 => alpha).
+    def [](key)
+      components[key]
+    end
+
+    # Set a RGBA component by index (0 => red, 1 => green, 2 => blue, 3 => alpha).
+    def []=(key, value)
+      component_name = %i[red green blue alpha][key]
+      send("#{component_name}=", value)
+    end
+
+    # Iterate over RGBA color components.
+    def each(&block)
+      components.each(&block)
+    end
+
+    # Iterate over RGBA color components with index.
+    def each_with_index(&block)
+      components.each_with_index(&block)
+    end
 
     # Set the value of red component.
     #
     # @param value [Integer] the value of red component [0-255]
     def red=(value)
-      raise ArgumentError.new("Invalid value: #{value.inspect}") if value.to_i < 0 or value.to_i > 255
+      raise ArgumentError, "Invalid value: #{value.inspect}" if value.to_i.negative? || value.to_i > 255
+
       @red = value
     end
 
-
     # Set the value of green component.
     #
     # @param value [Integer] the value of green component [0-255]
     def green=(value)
-      raise ArgumentError.new("Invalid value: #{value.inspect}") if value.to_i < 0 or value.to_i > 255
+      raise ArgumentError, "Invalid value: #{value.inspect}" if value.to_i.negative? || value.to_i > 255
+
       @green = value
     end
 
-
     # Set the value of blue component.
     #
     # @param value [Integer] the value of blue component [0-255]
     def blue=(value)
-      raise ArgumentError.new("Invalid value: #{value.inspect}") if value.to_i < 0 or value.to_i > 255
+      raise ArgumentError, "Invalid value: #{value.inspect}" if value.to_i.negative? || value.to_i > 255
+
       @blue = value
     end
 
-
     # Set the value of alpha component.
     #
     # @param value [Float] the value of alpha component [0.0-1.0]
     def alpha=(value)
-      raise ArgumentError.new("Invalid value: #{value.inspect}") if value.to_f < 0 or value.to_f > 1
+      raise ArgumentError, "Invalid value: #{value.inspect}" if value.to_f.negative? || value.to_f > 1
+
       @alpha = value
     end
 
-
     # Calculate the brightness of a color.
     #
     # @return [Integer] a value between 0-255 which indicates the brightness of the color
@@ -79,7 +104,6 @@ module Inker
       Color.brightness(@red, @green, @blue)
     end
 
-
     # Calculate the lightness of a color.
     #
     # @return [Float] a value between 0.0-1.0 which indicates the lightness of the color
@@ -87,7 +111,6 @@ module Inker
       Color.lightness(@red, @green, @blue)
     end
 
-
     # Calculate the saturation of a color.
     #
     # @return [Float] a value between 0.0-1.0 which indicates the saturation of the color
@@ -95,7 +118,6 @@ module Inker
       Color.saturation(@red, @green, @blue)
     end
 
-
     # Calculate the HUE of a color.
     #
     # @return [Integer] a value between 0-360 which indicates the HUE of the color
@@ -116,6 +138,39 @@ module Inker
       !dark?
     end
 
+    # Returns the luminance of the color.
+    # @return [Float] a value between 0.0-1.0 which indicates the luminance of the color
+    def luminance
+      Color.luminance(@red, @green, @blue)
+    end
+
+    # Calculates the result of 2 colors overlay.
+    # @return [Inker::Color] a new instance of {Inker::Color} which represents the result of the overlay operation.
+    def overlay(color)
+      result = dup
+      other = color.to_color
+
+      return result if alpha >= 1
+
+      alpha_weight = other.alpha * (1 - alpha)
+
+      # Calculate the result of the overlay operation.
+      3.times do |i|
+        result[i] = (self[i] * alpha + other[i] * alpha_weight).round
+      end
+
+      result.alpha = alpha + alpha_weight
+
+      result
+    end
+
+    # Returns the contrast ratio between two colors.
+    # @param [Float] a value between 0.0-21.0 which indicates the contrast ratio between two colors (higher is better).
+    def contrast_ratio(color)
+      l2, l1 = [luminance, color.to_color.luminance].minmax
+
+      (l1 + 0.05) / (l2 + 0.05)
+    end
 
     # Convert color to string in the specified format.
     #
@@ -124,29 +179,33 @@ module Inker
     # @return [String] a string representation of the color
     def to_s(format = 'hex')
       case format.to_s.strip.downcase
-      when 'hex6' then self.hex6
-      when 'rgb'  then self.rgb
-      when 'rgba' then self.rgba
-      when 'hsl'  then self.hsl
-      when 'hsla' then self.hsla
+      when 'hex6' then hex6
+      when 'rgb'  then rgb
+      when 'rgba' then rgba
+      when 'hsl'  then hsl
+      when 'hsla' then hsla
       else
-        self.hex
+        hex
       end
     end
 
+    def to_color
+      self
+    end
+
     private
 
     # Validates the values of the color.
-    def validate_color!
-      invalid = (@red < 0 or @red > 255)
-      invalid ||= (@green < 0 or @green > 255)
-      invalid ||= (@blue < 0 or @blue > 255)
-      invalid ||= (@alpha < 0 or @alpha > 1)
-
-      if invalid
-        raise ArgumentError.new "Invalid color: #{@input.inspect} " \
-          "(R: #{@red.inspect}, G: #{@green.inspect}, B: #{@blue.inspect}, A: #{@alpha.inspect})"
-      end
+    def validate_color!(input)
+      invalid = (@red.negative? || @red > 255)
+      invalid ||= (@green.negative? || @green > 255)
+      invalid ||= (@blue.negative? || @blue > 255)
+      invalid ||= (@alpha.negative? || @alpha > 1)
+
+      return unless invalid
+
+      raise ArgumentError, "Invalid color: #{input.inspect} " \
+        "(R: #{@red.inspect}, G: #{@green.inspect}, B: #{@blue.inspect}, A: #{@alpha.inspect})"
     end
   end
-end
+end

data/lib/inker/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module Inker
   # Inker gem version
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inker
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Groza Sergiu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-31 00:00:00.000000000 Z
+date: 2022-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -112,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A Ruby gem for color manipulation.