decolmor 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 391babdff79d7e079f2282aa45ad285323c2b58b87e518bb2d26ad8e1192a4e3
-  data.tar.gz: 14aa6f29f76b05ab2e853e438e60b4e6705fb147a4ecebaccf1375778e88ad12
+  metadata.gz: 4394b870f83f01ebe74db59131475d1d9a72bd32d307e36b775f903fbfe95b67
+  data.tar.gz: e9aad1484b539e938e666de21bd5eb1a630118646b3391da4d40d95a473ea766
 SHA512:
-  metadata.gz: ce61c17d0dbc5da49013777f8abc332354c681f566a03ee37ab959faa062176f48daa7e4495695580efa74d9b9383f4569be7b0f8fec63922a80730388bd267a
-  data.tar.gz: 6fdd75e6224a79e587dacb66de5d74444196dfc3b4ebb3f592ab689df8435d67150d7bc0751f81289d253c9f1884468b14a94f59bb7f6a972e625d29809f540a
+  metadata.gz: 939483bfc049fefab624f9ed62e10b081684ce020a3b0d96189036eb20747386f9693c831221684eb1403eeb0af899e29382459798fd3bbbebdbf232f8976aec
+  data.tar.gz: 606d35831d04dea98b8405e176240d2cf4ceedd9f7684170b0c972fc9b7db97964ab2c5080de897d3308b900fd5d0b9aeaafb1f8ce5ad899147f320796d6a45a

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 1.2.0 (September 21, 2021)
+
+  * `.hex_to_rgb` now support a returnable alpha in range `0..255`  
+    `.rgb_to_hex` now support incoming alpha in range `0..255`  
+    use the option: `alpha_255: true`
+  * refactor code for methods:
+    - hsl_to_rgb
+    - hsv_to_rgb
+    - hsb_to_rgb
+    - hsl_to_rgb_alt
+    - hsv_to_rgb_alt
+    - hsb_to_rgb_alt  
+    Removed some inaccuracies in the math, which didn't affect the result.  
+    Code in the _alt methods became clearer.  
+    Improved performance, especially _alt methods  
+    (but its still a bit slower than the main methods ~1.3X)
+
 ## 1.1.2 (September 16, 2021)
 
 * Migrate: Travis CI => Github Actions Workflow
@@ -15,11 +32,11 @@
 
 ## 1.1.0 (September 14, 2021)
 
-* ::hex_to_rgb
+* .hex_to_rgb
   * change default rounding 5 => 3 for Alpha channel  
     *reason: 3 digits is enough for a lossless conversion `0..255` -> `0..1` -> `0..255`*
   * for the Alpha channel now you can set rounding as the second argument:  
-  `Decolmor::hex_to_rgb(hex, 2)`
+  `Decolmor.hex_to_rgb(hex, 2)`
   * support short version of HEX  
   e.g: `#CF3`, `0F9`, `#0F9F`
 

data/NEWS.md

@@ -1,5 +1,12 @@
 # News
 
+## 1.2.0 (September 21, 2021)
+
+  * `.hex_to_rgb` now support a returnable alpha in range `0..255`  
+    `.rgb_to_hex` now support incoming alpha in range `0..255`  
+    use the option: `alpha_255: true`
+  * Improved performance for HSL/HSV/HSB => RGB conversion
+
 ## 1.1.2 (September 16, 2021)
 
   * Migrate: Travis CI => Github Actions Workflow
@@ -11,7 +18,7 @@
   
 ## 1.1.0 (September 14, 2021)
 
-  * `::hex_to_rgb` Now supports short version of HEX and rounding for the alpha channel
+  * `.hex_to_rgb` Now supports short version of HEX and rounding for the alpha channel
 
 ## 1.0.0 (September 13, 2021)
 

data/README.md

@@ -8,6 +8,8 @@ Gem for converting color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK
 The Alpha channel (transparency) is supported.  
 There is also a simple RGB generator.  
 
+[News][news] | [Recent releases][releases] | [Changelog][changelog] | [Wiki][wiki]
+
 ## Install
 Add the following line to Gemfile:
 
@@ -46,6 +48,8 @@ SomeClass.rgb_to_hsb(rgb)
 ```
 Gem methods will be available as class methods.
 
+See [WIKI](https://github.com/ChildrenofkoRn/decolmor/wiki/Examples) for more examples.
+
 ## Rounding for HSL/HSV/HSB/CMYK
 By default, rounding 1 is used to convert to HSL/HSV/HSB/CMYK.  
 This is enough to loselessly convert RGB -> HSL/HSV/HSB/CMYK -> RGB:
@@ -80,9 +84,15 @@ If you need to get integers, use 0.
 When converting from HEX to RGBA Alpha channel is converted to a value from the range `0..1` with rounding 3:  
  - 3 digits is enough for a lossless conversion `0..255` -> `0..1` -> `0..255`
 ```ruby
-    Decolmor.hex_to_rgb('#19988BB8')  # => [25, 152, 139, 0.722]
+    Decolmor.hex_to_rgb('#19988BB8')           # => [25, 152, 139, 0.722]
+    Decolmor.hex_to_rgb([25, 152, 139, 0.722)  # => "#19988BB8"
 ```
 Consequently, when converting to HEX from RGBA, Alpha from the range `0..1` is assumed.  
+But you can set range 0..255 for alpha channel:
+```ruby
+    Decolmor.hex_to_rgb('#19988BB8', alpha_255: true)          # => [25, 152, 139, 184]
+    Decolmor.rgb_to_hex([25, 152, 139, 184], alpha_255: true)  # => "#19988BB8"
+```
 You can also set rounding for Alpha channel as a second argument:
 ```ruby
     Decolmor.hex_to_rgb('#19988BB8', 2)  # => [25, 152, 139, 0.72]
@@ -109,7 +119,7 @@ or
 - hsv_to_rgb_alt
 - hsb_to_rgb_alt
 
-The results of the two implementations are identical, but the alternative versions (postfix `_alt`) are ~1.6X slower.
+The results of the two implementations are identical, but the alternative versions (postfix `_alt`) are ~1.35X slower.
 
 ## Attention for CMYK !
 Unfortunately, there is no simple formula for linear RGB to/from CMYK conversion.  
@@ -117,7 +127,7 @@ This implementation is a simplified/dirty/simulation.
 CMYK is used for printing and the correct conversion will be non-linear, based on the color profile for the particular printing device.  
 Therefore, the CMYK conversion results will not match Adobe products.  
 **BUT:**  
-Conversion to HEX/RGB/HSL/HSV/HSB is simple and is described by formulas.  
+Conversion from/to HEX/RGB/HSL/HSV/HSB is simple and is described by formulas.  
 Read more: https://en.wikipedia.org/wiki/HSL_and_HSV  
 The results when rounded to an integer will be the same as when using graphics editors, such as CorelDRAW or Adobe Photoshop.
 
@@ -137,7 +147,7 @@ The results when rounded to an integer will be the same as when using graphics e
    - hsl_to_rgb
    - hsv_to_rgb
    - hsb_to_rgb
- - Alternative implementation HSL/HSV/HSB to RGB(A) (~1.6X slower)
+ - Alternative implementation HSL/HSV/HSB to RGB(A) (a little slower)
    - hsl_to_rgb_alt
    - hsv_to_rgb_alt
    - hsb_to_rgb_alt
@@ -162,6 +172,12 @@ Copyright (c) 2021 ChildrenofkoRn
   [codecov]: https://codecov.io/gh/ChildrenofkoRn/decolmor "codecov"
   [badge-codecov]: https://codecov.io/gh/ChildrenofkoRn/decolmor/branch/main/graph/badge.svg?token=5P4OQUXC3N "codecov"
   [github-workflow]: https://github.com/ChildrenofkoRn/decolmor/actions/workflows/build.yml "build"
-  [badge-build]: https://github.com/ChildrenofkoRn/decolmor/actions/workflows/build.yml/badge.svg "build status"
+  [badge-build]: https://img.shields.io/github/workflow/status/ChildrenofkoRn/decolmor/build/main "build status"
   [license]: https://github.com/ChildrenofkoRn/decolmor/blob/main/LICENSE "MIT"
   [badge-license]: https://img.shields.io/github/license/ChildrenofkoRn/decolmor?color=%23239393 "license"
+
+
+  [changelog]: https://github.com/ChildrenofkoRn/decolmor/blob/main/CHANGELOG.md "changelog"
+  [news]: https://github.com/ChildrenofkoRn/decolmor/blob/main/NEWS.md "news"
+  [releases]: https://github.com/ChildrenofkoRn/decolmor/releases "releases"
+  [wiki]: https://github.com/ChildrenofkoRn/decolmor/wiki "wiki"

data/lib/decolmor/main.rb

@@ -5,7 +5,7 @@ module Decolmor
   end
 
   #========= Set default rounding for HSL/HSV/HSB/CMYK conversion ========
-  
+
   # round 1 enough for lossless conversion RGB -> HSL/HSV/HSB -> RGB
   # for lossless conversion HSL <==> HSV (HSB) better to use round 2
   #
@@ -21,7 +21,7 @@ module Decolmor
 
     #========= HEX <==> RGB(A) =============================================
 
-    def hex_to_rgb(hex, alpha_round = 3)
+    def hex_to_rgb(hex, alpha_round = 3, alpha_255: false)
       hex = hex.gsub('#','')
       hex = if [3, 4].include? hex.length
               hex.chars.map{ |char| char * 2 }
@@ -29,13 +29,20 @@ module Decolmor
               hex.scan(/../)
             end
       rgb = hex.map(&:hex)
-      rgb.size == 4 ? rgb + [(rgb.delete_at(3) / 255.to_f).round(alpha_round)] : rgb
+      if rgb.size == 4
+        rgb[3] = (rgb[3] / 255.to_f).round(alpha_round) unless alpha_255
+      end
+
+      rgb
     end
 
-    def rgb_to_hex(rgb)
-      template = rgb.size == 3 ? "#%02X%02X%02X" : "#%02X%02X%02X%02X"
-      rgb = rgb[0..2] + [(rgb[3] * 255).round] if rgb.size == 4
-      template % rgb
+    def rgb_to_hex(rgb, alpha_255: false)
+      if rgb.size == 3
+        "#%02X%02X%02X" % rgb
+      else
+        rgb[3] = (rgb[3] * 255).round unless alpha_255
+        "#%02X%02X%02X%02X" % rgb
+      end
     end
 
     #=======================================================================
@@ -103,14 +110,14 @@ module Decolmor
 
       # calculation intermediate values
       a = saturation * [lightness, 1 - lightness].min
-      converter = proc do |n|
-        k = (n + hue / 30) % 12
-        lightness - a * [-1, [k - 3, 9 - k, 1].min].max
-      end
 
       # calculation rgb & scaling into range 0..255
       rgb = [0, 8, 4]
-      rgb.map! { |channel| (converter.call(channel) * 255).round }
+      rgb.map! do |channel|
+        k = (channel + hue / 30) % 12
+        channel = lightness - a * [-1, [k - 3, 9 - k, 1].min].max
+        (channel * 255).round
+      end
       alpha.nil? ? rgb : rgb + [alpha]
     end
 
@@ -120,15 +127,13 @@ module Decolmor
       saturation /= 100
       value /= 100
 
-      # calculation intermediate values
-      converter = proc do |n|
-        k = (n + hue / 60) % 6
-        value - value * saturation * [0, [k, 4 - k, 1].min].max
-      end
-
       # calculation rgb & scaling into range 0..255
       rgb = [5, 3, 1]
-      rgb.map! { |channel| (converter.call(channel) * 255).round }
+      rgb.map! do |channel|
+        k = (channel + hue / 60) % 6
+        channel = value - value * saturation * [0, [k, 4 - k, 1].min].max
+        (channel * 255).round
+      end
       alpha.nil? ? rgb : rgb + [alpha]
     end
 
@@ -146,22 +151,11 @@ module Decolmor
       chroma = (1 - (2 * lightness - 1).abs) * saturation
       hue /= 60
       x = chroma * (1 - (hue % 2 - 1).abs)
-
-      # possible RGB points
-      points = [[chroma, x, 0],
-                [x, chroma, 0],
-                [0, chroma, x],
-                [0, x, chroma],
-                [x, 0, chroma],
-                [chroma, 0, x]]
-      # point selection based on entering HUE input in range
-      point = points.each_with_index.detect { |rgb_, n| (n..n + 1).include? hue }&.first
-      # if point == nil (hue undefined)
-      rgb = point || [0, 0, 0]
+      point = get_rgb_point(hue, chroma, x)
 
       # calculation rgb & scaling into range 0..255
       m = lightness - chroma / 2
-      rgb.map! { |channel| ((channel + m) * 255).round }
+      rgb = point.map { |channel| ((channel + m) * 255).round }
       alpha.nil? ? rgb : rgb + [alpha]
     end
 
@@ -175,22 +169,11 @@ module Decolmor
       chroma = value * saturation
       hue /= 60
       x = chroma * (1 - (hue % 2 - 1).abs)
-
-      # possible RGB points
-      points = [[chroma, x, 0],
-                [x, chroma, 0],
-                [0, chroma, x],
-                [0, x, chroma],
-                [x, 0, chroma],
-                [chroma, 0, x]]
-      # point selection based on entering HUE input in range
-      point = points.each_with_index.detect { |rgb_, n| (n * (1 / 100.000)...n + 1).include? hue }&.first
-      # if point == nil (hue undefined)
-      rgb = point || [0, 0, 0]
+      point = get_rgb_point(hue, chroma, x)
 
       # calculation rgb & scaling into range 0..255
       m = value - chroma
-      rgb.map! { |channel| ((channel + m) * 255).round }
+      rgb = point.map { |channel| ((channel + m) * 255).round }
       alpha.nil? ? rgb : rgb + [alpha]
     end
 
@@ -293,9 +276,25 @@ module Decolmor
               # blue is max
               (red - green) / chroma + 4
             end
-      hue *= 60
-      # make negative HUEs positive behind 360°
-      0 <= hue ? hue : hue + 360
+      hue * 60
+
+      # HUE will never leave the 0..360 range when RGB is within 0..255
+      # make negative HUEs positive
+      # 0 <= hue ? hue : hue + 360
+    end
+
+    # possible RGB points
+    # point selection based on entering HUE input in range
+    def get_rgb_point(hue, chroma, x)
+      case hue
+      when 0...1 then [chroma, x, 0]
+      when 1...2 then [x, chroma, 0]
+      when 2...3 then [0, chroma, x]
+      when 3...4 then [0, x, chroma]
+      when 4...5 then [x, 0, chroma]
+      when 5...6 then [chroma, 0, x]
+      else [0, 0, 0]
+      end
     end
   end
 

data/lib/decolmor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Decolmor
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

data/spec/decolmor_spec.rb

@@ -68,6 +68,14 @@ RSpec.describe Decolmor do
         end
       end
 
+      it "set range 0..255 for alpha channel" do
+        color = colors.keys.sample
+        alphas.each_pair do |hex_alpha, alpha|
+          hex = format('%s%s', color, hex_alpha)
+          expect( Decolmor.hex_to_rgb(hex, alpha_255: true).last ).to eq alpha[:rgb_255]
+        end
+      end
+
       it "HEX w alpha channel and w/o prefix # to RGBA" do
         color = colors.keys.sample
 
@@ -100,12 +108,22 @@ RSpec.describe Decolmor do
       it "RGBA converts to HEX w alpha" do
         color = colors.keys.sample
 
-        alphas.each_pair do |hex, alpha|
-          hex = format('%s%s', color, hex)
+        alphas.each_pair do |hex_alpha, alpha|
+          hex = format('%s%s', color, hex_alpha)
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_hex(rgba) ).to eq hex
         end
       end
+
+      it "set range 0..255 for alpha channel" do
+        color = colors.keys.sample
+
+        alphas.each_pair do |hex_alpha, alpha|
+          hex = format('%s%s', color, hex_alpha)
+          rgba = colors[color][:rgb] + [alpha[:rgb_255]]
+          expect( Decolmor.rgb_to_hex(rgba, alpha_255: true) ).to eq hex
+        end
+      end
     end
   end
 
@@ -145,7 +163,7 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to HSL unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_hsl(rgba).last ).to eq alpha[:rgb]
         end
@@ -160,7 +178,7 @@ RSpec.describe Decolmor do
 
       it "setting rounding doesn't affect alpha channel" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           # alpha shouldn't be rounded because its range is 0..1
           # if that did happen, we would get 0 or 1 instead of the normal value
@@ -182,7 +200,7 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to HSV unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_hsv(rgba).last ).to eq alpha[:rgb]
         end
@@ -196,7 +214,7 @@ RSpec.describe Decolmor do
 
       it "setting rounding doesn't affect alpha channel" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_hsv(rgba, 0).last ).to eq alpha[:rgb]
         end
@@ -217,14 +235,14 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsl_to_rgb(values[:hsl]) ).to eq values[:rgb]
         end
       end
 
       it "alpha channel pass to RGB unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, values|
+        alphas.each_pair do |_hex_alpha, values|
           hsla = colors[color][:hsl] + [values[:rgb]]
           expect( Decolmor.hsl_to_rgb(hsla).last ).to eq values[:rgb]
         end
@@ -236,14 +254,14 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsv_to_rgb(values[:hsv]) ).to eq values[:rgb]
         end
       end
 
       it "alpha channel pass to RGB unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, values|
+        alphas.each_pair do |_hex_alpha, values|
           hsva = colors[color][:hsv] + [values[:rgb]]
           expect( Decolmor.hsv_to_rgb(hsva).last ).to eq values[:rgb]
         end
@@ -264,18 +282,26 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsl_to_rgb_alt(values[:hsl]) ).to eq values[:rgb]
         end
       end
 
       it "alpha channel pass to RGB unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, values|
+        alphas.each_pair do |_hex_alpha, values|
           hsla = colors[color][:hsl] + [values[:rgb]]
           expect( Decolmor.hsl_to_rgb_alt(hsla).last ).to eq values[:rgb]
         end
       end
+
+      it "if hue not a range member 0..360 return identical RGB values (colorless)" do
+        colors.each_pair do |hex, values|
+          hsl = values[:hsl]
+          hsl[0] += 360
+          expect( Decolmor.hsl_to_rgb_alt(hsl).uniq.size ).to eq 1
+        end
+      end
     end
 
     describe ".hsv_to_rgb_alt" do
@@ -283,18 +309,26 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsv_to_rgb_alt(values[:hsv]) ).to eq values[:rgb]
         end
       end
 
       it "alpha channel pass to RGB unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, values|
+        alphas.each_pair do |_hex_alpha, values|
           hsva = colors[color][:hsv] + [values[:rgb]]
           expect( Decolmor.hsv_to_rgb_alt(hsva).last ).to eq values[:rgb]
         end
       end
+
+      it "if hue not a range member 0..360 return identical RGB values (colorless)" do
+        colors.each_pair do |_hex, values|
+          hsl = values[:hsl]
+          hsl[0] -= 360
+          expect( Decolmor.hsl_to_rgb_alt(hsl).uniq.size ).to eq 1
+        end
+      end
     end
 
     describe ".hsb_to_rgb_alt" do
@@ -320,21 +354,21 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to HSV unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           hsla = colors[color][:hsl] + [alpha[:rgb]]
           expect( Decolmor.hsl_to_hsv(hsla).last ).to eq alpha[:rgb]
         end
       end
 
       it "you can set rounding for resulting HSV values (default = 1)" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsl_to_hsv(values[:hsl], 0) ).to eq values[:hsv].map(&:round)
         end
       end
 
       it "setting rounding doesn't affect alpha channel" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           hsla = colors[color][:hsl] + [alpha[:rgb]]
           expect( Decolmor.hsl_to_hsv(hsla, 0).last ).to eq alpha[:rgb]
         end
@@ -353,7 +387,7 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to HSL" do
-        colors.each_pair do |hex_, values|
+        colors.each_pair do |_hex, values|
           hsl = values[:hsl].map { |value| value.round(1) }
           expect( Decolmor.hsv_to_hsl(values[:hsv]) ).to eq hsl
         end
@@ -361,21 +395,21 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to HSL unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           hsva = colors[color][:hsv] + [alpha[:rgb]]
           expect( Decolmor.hsv_to_hsl(hsva).last ).to eq alpha[:rgb]
         end
       end
 
       it "you can set rounding for resulting HSL values (default = 1)" do
-        colors.each_pair do |hex, values|
+        colors.each_pair do |_hex, values|
           expect( Decolmor.hsv_to_hsl(values[:hsv], 0) ).to eq values[:hsl].map(&:round)
         end
       end
 
       it "setting rounding doesn't affect alpha channel" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex, alpha|
           hsva = colors[color][:hsv] + [alpha[:rgb]]
           expect( Decolmor.hsv_to_hsl(hsva, 0).last ).to eq alpha[:rgb]
         end
@@ -405,7 +439,7 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to HSL unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_cmyk(rgba).last ).to eq alpha[:rgb]
         end
@@ -419,7 +453,7 @@ RSpec.describe Decolmor do
 
       it "setting rounding doesn't affect alpha channel" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, alpha|
+        alphas.each_pair do |_hex_alpha, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
           expect( Decolmor.rgb_to_cmyk(rgba, 0).last ).to eq alpha[:rgb]
         end
@@ -438,7 +472,7 @@ RSpec.describe Decolmor do
 
       it "alpha channel pass to RGB unchanged" do
         color = colors.keys.sample
-        alphas.each_pair do |hex_, values|
+        alphas.each_pair do |_hex_alpha, values|
           cmyka = colors[color][:cmyk] + [values[:rgb]]
           expect( Decolmor.cmyk_to_rgb(cmyka).last ).to eq values[:rgb]
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decolmor
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - ChildrenofkoRn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-16 00:00:00.000000000 Z
+date: 2021-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler