decolmor 1.0.0 → 1.2.0

data/spec/decolmor_spec.rb

@@ -1,7 +1,20 @@
 load_class(__FILE__)
 
 RSpec.describe Decolmor do
-  describe 'you can set rounding globally for convert to HSL/HSV/HSB/CMYK' do
+
+  describe 'we can include the module into the class' do
+    let(:dummy_class) { Class.new { include Decolmor } }
+
+    it "class contains the module Decolmor" do
+      expect( dummy_class.include?(Decolmor) ).to eq true
+    end
+
+    it "methods will be available into our class as class methods" do
+      expect { dummy_class.hsx_round = 3 }.to change { dummy_class.hsx_round }.from(1).to(3)
+    end
+  end
+
+  describe 'we can set rounding globally for convert to HSL/HSV/HSB/CMYK' do
     after(:each) do
       Decolmor.hsx_round = 1
     end
@@ -9,15 +22,14 @@ RSpec.describe Decolmor do
     let(:colors) { FactoryBot.build(:colors_map, round: 2) }
 
     it ".hsx_round by default 1" do
-      expect( Decolmor::hsx_round ).to eq 1
+      expect( Decolmor.hsx_round ).to eq 1
     end
 
     it ".hsx_round= changes hsx_round" do
-      expect { Decolmor::hsx_round = 2 }.to change { Decolmor.hsx_round }.from(1).to(2)
+      expect { Decolmor.hsx_round = 2 }.to change { Decolmor.hsx_round }.from(1).to(2)
     end
   end
 
-  
   context 'HEX <==> RGB(A)' do
     describe ".hex_to_rgb" do
       let(:colors) { FactoryBot.build(:colors_map) }
@@ -25,24 +37,42 @@ RSpec.describe Decolmor do
 
       it "HEX w prefix # to RGB" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hex_to_rgb(hex) ).to eq values[:rgb]
+          expect( Decolmor.hex_to_rgb(hex) ).to eq values[:rgb]
         end
       end
 
       it "HEX w/o prefix # to RGB" do
         colors.each_pair do |hex, values|
           hex = hex.delete('#')
-          expect( Decolmor::hex_to_rgb(hex) ).to eq values[:rgb]
+          expect( Decolmor.hex_to_rgb(hex) ).to eq values[:rgb]
         end
       end
 
       it "HEX w alpha channel and prefix # to RGBA" do
-        docs "alpha into range 0..1 and rounding 5"
+        docs "alpha into range 0..1 and rounding 3"
         color = colors.keys.sample
         alphas.each_pair do |hex_alpha, alpha|
           hex = format('%s%s', color, hex_alpha)
           rgba = colors[color][:rgb] + [alpha[:rgb]]
-          expect( Decolmor::hex_to_rgb(hex) ).to eq rgba
+          expect( Decolmor.hex_to_rgb(hex) ).to eq rgba
+        end
+      end
+
+      it "set rounding for alpha channel" do
+        color = colors.keys.sample
+        alphas.each_pair do |hex_alpha, alpha|
+          rounding = 2
+          hex = format('%s%s', color, hex_alpha)
+          rgba = colors[color][:rgb] + [alpha[:rgb].round(rounding)]
+          expect( Decolmor.hex_to_rgb(hex, rounding) ).to eq rgba
+        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
 
@@ -52,7 +82,15 @@ RSpec.describe Decolmor do
         alphas.each_pair do |hex_alpha, alpha|
           hex = format('%s%s', color, hex_alpha).delete('#')
           rgba = colors[color][:rgb] + [alpha[:rgb]]
-          expect( Decolmor::hex_to_rgb(hex) ).to eq rgba
+          expect( Decolmor.hex_to_rgb(hex) ).to eq rgba
+        end
+      end
+
+      it "HEX short version to RGB(A)" do
+        colors = {'6FC' => [102, 255, 204], '#9C3' => [153, 204, 51], '36FF' => [51, 102, 255, 1]}
+
+        colors.each_pair do |hex_short, rgb|
+          expect( Decolmor.hex_to_rgb(hex_short) ).to eq rgb
         end
       end
     end
@@ -63,17 +101,27 @@ RSpec.describe Decolmor do
 
       it "RGB converts to HEX" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::rgb_to_hex(values[:rgb]) ).to eq hex
+          expect( Decolmor.rgb_to_hex(values[:rgb]) ).to eq hex
         end
       end
 
       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
+          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
@@ -84,7 +132,7 @@ RSpec.describe Decolmor do
     describe ".new_rgb" do
       it "generate RGB with values into range 0..255" do
         100.times do
-          expect( Decolmor::new_rgb ).to all( be_between(0, 255) )
+          expect( Decolmor.new_rgb ).to all( be_between(0, 255) )
         end
       end
 
@@ -93,10 +141,10 @@ RSpec.describe Decolmor do
         color = {red: 72, green: 209, blue: 204, alpha: 244}
         # set and check each channel separately
         color.each_with_index do |(key, value), index|
-          expect( Decolmor::new_rgb(**{key => value})[index] ).to eq value
+          expect( Decolmor.new_rgb(**{key => value})[index] ).to eq value
         end
         # set all channels
-        expect( Decolmor::new_rgb(**color) ).to eq color.values
+        expect( Decolmor.new_rgb(**color) ).to eq color.values
       end
     end
   end
@@ -109,32 +157,32 @@ RSpec.describe Decolmor do
 
       it "RGB converts to HSL" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::rgb_to_hsl(values[:rgb]) ).to eq values[:hsl]
+          expect( Decolmor.rgb_to_hsl(values[:rgb]) ).to eq values[:hsl]
         end
       end
 
       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]
+          expect( Decolmor.rgb_to_hsl(rgba).last ).to eq alpha[:rgb]
         end
       end
 
       it "you can set rounding for resulting HSL values (default = 1)" do
         docs "round 1 enough for a lossless conversion RGB -> HSL/HSV/HSB -> RGB"
         colors.each_pair do |hex, values|
-          expect( Decolmor::rgb_to_hsl(values[:rgb], 0) ).to eq values[:hsl].map(&:round)
+          expect( Decolmor.rgb_to_hsl(values[:rgb], 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, 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
-          expect( Decolmor::rgb_to_hsl(rgba, 0).last ).to eq alpha[:rgb]
+          expect( Decolmor.rgb_to_hsl(rgba, 0).last ).to eq alpha[:rgb]
         end
       end
     end
@@ -146,36 +194,36 @@ RSpec.describe Decolmor do
 
       it "RGB converts to HSV" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::rgb_to_hsv(values[:rgb]) ).to eq values[:hsv]
+          expect( Decolmor.rgb_to_hsv(values[:rgb]) ).to eq values[:hsv]
         end
       end
 
       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]
+          expect( Decolmor.rgb_to_hsv(rgba).last ).to eq alpha[:rgb]
         end
       end
 
       it "you can set rounding for resulting HSV values (default = 1)" do
         colors_round_2.each_pair do |hex, values|
-          expect( Decolmor::rgb_to_hsv(values[:rgb], 0) ).to eq values[:hsv].map(&:round)
+          expect( Decolmor.rgb_to_hsv(values[:rgb], 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|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
-          expect( Decolmor::rgb_to_hsv(rgba, 0).last ).to eq alpha[:rgb]
+          expect( Decolmor.rgb_to_hsv(rgba, 0).last ).to eq alpha[:rgb]
         end
       end
     end
 
     describe ".rgb_to_hsb" do
       it "alias .rgb_to_hsv" do
-        expect( subject.method(:rgb_to_hsb ).original_name).to eq(:rgb_to_hsv)
+        expect( Decolmor.method(:rgb_to_hsb ).original_name).to eq(:rgb_to_hsv)
       end
     end
   end
@@ -187,16 +235,16 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
-        colors.each_pair do |hex, values|
-          expect( Decolmor::hsl_to_rgb(values[:hsl]) ).to eq values[:rgb]
+        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]
+          expect( Decolmor.hsl_to_rgb(hsla).last ).to eq values[:rgb]
         end
       end
     end
@@ -206,23 +254,23 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
-        colors.each_pair do |hex, values|
-          expect( Decolmor::hsv_to_rgb(values[:hsv]) ).to eq values[:rgb]
+        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]
+          expect( Decolmor.hsv_to_rgb(hsva).last ).to eq values[:rgb]
         end
       end
     end
 
     describe ".hsb_to_rgb" do
       it "alias .hsv_to_rgb" do
-        expect( subject.method(:hsb_to_rgb ).original_name).to eq(:hsv_to_rgb)
+        expect( Decolmor.method(:hsb_to_rgb ).original_name).to eq(:hsv_to_rgb)
       end
     end
   end
@@ -234,16 +282,24 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
-        colors.each_pair do |hex, values|
-          expect( Decolmor::hsl_to_rgb_alt(values[:hsl]) ).to eq values[:rgb]
+        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]
+          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
@@ -253,23 +309,31 @@ RSpec.describe Decolmor do
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
-        colors.each_pair do |hex, values|
-          expect( Decolmor::hsv_to_rgb_alt(values[:hsv]) ).to eq values[:rgb]
+        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]
+          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
       it "alias .hsv_to_rgb_alt" do
-        expect( subject.method(:hsb_to_rgb_alt ).original_name).to eq(:hsv_to_rgb_alt)
+        expect( Decolmor.method(:hsb_to_rgb_alt ).original_name).to eq(:hsv_to_rgb_alt)
       end
     end
   end
@@ -284,36 +348,36 @@ RSpec.describe Decolmor do
       it "HSL converts to HSV" do
         colors.each_pair do |hex_, values|
           hsv = values[:hsv].map { |value| value.round(1) }
-          expect( Decolmor::hsl_to_hsv(values[:hsl]) ).to eq hsv
+          expect( Decolmor.hsl_to_hsv(values[:hsl]) ).to eq hsv
         end
       end
 
       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]
+          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|
-          expect( Decolmor::hsl_to_hsv(values[:hsl], 0) ).to eq values[:hsv].map(&:round)
+        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]
+          expect( Decolmor.hsl_to_hsv(hsla, 0).last ).to eq alpha[:rgb]
         end
       end
     end
 
     describe ".hsl_to_hsb" do
       it "alias .hsl_to_hsv" do
-        expect( subject.method(:hsl_to_hsb).original_name ).to eq(:hsl_to_hsv)
+        expect( Decolmor.method(:hsl_to_hsb).original_name ).to eq(:hsl_to_hsv)
       end
     end
 
@@ -323,38 +387,38 @@ 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
+          expect( Decolmor.hsv_to_hsl(values[:hsv]) ).to eq hsl
         end
       end
 
       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]
+          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|
-          expect( Decolmor::hsv_to_hsl(values[:hsv], 0) ).to eq values[:hsl].map(&:round)
+        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]
+          expect( Decolmor.hsv_to_hsl(hsva, 0).last ).to eq alpha[:rgb]
         end
       end
     end
 
     describe ".hsb_to_hsl" do
       it "alias .hsv_to_hsl" do
-        expect( subject.method(:hsb_to_hsl).original_name ).to eq(:hsv_to_hsl)
+        expect( Decolmor.method(:hsb_to_hsl).original_name ).to eq(:hsv_to_hsl)
       end
     end
   end
@@ -369,29 +433,29 @@ RSpec.describe Decolmor do
         colors.each_pair do |hex_, values|
 
           cmyk = values[:cmyk].map {|arr| arr.round(1) }
-          expect( Decolmor::rgb_to_cmyk(values[:rgb]) ).to eq cmyk
+          expect( Decolmor.rgb_to_cmyk(values[:rgb]) ).to eq cmyk
         end
       end
 
       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]
+          expect( Decolmor.rgb_to_cmyk(rgba).last ).to eq alpha[:rgb]
         end
       end
 
       it "you can set rounding for resulting CMYK values (default = 1)" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hsv_to_hsl(values[:hsv], 0) ).to eq values[:hsl].map(&:round)
+          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, alpha|
           rgba = colors[color][:rgb] + [alpha[:rgb]]
-          expect( Decolmor::rgb_to_cmyk(rgba, 0).last ).to eq alpha[:rgb]
+          expect( Decolmor.rgb_to_cmyk(rgba, 0).last ).to eq alpha[:rgb]
         end
       end
     end
@@ -402,19 +466,18 @@ RSpec.describe Decolmor do
 
       it "CMYK converts to RGB" do
         colors.each_pair do |hex_, values|
-          expect( Decolmor::cmyk_to_rgb(values[:cmyk]) ).to eq values[:rgb]
+          expect( Decolmor.cmyk_to_rgb(values[:cmyk]) ).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|
           cmyka = colors[color][:cmyk] + [values[:rgb]]
-          expect( Decolmor::cmyk_to_rgb(cmyka).last ).to eq values[:rgb]
+          expect( Decolmor.cmyk_to_rgb(cmyka).last ).to eq values[:rgb]
         end
       end
     end
   end
 
 end
-

data/spec/factories/alpha.rb

@@ -6,7 +6,7 @@ FactoryBot.define do
 
     values = samples.each_with_object(Hash.new) do |value, hash|
       hex = "%02X" % value
-      range_01  = (value / 255.to_f).round(5)
+      range_01  = (value / 255.to_f).round(3)
       hash[hex] = {rgb: range_01, rgb_255: value}
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decolmor
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - ChildrenofkoRn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-13 00:00:00.000000000 Z
+date: 2021-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,7 +93,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.0'
 description: |-
-  Gem for converting color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK
+  Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK.
   The Alpha channel (transparency) is supported.
   There is also a simple RGB generator.
 email: Rick-ROR@ya.ru
@@ -123,9 +123,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/ChildrenofkoRn/decolmor
-  news_uri: https://github.com/ChildrenofkoRn/decolmor/blob/master/NEWS.md
-  changelog_uri: https://github.com/ChildrenofkoRn/decolmor/blob/master/CHANGELOG.md
-  documentation_uri: https://github.com/ChildrenofkoRn/decolmor/blob/master/README.md
+  news_uri: https://github.com/ChildrenofkoRn/decolmor/blob/main/NEWS.md
+  changelog_uri: https://github.com/ChildrenofkoRn/decolmor/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/ChildrenofkoRn/decolmor/blob/main/README.md
   bug_tracker_uri: https://github.com/ChildrenofkoRn/decolmor/issues
   source_code_uri: https://github.com/ChildrenofkoRn/decolmor
 post_install_message: 
@@ -143,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.2.27
 signing_key: 
 specification_version: 4
 summary: 'Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK'