decolmor 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54f8407f171d29fb366e8a75caa8dde7f133bfe8d035495936ccc467272ed135
-  data.tar.gz: 982d9f6c6e640a5485783d189c00bb9d0edeae24dbf4e05ac4a77d8f38513742
+  metadata.gz: 73c5b6a307982579fd26496c5398ce26bfe4ca900ce1ea64500249d0cfe2ca60
+  data.tar.gz: bb00a9c25c480ad47152e2f463cc216c317f3706fbe1a3f313a7aa35b0825577
 SHA512:
-  metadata.gz: 25f9e5569646ce8d1bcc4744caa7a1b372e2ff146a1087b1c0785077353e12dda0687052b93a3ae689c7ce3c871a58979424fb95961e609a979990415327370a
-  data.tar.gz: 9ffb5732412c5771da28c3344806aab52d278b7374de18b368bf38713ad93933983629ffc8bd8f9f48fe8cc61ef93854387773d55880af0b3ce333230bb823a0
+  metadata.gz: f28a363a685048fc28d39cca59c63fafde302b17b1ae8c1c3dbe615842a54bbd4c8228ca59c21afa0a0b14e8ee694c8b50d307bd66aff0780214e7363aac4a30
+  data.tar.gz: c8651a6e4151162cea6c55d6f61f9c45ee171f0f6bd0384ba059dede341562ea1086c2e70ce953fef9c2ef2c67c7f19e8a7bb6e8d1fecd9a1bf01275e4e8ed1b

data/CHANGELOG.md

@@ -9,7 +9,13 @@
 * ::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 you can now set rounding as the second argument:  
+  * for the Alpha channel now you can set rounding as the second argument:  
   `Decolmor::hex_to_rgb(hex, 2)`
   * support short version of HEX  
   e.g: `#CF3`, `0F9`, `#0F9F`
+
+## 1.1.1 (September 16, 2021)
+
+* Now you can `include` the module into your class
+    * gem methods will be available as class methods
+* Fixed default branch in .gemspec metadata paths

data/NEWS.md

@@ -7,3 +7,8 @@
 ## 1.1.0 (September 14, 2021)
 
   * `::hex_to_rgb` Now supports short version of HEX and rounding for the alpha channel
+
+## 1.1.1 (September 16, 2021)
+
+  * Now you can `include` the module into your class
+    * gem methods will be available as class methods

data/README.md

@@ -32,30 +32,40 @@ gem install decolmor
 require 'decolmor'
 
 rgb = [29, 128, 86]
-Decolmor::rgb_to_hsb(rgb)
+Decolmor.rgb_to_hsb(rgb)
 => [154.5, 77.3, 50.2]
 ```
+or `include` into class:
+```ruby
+class SomeClass
+  include Decolmor
+end
+SomeClass.rgb_to_hsb(rgb)
+=> [154.5, 77.3, 50.2]
+```
+Gem methods will be available as class methods.
+
 ## 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:
 ```ruby
     rgb = [224, 23, 131]  
-    hsl = Decolmor::rgb_to_hsl(rgb)  # => [327.8, 81.4, 48.4]
-    hsv = Decolmor::rgb_to_hsv(rgb)  # => [327.8, 89.7, 87.8]
-    Decolmor::hsv_to_rgb(hsv)  # => [224, 23, 131]
-    Decolmor::hsl_to_rgb(hsl)  # => [224, 23, 131]
+    hsl = Decolmor.rgb_to_hsl(rgb)  # => [327.8, 81.4, 48.4]
+    hsv = Decolmor.rgb_to_hsv(rgb)  # => [327.8, 89.7, 87.8]
+    Decolmor.hsv_to_rgb(hsv)  # => [224, 23, 131]
+    Decolmor.hsl_to_rgb(hsl)  # => [224, 23, 131]
 ```
 If you convert between HSL <==> HSV (HSB) with a rounding of 2, you can get more accurate results.  
 This can also be useful if you use HSL/HSB for intermediate changes and then go back to RGB.  
 You can change rounding globally:
 ```ruby
-    Decolmor::hsx_round = 2
-    Decolmor::rgb_to_hsl(rgb)  # => [154.55, 63.06, 30.78]
-    Decolmor::hsx_round        # => 2
+    Decolmor.hsx_round = 2
+    Decolmor.rgb_to_hsl(rgb)  # => [154.55, 63.06, 30.78]
+    Decolmor.hsx_round        # => 2
 ```
 You can also specify rounding as a second argument when calling the method:
 ```ruby
-    Decolmor::rgb_to_hsl(rgb, 3)  # => [154.545, 63.057, 30.784]
+    Decolmor.rgb_to_hsl(rgb, 3)  # => [154.545, 63.057, 30.784]
 ```
 In this case, the global rounding will be ignored.
 If you need to get integers, use 0.
@@ -69,12 +79,12 @@ 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]
 ```
 Consequently, when converting to HEX from RGBA, Alpha from the range `0..1` is assumed.  
 You can also set rounding for Alpha channel as a second argument:
 ```ruby
-    Decolmor::hex_to_rgb('#19988BB8', 2)  # => [25, 152, 139, 0.72]
+    Decolmor.hex_to_rgb('#19988BB8', 2)  # => [25, 152, 139, 0.72]
 ```
 This only works for converting HEX to RGBA.  
 In other cases (conversions between RGB/HSL/HSV/HSB/CMYK) Alpha channel remains unchanged.
@@ -84,8 +94,8 @@ HSB is an alternative name for HSV, it is the same thing.
 However, for convenience, aliasing methods are made for HSB from HSV.
 ```ruby
     rgb = [255, 109, 55]  
-    Decolmor::rgb_to_hsv(rgb)  # => [16.2, 78.4, 100.0]
-    Decolmor::rgb_to_hsb(rgb)  # => [16.2, 78.4, 100.0]
+    Decolmor.rgb_to_hsv(rgb)  # => [16.2, 78.4, 100.0]
+    Decolmor.rgb_to_hsb(rgb)  # => [16.2, 78.4, 100.0]
 ```
 ## HSL/HSV/HSB to RGB conversion
 HSL/HSV/HSB to RGB conversion has two implementations, the gem includes both:

data/decolmor.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
   if spec.respond_to?(:metadata)
     spec.metadata = {
       "homepage_uri"      => spec.homepage.to_s,
-      "news_uri"          => "#{spec.homepage}/blob/master/NEWS.md",
-      "changelog_uri"     => "#{spec.homepage}/blob/master/CHANGELOG.md",
-      "documentation_uri" => "#{spec.homepage}/blob/master/README.md",
+      "news_uri"          => "#{spec.homepage}/blob/main/NEWS.md",
+      "changelog_uri"     => "#{spec.homepage}/blob/main/CHANGELOG.md",
+      "documentation_uri" => "#{spec.homepage}/blob/main/README.md",
       "bug_tracker_uri"   => "#{spec.homepage}/issues",
       "source_code_uri"   => spec.homepage.to_s
     }

data/lib/decolmor/main.rb

@@ -1,282 +1,294 @@
 module Decolmor
 
-  #========= HEX <==> RGB(A) =============================================
-
-  def self.hex_to_rgb(hex, alpha_round = 3)
-    hex = hex.gsub('#','')
-    hex = if [3, 4].include? hex.length
-            hex.chars.map{ |char| char * 2 }
-          else
-            hex.scan(/../)
-          end
-    rgb = hex.map(&:hex)
-    rgb.size == 4 ? rgb + [(rgb.delete_at(3) / 255.to_f).round(alpha_round)] : rgb
+  def self.included(base)
+    base.extend ClassMethods
   end
 
-  def self.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
-  end
-
-  #=======================================================================
+  module ClassMethods
 
-  # simple generator RGB, you can set any channel(s)
-  def self.new_rgb(red: nil, green: nil, blue: nil, alpha: nil)
-    range = 0..255
-    rgb = [red, green, blue].map { |channel| channel || rand(range) }
-    alpha.nil? ? rgb : rgb + [alpha]
-  end
+    attr_writer :hsx_round
 
-  #========= RGB(A) to HSL/HSV/HSB =======================================
+    def hsx_round
+      @hsx_round ||= HSX_ROUND
+    end
 
-  def self.rgb_to_hsl(rgb_arr, rounding = hsx_round)
-    # scaling RGB values into range 0..1
-    red, green, blue, alpha = rgb_arr.map { |color| color / 255.to_f }
+    #========= HEX <==> RGB(A) =============================================
+
+    def hex_to_rgb(hex, alpha_round = 3)
+      hex = hex.gsub('#','')
+      hex = if [3, 4].include? hex.length
+              hex.chars.map{ |char| char * 2 }
+            else
+              hex.scan(/../)
+            end
+      rgb = hex.map(&:hex)
+      rgb.size == 4 ? rgb + [(rgb.delete_at(3) / 255.to_f).round(alpha_round)] : rgb
+    end
 
-    # calculation intermediate values
-    cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
+    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
+    end
 
-    # calculation HSL values
-    hue = get_hue(red, green, blue)
-    lightness = (cmax + cmin) / 2
-    saturation = chroma == 0 ? 0 : chroma / (1 - (2 * lightness - 1).abs)
+    #=======================================================================
 
-    # scaling values to fill 0..100 interval
-    saturation *= 100
-    lightness *= 100
+    # simple generator RGB, you can set any channel(s)
+    def new_rgb(red: nil, green: nil, blue: nil, alpha: nil)
+      range = 0..255
+      rgb = [red, green, blue].map { |channel| channel || rand(range) }
+      alpha.nil? ? rgb : rgb + [alpha]
+    end
 
-    # rounding, drop Alpha if not set (nil)
-    hsl = [hue, saturation, lightness].map { |x| x.round(rounding) }
-    alpha.nil? ? hsl : hsl + [alpha * 255]
-  end
+    #========= RGB(A) to HSL/HSV/HSB =======================================
 
-  def self.rgb_to_hsv(rgb_arr, rounding = hsx_round)
-    # scaling RGB values into range 0..1
-    red, green, blue, alpha = rgb_arr.map { |color| color / 255.to_f }
+    def rgb_to_hsl(rgb_arr, rounding = hsx_round)
+      # scaling RGB values into range 0..1
+      red, green, blue, alpha = rgb_arr.map { |color| color / 255.to_f }
 
-    # calculation intermediate values
-    _cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
+      # calculation intermediate values
+      cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
 
-    # calculation HSV values
-    hue = get_hue(red, green, blue)
-    saturation = chroma == 0 ? 0 : chroma / cmax
-    value = cmax
+      # calculation HSL values
+      hue = get_hue(red, green, blue)
+      lightness = (cmax + cmin) / 2
+      saturation = chroma == 0 ? 0 : chroma / (1 - (2 * lightness - 1).abs)
 
-    # scaling values into range 0..100
-    saturation *= 100
-    value *= 100
+      # scaling values to fill 0..100 interval
+      saturation *= 100
+      lightness *= 100
 
-    # rounding
-    hsv = [hue, saturation, value].map { |x| x.round(rounding) }
-    alpha.nil? ? hsv : hsv + [alpha * 255]
-  end
+      # rounding, drop Alpha if not set (nil)
+      hsl = [hue, saturation, lightness].map { |x| x.round(rounding) }
+      alpha.nil? ? hsl : hsl + [alpha * 255]
+    end
 
+    def rgb_to_hsv(rgb_arr, rounding = hsx_round)
+      # scaling RGB values into range 0..1
+      red, green, blue, alpha = rgb_arr.map { |color| color / 255.to_f }
 
-  self.singleton_class.send(:alias_method, :rgb_to_hsb, :rgb_to_hsv)
+      # calculation intermediate values
+      _cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
 
-  #========= HSL/HSV/HSB to RGB(A) =======================================
+      # calculation HSV values
+      hue = get_hue(red, green, blue)
+      saturation = chroma == 0 ? 0 : chroma / cmax
+      value = cmax
 
-  def self.hsl_to_rgb(hsl_arr)
-    hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    lightness /= 100
+      # scaling values into range 0..100
+      saturation *= 100
+      value *= 100
 
-    # 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
+      # rounding
+      hsv = [hue, saturation, value].map { |x| x.round(rounding) }
+      alpha.nil? ? hsv : hsv + [alpha * 255]
     end
 
-    # calculation rgb & scaling into range 0..255
-    rgb = [0, 8, 4]
-    rgb.map! { |channel| (converter.call(channel) * 255).round }
-    alpha.nil? ? rgb : rgb + [alpha]
-  end
+    alias_method :rgb_to_hsb, :rgb_to_hsv
+
+    #========= HSL/HSV/HSB to RGB(A) =======================================
 
-  def self.hsv_to_rgb(hsv_arr)
-    hue, saturation, value, alpha = hsv_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    value /= 100
+    def hsl_to_rgb(hsl_arr)
+      hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      lightness /= 100
 
-    # calculation intermediate values
-    converter = proc do |n|
-      k = (n + hue / 60) % 6
-      value - value * saturation * [0, [k, 4 - k, 1].min].max
+      # 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 }
+      alpha.nil? ? rgb : rgb + [alpha]
     end
 
-    # calculation rgb & scaling into range 0..255
-    rgb = [5, 3, 1]
-    rgb.map! { |channel| (converter.call(channel) * 255).round }
-    alpha.nil? ? rgb : rgb + [alpha]
-  end
+    def hsv_to_rgb(hsv_arr)
+      hue, saturation, value, alpha = hsv_arr.map(&:to_f)
+      # scaling values into range 0..1
+      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 }
+      alpha.nil? ? rgb : rgb + [alpha]
+    end
 
-  self.singleton_class.send(:alias_method, :hsb_to_rgb, :hsv_to_rgb)
-
-  #========= Alternative implementation HSL/HSV/HSB to RGB(A) ============
-
-  def self.hsl_to_rgb_alt(hsl_arr)
-    hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    lightness /= 100
-
-    # calculation chroma & intermediate values
-    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]
-
-    # calculation rgb & scaling into range 0..255
-    m = lightness - chroma / 2
-    rgb.map! { |channel| ((channel + m) * 255).round }
-    alpha.nil? ? rgb : rgb + [alpha]
-  end
+    alias_method :hsb_to_rgb, :hsv_to_rgb
+
+    #========= Alternative implementation HSL/HSV/HSB to RGB(A) ============
+
+    def hsl_to_rgb_alt(hsl_arr)
+      hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      lightness /= 100
+
+      # calculation chroma & intermediate values
+      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]
+
+      # calculation rgb & scaling into range 0..255
+      m = lightness - chroma / 2
+      rgb.map! { |channel| ((channel + m) * 255).round }
+      alpha.nil? ? rgb : rgb + [alpha]
+    end
 
-  def self.hsv_to_rgb_alt(hsv_arr)
-    hue, saturation, value, alpha = hsv_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    value /= 100
-
-    # calculation chroma & intermediate values
-    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]
-
-    # calculation rgb & scaling into range 0..255
-    m = value - chroma
-    rgb.map! { |channel| ((channel + m) * 255).round }
-    alpha.nil? ? rgb : rgb + [alpha]
-  end
+    def hsv_to_rgb_alt(hsv_arr)
+      hue, saturation, value, alpha = hsv_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      value /= 100
+
+      # calculation chroma & intermediate values
+      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]
+
+      # calculation rgb & scaling into range 0..255
+      m = value - chroma
+      rgb.map! { |channel| ((channel + m) * 255).round }
+      alpha.nil? ? rgb : rgb + [alpha]
+    end
 
-  self.singleton_class.send(:alias_method, :hsb_to_rgb_alt, :hsv_to_rgb_alt)
+    alias_method :hsb_to_rgb_alt, :hsv_to_rgb_alt
 
-  #========= HSL <==> HSV (HSB) ==========================================
+    #========= HSL <==> HSV (HSB) ==========================================
 
-  def self.hsl_to_hsv(hsl_arr, rounding = hsx_round)
-    hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    lightness /= 100
+    def hsl_to_hsv(hsl_arr, rounding = hsx_round)
+      hue, saturation, lightness, alpha = hsl_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      lightness /= 100
 
-    # calculation value & saturation HSV
-    value = lightness + saturation * [lightness, 1 - lightness].min
-    saturation_hsv = lightness == 0 ? 0 : 2 * (1 - lightness / value)
+      # calculation value & saturation HSV
+      value = lightness + saturation * [lightness, 1 - lightness].min
+      saturation_hsv = lightness == 0 ? 0 : 2 * (1 - lightness / value)
 
-    # scaling HSV values & rounding
-    hsv = [hue, saturation_hsv * 100, value * 100].map { |x| x.round(rounding) }
-    alpha.nil? ? hsv : hsv + [alpha]
-  end
+      # scaling HSV values & rounding
+      hsv = [hue, saturation_hsv * 100, value * 100].map { |x| x.round(rounding) }
+      alpha.nil? ? hsv : hsv + [alpha]
+    end
 
-  self.singleton_class.send(:alias_method, :hsl_to_hsb, :hsl_to_hsv)
-
-  def self.hsv_to_hsl(hsv_arr, rounding = hsx_round)
-    hue, saturation, value, alpha = hsv_arr.map(&:to_f)
-    # scaling values into range 0..1
-    saturation /= 100
-    value /= 100
-
-    # calculation lightness & saturation HSL
-    lightness = value * (1 - saturation / 2)
-    saturation_hsl = if [0, 1].any? { |v| v == lightness }
-                       0
-                     else
-                       (value - lightness) / [lightness, 1 - lightness].min
-                     end
-
-    # scaling HSL values & rounding
-    hsl = [hue, saturation_hsl * 100, lightness * 100].map { |x| x.round(rounding) }
-    alpha.nil? ? hsl : hsl + [alpha]
-  end
+    alias_method :hsl_to_hsb, :hsl_to_hsv
+
+    def hsv_to_hsl(hsv_arr, rounding = hsx_round)
+      hue, saturation, value, alpha = hsv_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      value /= 100
+
+      # calculation lightness & saturation HSL
+      lightness = value * (1 - saturation / 2)
+      saturation_hsl = if [0, 1].any? { |v| v == lightness }
+                         0
+                       else
+                         (value - lightness) / [lightness, 1 - lightness].min
+                       end
+
+      # scaling HSL values & rounding
+      hsl = [hue, saturation_hsl * 100, lightness * 100].map { |x| x.round(rounding) }
+      alpha.nil? ? hsl : hsl + [alpha]
+    end
 
-  self.singleton_class.send(:alias_method, :hsb_to_hsl, :hsv_to_hsl)
+    alias_method :hsb_to_hsl, :hsv_to_hsl
 
-  #========= RGB(A) <==> CMYK ============================================
+    #========= RGB(A) <==> CMYK ============================================
 
-  def self.rgb_to_cmyk(rgb_arr, rounding = hsx_round)
-    # scaling RGB values into range 0..1
-    rgb = rgb_arr[0..2].map { |color| color / 255.to_f }
-    k = 1 - rgb.max
-    converter = proc do |color|
-       (1 - k) == 0 ? 0 : (1 - color - k) / (1 - k)
+    def rgb_to_cmyk(rgb_arr, rounding = hsx_round)
+      # scaling RGB values into range 0..1
+      rgb = rgb_arr[0..2].map { |color| color / 255.to_f }
+      k = 1 - rgb.max
+      converter = proc do |color|
+         (1 - k) == 0 ? 0 : (1 - color - k) / (1 - k)
+      end
+
+      # calculation CMYK & scaling into percentages & rounding
+      c, m, y = rgb.map { |color| converter.call(color) || 0 }
+      cmyk = [c, m, y, k].map { |x| (x * 100).round(rounding) }
+      rgb_arr.size == 4 ? cmyk + [rgb_arr.last] : cmyk
     end
 
-    # calculation CMYK & scaling into percentages & rounding
-    c, m, y = rgb.map { |color| converter.call(color) || 0 }
-    cmyk = [c, m, y, k].map { |x| (x * 100).round(rounding) }
-    rgb_arr.size == 4 ? cmyk + [rgb_arr.last] : cmyk
-  end
+    def cmyk_to_rgb(cmyk_arr)
+      c, m, y, k = cmyk_arr[0..3].map { |color| color / 100.to_f }
+      converter = proc do |channel|
+        255 * (1 - channel) * (1 - k)
+      end
 
-  def self.cmyk_to_rgb(cmyk_arr)
-    c, m, y, k = cmyk_arr[0..3].map { |color| color / 100.to_f }
-    converter = proc do |channel|
-      255 * (1 - channel) * (1 - k)
+      # calculation RGB & rounding
+      rgb = [c, m, y].map { |channel| converter.call(channel).round }
+      cmyk_arr.size == 5 ? rgb + [cmyk_arr.last] : rgb
     end
 
-    # calculation RGB & rounding
-    rgb = [c, m, y].map { |channel| converter.call(channel).round }
-    cmyk_arr.size == 5 ? rgb + [cmyk_arr.last] : rgb
-  end
-
-  private
+    #========= helper methods for RGB to HSL/HSB/HSV =======================
 
-  #========= helper methods for RGB to HSL/HSB/HSV =======================
+    # find greatest and smallest channel values and chroma from RGB
+    def get_min_max_chroma(red, green, blue)
+      cmin = [red, green, blue].min
+      cmax = [red, green, blue].max
+      # calculation chroma
+      chroma = cmax - cmin
 
-  # find greatest and smallest channel values and chroma from RGB
-  def self.get_min_max_chroma(red, green, blue)
-    cmin = [red, green, blue].min
-    cmax = [red, green, blue].max
-    # calculation chroma
-    chroma = cmax - cmin
+      [cmin, cmax, chroma]
+    end
 
-    [cmin, cmax, chroma]
+    # calculation HUE from RGB
+    def get_hue(red, green, blue)
+      _cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
+
+      hue = if chroma == 0
+              0
+            elsif cmax == red
+              # red is max
+              ((green - blue) / chroma) % 6
+            elsif cmax == green
+              # green is max
+              (blue - red) / chroma + 2
+            else
+              # blue is max
+              (red - green) / chroma + 4
+            end
+      hue *= 60
+      # make negative HUEs positive behind 360°
+      0 <= hue ? hue : hue + 360
+    end
   end
 
-  # calculation HUE from RGB
-  def self.get_hue(red, green, blue)
-    _cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
-
-    hue = if chroma == 0
-            0
-          elsif cmax == red
-            # red is max
-            ((green - blue) / chroma) % 6
-          elsif cmax == green
-            # green is max
-            (blue - red) / chroma + 2
-          else
-            # blue is max
-            (red - green) / chroma + 4
-          end
-    hue *= 60
-    # make negative HUEs positive behind 360°
-    0 <= hue ? hue : hue + 360
-  end
+  extend ClassMethods
 end

data/lib/decolmor/version.rb

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

data/lib/decolmor.rb

@@ -8,12 +8,4 @@ module Decolmor
   # for lossless conversion HSL <==> HSV (HSB) better to use round 2
   #
   HSX_ROUND = 1
-
-  class << self
-    attr_writer :hsx_round
-
-    def hsx_round
-      @hsx_round ||= HSX_ROUND
-    end
-  end
 end

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,14 +37,14 @@ 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
 
@@ -42,7 +54,7 @@ RSpec.describe Decolmor do
         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
 
@@ -52,7 +64,7 @@ RSpec.describe Decolmor do
           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
+          expect( Decolmor.hex_to_rgb(hex, rounding) ).to eq rgba
         end
       end
 
@@ -62,7 +74,7 @@ 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
 
@@ -70,7 +82,7 @@ RSpec.describe Decolmor 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
+          expect( Decolmor.hex_to_rgb(hex_short) ).to eq rgb
         end
       end
     end
@@ -81,7 +93,7 @@ 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
 
@@ -91,7 +103,7 @@ RSpec.describe Decolmor do
         alphas.each_pair do |hex, alpha|
           hex = format('%s%s', color, hex)
           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
     end
@@ -102,7 +114,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
 
@@ -111,10 +123,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
@@ -127,7 +139,7 @@ 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
 
@@ -135,14 +147,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
 
@@ -152,7 +164,7 @@ RSpec.describe Decolmor do
           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
@@ -164,7 +176,7 @@ 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
 
@@ -172,13 +184,13 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
 
@@ -186,14 +198,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
@@ -206,7 +218,7 @@ RSpec.describe Decolmor do
 
       it "HSL converts to RGB" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hsl_to_rgb(values[:hsl]) ).to eq values[:rgb]
+          expect( Decolmor.hsl_to_rgb(values[:hsl]) ).to eq values[:rgb]
         end
       end
 
@@ -214,7 +226,7 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
@@ -225,7 +237,7 @@ RSpec.describe Decolmor do
 
       it "HSV converts to RGB" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hsv_to_rgb(values[:hsv]) ).to eq values[:rgb]
+          expect( Decolmor.hsv_to_rgb(values[:hsv]) ).to eq values[:rgb]
         end
       end
 
@@ -233,14 +245,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
@@ -253,7 +265,7 @@ RSpec.describe Decolmor do
 
       it "HSL converts to RGB" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hsl_to_rgb_alt(values[:hsl]) ).to eq values[:rgb]
+          expect( Decolmor.hsl_to_rgb_alt(values[:hsl]) ).to eq values[:rgb]
         end
       end
 
@@ -261,7 +273,7 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
     end
@@ -272,7 +284,7 @@ RSpec.describe Decolmor do
 
       it "HSV converts to RGB" do
         colors.each_pair do |hex, values|
-          expect( Decolmor::hsv_to_rgb_alt(values[:hsv]) ).to eq values[:rgb]
+          expect( Decolmor.hsv_to_rgb_alt(values[:hsv]) ).to eq values[:rgb]
         end
       end
 
@@ -280,14 +292,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
     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
@@ -302,7 +314,7 @@ 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
 
@@ -310,13 +322,13 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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)
+          expect( Decolmor.hsl_to_hsv(values[:hsl], 0) ).to eq values[:hsv].map(&:round)
         end
       end
 
@@ -324,14 +336,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
 
@@ -343,7 +355,7 @@ RSpec.describe Decolmor do
       it "HSV converts to HSL" do
         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
 
@@ -351,13 +363,13 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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)
+          expect( Decolmor.hsv_to_hsl(values[:hsv], 0) ).to eq values[:hsl].map(&:round)
         end
       end
 
@@ -365,14 +377,14 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         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
@@ -387,7 +399,7 @@ 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
 
@@ -395,13 +407,13 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
 
@@ -409,7 +421,7 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
@@ -420,7 +432,7 @@ 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
 
@@ -428,11 +440,10 @@ RSpec.describe Decolmor do
         color = colors.keys.sample
         alphas.each_pair do |hex_, 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
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decolmor
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - ChildrenofkoRn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-14 00:00:00.000000000 Z
+date: 2021-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -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'