decolmor 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1633188a81e5b270b4e7ba878d9b72df23a864ea98e299428cef3cfb0948b906
+  data.tar.gz: 5db8fee23dd5652b66943a715058ae04ea47bdbaaf3ceeed6711407e23fc5fff
+SHA512:
+  metadata.gz: b9cf4ffd31d01c26bd2d78337ef316bcb81bd7ad06bc7471a5ccc4738e90103a6443008517a289889a0e0c9cc94e6e0387b188e08508f4ae01f312cf90c5ecd2
+  data.tar.gz: 602694cadb39dbef406d503ca75e632a650e571710a30a1f1a7935b8aec425b6583e03148f1bc5a07f8128cd63e6b478b0bea5b442f9be1a7a34bd8833ce391d

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--warnings

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.0 (September 13, 2021)
+
+* Initial release

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 ChildrenofkoRn
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/NEWS.md

@@ -0,0 +1,4 @@
+# News
+
+## 1.0.0 (September 13, 2021)
+  * First version

data/README.md

@@ -0,0 +1,133 @@
+# Decolmor
+[![Gem Version](https://badge.fury.io/rb/decolmor.svg)](http://badge.fury.io/rb/decolmor)
+[![Build Status](https://app.travis-ci.com/ChildrenofkoRn/decolmor.svg?token=ssJ5zvqjK7iZ4F1TaeQn&branch=main)](https://app.travis-ci.com/ChildrenofkoRn/decolmor)
+[![codecov](https://codecov.io/gh/ChildrenofkoRn/decolmor/branch/main/graph/badge.svg?token=5P4OQUXC3N)](https://codecov.io/gh/ChildrenofkoRn/decolmor)
+
+Gem for converting the color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK  
+The Alpha channel (transparency) is supported.  
+There is also a simple RGB generator.  
+
+## Install
+Add the following line to Gemfile:
+
+```ruby
+gem 'decolmor'
+```
+and run `bundle install` from your shell.
+
+To install the gem manually from your shell, run:
+
+```shell
+gem install decolmor
+```
+### Supported Rubies
+ - 2.4
+ - 2.5
+ - 2.6
+ - 2.7
+ - 3.0
+
+## Using
+```ruby
+require 'decolmor'
+
+rgb = [29, 128, 86]
+Decolmor::rgb_to_hsb(rgb)
+=> [154.5, 77.3, 50.2]
+```
+## 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]
+```
+If you convert between HSL <==> HSV (HSB) with a rounding of 2, you can get more accurate results.  
+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
+```
+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]
+```
+In this case, the global rounding will be ignored.
+If you need to get integers, use 0.
+	
+## Alpha channel
+When converting from HEX to RGBA Alpha channel is converted to a value from the range `0..1` with rounding 5:
+```ruby
+    Decolmor::hex_to_rgb('#19988BB8')  # => [25, 152, 139, 0.72157]
+```
+Consequently, when converting to HEX from RGBA, Alpha from the range `0..1` is assumed.  
+In other cases (conversions between RGB/HSL/HSV/HSB/CMYK) Alpha channel remains unchanged.
+
+## HSV or HSB
+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]
+```
+## HSL/HSV/HSB to RGB conversion
+HSL/HSV/HSB to RGB conversion has two implementations, the gem includes both:
+- hsl_to_rgb
+- hsv_to_rgb
+- hsb_to_rgb
+
+or  
+- hsl_to_rgb_alt
+- 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.
+
+## Attention for CMYK !
+Unfortunately, there is no simple formula for linear RGB to/from CMYK conversion.  
+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.  
+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.
+
+## Supported Methods
+ - Setter global rounding for conversion to HSL/HSV/HSB/CMYK
+   - Decolmor::hsx_round =
+ - HEX <==> RGB(A)
+   - hex_to_rgb
+   - rgb_to_hex
+  - Simple generator RGB, you can set any channel(s)
+    - new_rgb
+ - RGB(A) to HSL/HSV/HSB
+   - rgb_to_hsl
+   - rgb_to_hsv
+   - rgb_to_hsb
+ - HSL/HSV/HSB to RGB(A)
+   - hsl_to_rgb
+   - hsv_to_rgb
+   - hsb_to_rgb
+ - Alternative implementation HSL/HSV/HSB to RGB(A) (~1.6X slower)
+   - hsl_to_rgb_alt
+   - hsv_to_rgb_alt
+   - hsb_to_rgb_alt
+ - HSL <==> HSV (HSB)
+   - hsl_to_hsv
+   - hsl_to_hsb
+   - hsv_to_hsl
+   - hsb_to_hsl
+ - RGB(A) <==> CMYK
+   - rgb_to_cmyk
+   - cmyk_to_rgb
+
+## License
+MIT License  
+Copyright (c) 2021 ChildrenofkoRn  
+[LICENSE](https://github.com/ChildrenofkoRn/decolmor/blob/master/LICENSE)

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'rake'
+
+begin
+  require 'bundler/setup'
+  require "bundler/gem_tasks"
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/decolmor.gemspec

@@ -0,0 +1,40 @@
+require File.expand_path('lib/decolmor/version', __dir__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'decolmor'
+  spec.version       = Decolmor::VERSION
+  spec.licenses      = ['MIT']
+  spec.summary       = "Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK"
+  spec.description   = "Gem for converting color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK\n" \
+                       "The Alpha channel (transparency) is supported.\n" \
+                       "There is also a simple RGB generator."
+  spec.authors       = ["ChildrenofkoRn"]
+  spec.email         = 'Rick-ROR@ya.ru'
+  spec.homepage      = 'https://github.com/ChildrenofkoRn/decolmor'
+  spec.require_paths = ['lib']
+  spec.files         = Dir['lib/**/*'] +
+                       %w(README.md CHANGELOG.md NEWS.md LICENSE
+                          decolmor.gemspec Gemfile Rakefile)
+  spec.test_files    = Dir['spec/**/*'] + ['.rspec']
+  spec.extra_rdoc_files      = %w(README.md LICENSE)
+
+  spec.platform              = Gem::Platform::RUBY
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  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",
+      "bug_tracker_uri"   => "#{spec.homepage}/issues",
+      "source_code_uri"   => spec.homepage.to_s
+    }
+  end
+
+  spec.add_development_dependency 'bundler',     '>= 1.17', '< 3.0'
+  spec.add_development_dependency 'rake',        '~> 13.0'
+  spec.add_development_dependency 'codecov',     '~> 0.2'
+  spec.add_development_dependency 'rspec',       '~> 3.8'
+  spec.add_development_dependency 'factory_bot', '>= 5.1', '< 7.0'
+end

data/lib/decolmor/main.rb

@@ -0,0 +1,276 @@
+module Decolmor
+
+  #========= HEX <==> RGB(A) =============================================
+
+  def self.hex_to_rgb(hex)
+    rgb = hex.gsub('#','').scan(/../).map(&:hex).map(&:to_i)
+    rgb.size == 4 ? rgb + [(rgb.delete_at(3) / 255.to_f).round(5)] : rgb
+  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
+
+  #=======================================================================
+
+  # 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
+
+  #========= RGB(A) to HSL/HSV/HSB =======================================
+
+  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 }
+
+    # calculation intermediate values
+    cmin, cmax, chroma = get_min_max_chroma(red, green, blue)
+
+    # 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
+
+    # rounding, drop Alpha if not set (nil)
+    hsl = [hue, saturation, lightness].map { |x| x.round(rounding) }
+    alpha.nil? ? hsl : hsl + [alpha * 255]
+  end
+
+  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 }
+
+    # 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
+
+    # scaling values into range 0..100
+    saturation *= 100
+    value *= 100
+
+    # rounding
+    hsv = [hue, saturation, value].map { |x| x.round(rounding) }
+    alpha.nil? ? hsv : hsv + [alpha * 255]
+  end
+
+
+  self.singleton_class.send(:alias_method, :rgb_to_hsb, :rgb_to_hsv)
+
+  #========= HSL/HSV/HSB to RGB(A) =======================================
+
+  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
+
+    # 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
+
+  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
+
+    # 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
+
+  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
+
+  self.singleton_class.send(:alias_method, :hsb_to_rgb_alt, :hsv_to_rgb_alt)
+
+  #========= 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
+
+    # 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
+
+  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
+
+  self.singleton_class.send(:alias_method, :hsb_to_hsl, :hsv_to_hsl)
+
+  #========= 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)
+    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 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)
+    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 =======================
+
+  # 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
+
+  # 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
+end

data/lib/decolmor/version.rb

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

data/lib/decolmor.rb

@@ -0,0 +1,19 @@
+require 'decolmor/main'
+require 'decolmor/version'
+
+module Decolmor
+  #========= 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
+  #
+  HSX_ROUND = 1
+
+  class << self
+    attr_writer :hsx_round
+
+    def hsx_round
+      @hsx_round ||= HSX_ROUND
+    end
+  end
+end

data/spec/decolmor_spec.rb

@@ -0,0 +1,420 @@
+load_class(__FILE__)
+
+RSpec.describe Decolmor do
+  describe 'you can set rounding globally for convert to HSL/HSV/HSB/CMYK' do
+    after(:each) do
+      Decolmor.hsx_round = 1
+    end
+
+    let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+
+    it ".hsx_round by default 1" do
+      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)
+    end
+  end
+
+  
+  context 'HEX <==> RGB(A)' do
+    describe ".hex_to_rgb" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "HEX w prefix # to RGB" do
+        colors.each_pair do |hex, values|
+          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]
+        end
+      end
+
+      it "HEX w alpha channel and prefix # to RGBA" do
+        docs "alpha into range 0..1 and rounding 5"
+        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
+        end
+      end
+
+      it "HEX w alpha channel and w/o prefix # to RGBA" do
+        color = colors.keys.sample
+
+        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
+        end
+      end
+    end
+
+    describe ".rgb_to_hex" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "RGB converts to HEX" do
+        colors.each_pair do |hex, values|
+          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)
+          rgba = colors[color][:rgb] + [alpha[:rgb]]
+          expect( Decolmor::rgb_to_hex(rgba) ).to eq hex
+        end
+      end
+    end
+  end
+
+  
+  context 'simple generator RGB, you can set any channel(s)' 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) )
+        end
+      end
+
+      it "w params generate RGB with established values" do
+        docs "alpha isn't generated, but you can set it"
+        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
+        end
+        # set all channels
+        expect( Decolmor::new_rgb(**color) ).to eq color.values
+      end
+    end
+  end
+
+
+  context 'RGB(A) to HSL/HSV/HSB' do
+    describe ".rgb_to_hsl" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "RGB converts to HSL" do
+        colors.each_pair do |hex, values|
+          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|
+          rgba = colors[color][:rgb] + [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)
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" do
+        color = colors.keys.sample
+        alphas.each_pair do |hex_, 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]
+        end
+      end
+    end
+
+    describe ".rgb_to_hsv" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+      let(:colors_round_2) { FactoryBot.build(:colors_map, round: 2) }
+
+      it "RGB converts to HSV" do
+        colors.each_pair do |hex, values|
+          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|
+          rgba = colors[color][:rgb] + [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)
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" 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]
+        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)
+      end
+    end
+  end
+
+
+  context 'HSL/HSV/HSB to RGB(A)' do
+    describe ".hsl_to_rgb" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      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]
+        end
+      end
+
+      it "alpha channel pass to RGB unchanged" 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]
+        end
+      end
+    end
+
+    describe ".hsv_to_rgb" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      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]
+        end
+      end
+
+      it "alpha channel pass to RGB unchanged" 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]
+        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)
+      end
+    end
+  end
+
+
+  context 'Alternative implementation HSL/HSV/HSB to RGB(A)' do
+    describe ".hsl_to_rgb_alt" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      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]
+        end
+      end
+
+      it "alpha channel pass to RGB unchanged" 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]
+        end
+      end
+    end
+
+    describe ".hsv_to_rgb_alt" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      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]
+        end
+      end
+
+      it "alpha channel pass to RGB unchanged" 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]
+        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)
+      end
+    end
+  end
+
+
+  context 'HSL <==> HSV (HSB)' do
+    describe ".hsl_to_hsv" do
+      # as for lossless conversion need to use float value with 2 decimal places
+      let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      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
+        end
+      end
+
+      it "alpha channel pass to HSV unchanged" 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]
+        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)
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" 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]
+        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)
+      end
+    end
+
+    describe ".hsv_to_hsl" do
+      # as for lossless conversion need to use float value with 2 decimal places
+      let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      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
+        end
+      end
+
+      it "alpha channel pass to HSL unchanged" 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]
+        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)
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" 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]
+        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)
+      end
+    end
+  end
+
+
+  context 'RGB(A) <==> CMYK' do
+    describe ".rgb_to_cmyk" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "RGB converts to CMYK" 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
+        end
+      end
+
+      it "alpha channel pass to HSL unchanged" 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]
+        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)
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" 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]
+        end
+      end
+    end
+
+    describe ".cmyk_to_rgb" do
+      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "CMYK converts to RGB" do
+        colors.each_pair do |hex_, values|
+          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|
+          cmyka = colors[color][:cmyk] + [values[:rgb]]
+          expect( Decolmor::cmyk_to_rgb(cmyka).last ).to eq values[:rgb]
+        end
+      end
+    end
+  end
+
+end
+

data/spec/factories/alpha.rb

@@ -0,0 +1,15 @@
+FactoryBot.define do
+  factory :alpha, class: Hash do
+    skip_create
+
+    samples = [0, 1, 64, 128, 191, 254, 255]
+
+    values = samples.each_with_object(Hash.new) do |value, hash|
+      hex = "%02X" % value
+      range_01  = (value / 255.to_f).round(5)
+      hash[hex] = {rgb: range_01, rgb_255: value}
+    end
+
+    initialize_with { values }
+  end
+end

data/spec/factories/colors.rb

@@ -0,0 +1,79 @@
+FactoryBot.define do
+  factory :colors_map, class: Hash do
+    skip_create
+
+    colors_map = {
+      # black
+      "#000000" => {rgb:  [  0,   0,   0],                            hsl: [  0.000,   0.000,   0.000],
+                    cmyk: [  0.000,   0.000,   0.000, 100.000],       hsv: [  0.000,   0.000,   0.000],},
+      # white
+      "#FFFFFF" => {rgb:  [255, 255, 255],                            hsl: [  0.000,   0.000, 100.000],
+                    cmyk: [  0.000,   0.000,   0.000,   0.000],       hsv: [  0.000,   0.000, 100.000],},
+      # red
+      "#FF0000" => {rgb:  [255,   0,   0],                            hsl: [  0.000, 100.000,  50.000],
+                    cmyk: [  0.000, 100.000, 100.000,   0.000],       hsv: [  0.000, 100.000, 100.000],},
+      # lime
+      "#00FF00" => {rgb:  [  0, 255,   0],                            hsl: [120.000, 100.000,  50.000],
+                    cmyk: [100.000,   0.000, 100.000,   0.000],       hsv: [120.000, 100.000, 100.000],},
+      # blue
+      "#0000FF" => {rgb:  [  0,   0, 255],                            hsl: [240.000, 100.000,  50.000],
+                    cmyk: [100.000, 100.000,   0.000,   0.000],       hsv: [240.000, 100.000, 100.000],},
+      # yellow
+      "#FFFF00" => {rgb:  [255, 255,   0],                            hsl: [ 60.000, 100.000,  50.000],
+                    cmyk: [  0.000,   0.000, 100.000,   0.000],       hsv: [ 60.000, 100.000, 100.000],},
+      # cyan / aqua
+      "#00FFFF" => {rgb:  [  0, 255, 255],                            hsl: [180.000, 100.000,  50.000],
+                    cmyk: [100.000,   0.000,   0.000,   0.000],       hsv: [180.000, 100.000, 100.000],},
+      # magenta / fuchsia
+      "#FF00FF" => {rgb:  [255,   0, 255],                            hsl: [300.000, 100.000,  50.000],
+                    cmyk: [  0.000, 100.000,   0.000,   0.000],       hsv: [300.000, 100.000, 100.000],},
+      # silver
+      "#C0C0C0" => {rgb:  [192, 192, 192],                            hsl: [  0.000,   0.000,  75.294],
+                    cmyk: [  0.000,   0.000,   0.000,  24.706],       hsv: [  0.000,   0.000,  75.294],},
+      # gray
+      "#808080" => {rgb:  [128, 128, 128],                            hsl: [  0.000,   0.000,  50.196],
+                    cmyk: [  0.000,   0.000,   0.000,  49.804],       hsv: [  0.000,   0.000,  50.196],},
+      # maroon
+      "#800000" => {rgb:  [128,   0,   0],                            hsl: [  0.000, 100.000,  25.098],
+                    cmyk: [  0.000, 100.000, 100.000,  49.804],       hsv: [  0.000, 100.000,  50.196],},
+      # olive
+      "#808000" => {rgb:  [128, 128,   0],                            hsl: [ 60.000, 100.000,  25.098],
+                    cmyk: [  0.000,   0.000, 100.000,  49.804],       hsv: [ 60.000, 100.000,  50.196],},
+      # green
+      "#008000" => {rgb:  [  0, 128,   0],                            hsl: [120.000, 100.000,  25.098],
+                    cmyk: [100.000,   0.000, 100.000,  49.804],       hsv: [120.000, 100.000,  50.196],},
+      # purple
+      "#800080" => {rgb:  [128,   0, 128],                            hsl: [300.000, 100.000,  25.098],
+                    cmyk: [  0.000, 100.000,   0.000,  49.804],       hsv: [300.000, 100.000,  50.196],},
+      # teal
+      "#008080" => {rgb:  [  0, 128, 128],                            hsl: [180.000, 100.000,  25.098],
+                    cmyk: [100.000,   0.000,   0.000,  49.804],       hsv: [180.000, 100.000,  50.196],},
+      # navy
+      "#000080" => {rgb:  [  0,   0, 128],                            hsl: [240.000, 100.000,  25.098],
+                    cmyk: [100.000, 100.000,   0.000,  49.804],       hsv: [240.000, 100.000,  50.196],},
+
+      # some random colors
+      "#E01783" => {rgb:  [224,  23, 131],                            hsl: [327.761,  81.377,  48.431],
+                    cmyk: [  0.000,  89.732,  41.518,  12.157],       hsv: [327.761,  89.732,  87.843],},
+
+      "#1D8056" => {rgb:  [ 29, 128,  86],                            hsl: [154.545,  63.057,  30.784],
+                    cmyk: [ 77.344,   0.000,  32.812,  49.804],       hsv: [154.545,  77.344,  50.196],},
+
+      "#229765" => {rgb:  [ 34, 151, 101],                            hsl: [154.359,  63.243,  36.275],
+                    cmyk: [ 77.483,   0.000,  33.113,  40.784],       hsv: [154.359,  77.483,  59.216],},
+
+      "#239393" => {rgb:  [ 35, 147, 147],                            hsl: [180.000,  61.538,  35.686],
+                    cmyk: [ 76.190,   0.000,   0.000,  42.353],       hsv: [180.000,  76.190,  57.647],},
+    }
+
+    transient do
+      round { 1 }
+    end
+
+    initialize_with  do
+      colors_map.transform_values do |value|
+        value.transform_values { |arr| arr.map { |num| num.round(round)} }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'spec'
+  add_filter 'lib/decolmor/version.rb'
+
+  if ENV['CI']
+    require 'codecov'
+    formatter SimpleCov::Formatter::Codecov
+  else
+    formatter SimpleCov::Formatter::MultiFormatter
+                .new([SimpleCov::Formatter::HTMLFormatter])
+  end
+
+  track_files "**/*.rb"
+end
+
+
+require 'rspec'
+require 'factory_bot'
+
+RSpec.configure do |config|
+
+  config.expose_dsl_globally = true
+
+  # Use color in STDOUT
+  config.color_mode = :on
+
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # Use the specified formatter
+  config.formatter = :documentation # :progress, :html, :textmate
+
+  config.include FactoryBot::Syntax::Methods
+
+  config.before do
+    FactoryBot.reload
+  end
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+end
+
+def load_class(file)
+  klass = File.basename(file).gsub('_spec','')
+  require File.expand_path("lib/#{klass}")
+end
+
+def docs(message, level=0)
+  RSpec.configuration.reporter.message "#{'  ' * level}# #{message}"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: decolmor
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ChildrenofkoRn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: |-
+  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.
+email: Rick-ROR@ya.ru
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- NEWS.md
+- README.md
+- Rakefile
+- decolmor.gemspec
+- lib/decolmor.rb
+- lib/decolmor/main.rb
+- lib/decolmor/version.rb
+- spec/decolmor_spec.rb
+- spec/factories/alpha.rb
+- spec/factories/colors.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ChildrenofkoRn/decolmor
+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
+  bug_tracker_uri: https://github.com/ChildrenofkoRn/decolmor/issues
+  source_code_uri: https://github.com/ChildrenofkoRn/decolmor
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: 'Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK'
+test_files:
+- spec/decolmor_spec.rb
+- spec/factories/alpha.rb
+- spec/factories/colors.rb
+- spec/spec_helper.rb
+- ".rspec"