ex_aequo_color 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4fb0fe9a73d4ee09f3ad5ff391b59a8b2b753c7cc62b8fd0077cf61159ee35c
-  data.tar.gz: 5b7974683fff4c51c8afa3611de4b46fe6b23216ee174e6e875dad02810757c8
+  metadata.gz: d4bf66e8c2104db21c5fc0de8ddc8304ca2bf12ae15a49802f6a39ffa807491e
+  data.tar.gz: 6d85820b12b893b6e3b1f732aae7104fc8caee4c4929b3ea69cdfe9475274d5f
 SHA512:
-  metadata.gz: 69980440123726d3039c73d348b626c61878c0c1cfce528c06ac3c4d2157c6046bb4d5d2db4bb35b7907c7bcc44238e8c0f701c15ba98d72155acab82458788d
-  data.tar.gz: 05ab4096da95f7b4c3109451372e2c265f88a43e6fc69a75d6afa20fd87548b9eb54a6049ea6ecc2b91d3ebd246c62bb6313527f36e406decc68bab7c0293a2a
+  metadata.gz: e40bffec0f9703a82b346d3bb3ca7be75838ffecf8c9aad17027593e7d66164e5fbeef53fa5cce3d0c1086d96e33f3ff5d783a0662614b6ccca39ab38bdb9c28
+  data.tar.gz: 23f5f88a6eb25e1e819e9d527391cb40f670cbf8f71e7678e5729e48276d6251a470801020e8adc0e68c795be5c6502d396add9f8a87275fe484b5aa040b817d

data/README.md

@@ -1,52 +1,369 @@
-[![Gem Version](https://badge.fury.io/rb/ex_aequo_color.svg)](http://badge.fury.io/rb/ex_aequo_color)
-[![Gem Downloads](https://img.shields.io/gem/dt/ex_aequo_color.svg)](https://rubygems.org/gems/ex_aequo_color)
+[![Gem Version](https://badge.fury.io/rb/lab42_color.svg)](http://badge.fury.io/rb/lab42_color)
+[![Gem Downloads](https://img.shields.io/gem/dt/lab42_color.svg)](https://rubygems.org/gems/lab42_color)
 
 
 # ExAequo::Color
 
-Describing how this gem works with some [speculations](https://github.com/RobertDober/speculate_about)...
+## Usage
 
+```sh
+  gem install ex_aequo_color
+```
+
+With bundler
+
+```ruby
+  gem 'ex_aequo_color'
+```
+
+In your code
+
+```ruby
+require 'ex_aequo/color'
+# or
+require 'ex_aequo/color/all'
+```
 
-The `ExAequo::Color` module exposes three methods
+## Synopsis
+
+The `ex_aequo_color` gem exposes the `ExAequo::Color` module.
+
+It can be uses as a receiver or to extend a module or
+to be included.
+
+## Speculations (literate specs)
+
+The following specs are executed with the [speculate about](https://github.com/RobertDober/speculate_about) gem.
+
+These specs assume the following setup code
+
+```ruby
+    require 'ex_aequo/color/all'
+    Color = ExAequo::Color
+```
 
-- `colorize`
-- `colorize_file`
-- `colorize_lines`
+## Context: #color using symbols for colors, strings for text
 
+### Context: using `Color` as receiver
 
-## Context: `colorize`, returning a result
+Then we can get a color code, with or without the reset
+```ruby
+    Color.color(:red, "hello") ==> "\e[31mhello\e[0m"
+    Color.color(:color253, "hello", reset: false) ==> "\e[38;5;253mhello"
+```
+
+And we can combine different colors, fg and bg, as well as bold, dim, etc.
+```ruby
+    Color.color(:bg_red, :bold, :dark_sea_green, "text", reset: false) ==> "\e[41m\e[1m\e[38;2;135;175;135mtext"
+```
+
+And we are also protected against typos
+```ruby
+    expect {
+     Color.color(:bg_red, :bold, :dark_see_green, "text", reset: false)
+    }.to raise_error(Color::BadColorSpecification, "bad color specification: dark_see_green")
+```
+
+Or just the ANSI SGC code
+```ruby
+    Color.sgc(31) ==> "\e[31m"
+```
+
+And we can observe that the NO_COLOR environnement variable is respected
+```ruby
+    original = ENV['NO_COLOR']
+    ENV['NO_COLOR'] = 'true'
+    # ENV['NO_COLOR'] is cached though
+    ExAequo::Color.instance_variable_set("@___no_color__", true)
+
+    Color.color(:red, "hello") ==> "hello"
+    Color.sgc(31) ==> ""
+
+ensure
+    ENV['NO_COLOR'] = original
+    ExAequo::Color.instance_variable_set("@___no_color__", false)
+```
 
-Given we inlude `ExAequo::Color`
+And we can also output directly
 ```ruby
-    require 'ex_aequo/color'
-    include ExAequo::Color
+   expect { Color.putc(:yellow, 'yellow') }.to output("\e[33myellow").to_stdout
+   expect { Color.putcs(:green, 'green', device: $stderr) }.to output("\e[32mgreen\e[0m\n").to_stderr
 ```
 
-Then we can colorize some strings
+And we can override the default `reset:` argument of the two output methods
 ```ruby
-        expect(colorize('hello')).to eq(ok: true, result: 'hello')
+   expect { Color.putcs(:green, 'green', device: $stderr, reset: false) }.to output("\e[32mgreen\n").to_stderr
 ```
 
-And we can also colorize it with colors
+And we can write to any IO device
 ```ruby
-        expect(colorize('<bold>world$!')).to eq(ok: true, result: "\e[1mworld\e[0m!")
+   out = StringIO.new
+   Color.putc(:magenta, 'magenta', device: out, reset: true)
+   out.rewind
+   expect(out.string).to eq("\e[35mmagenta\e[0m")
 ```
 
-And of course we obey the POSIX rule for the `$NO_COLOR` environment variable
+### Context: Including `Color`
+
+As `Color` is a module we can just include it
+Given a class including `Color`
+```ruby
+  class IncludingColor
+    include Color
+  end
+
+  let(:colorizer) { IncludingColor.new }
+```
+
+Then we can use the included methods
+```ruby
+  colorizer.color(:aquamarine1, "hello") ==> "\e[38;2;95;255;215mhello\e[0m"
+  colorizer.color(:light_coral, "hello", reset: false) ==> "\e[38;2;255;135;135mhello"
+```
+
+And there are some ways to reset
+```ruby
+  colorizer.color(:fuchsia, "hello", reset:true) ==> "\e[38;2;255;0;255mhello\e[0m"
+  # And being lazy ;) instead of reset: true
+  colorizer.color(:fuchsia, "hello", :reset) ==> "\e[38;2;255;0;255mhello\e[0m"
+  colorizer.color(:fuchsia, "hello", 0) ==> "\e[38;2;255;0;255mhello\e[0m"
+  
+```
+But we need to be carful with errors
+```ruby
+  expect { colorizer.color(42) }
+    .to raise_error(
+      ArgumentError, "need a colorspec by symbol, a string or 0 (short for :reset), but got 42"
+    )
+```
+
+### Context: Selective Inclusion
+
+Given two classes with different selective inclusion
+```ruby
+    class OnlyOutput
+      include Color::Output
+    end
+
+    class OnlyEncode
+      include Color::Encode
+    end
+
+    let(:oo) { OnlyOutput.new }
+    let(:oe) { OnlyEncode.new }
+```
+
+Then we can use the representivly included methods
+```ruby
+    expect { oo.putc('something') }.to output('something').to_stdout
+    expect { oo.putcs(:red, 'red', device: $stderr) }.to output("\e[31mred\e[0m\n").to_stderr
+```
+
+And also
+```ruby
+    expect(oe.color(:dim)).to eq("\e[2m\e[0m")
+    expect(oe.sgc(45)).to eq("\e[45m")
+```
+
+But we will see that
+```ruby
+    expect {
+      oo.color(:bold)
+    }.to raise_error(NoMethodError, "undefined method 'color' for an instance of OnlyOutput")
+    expect {
+      oo.sgc(0)
+    }.to raise_error(NoMethodError, "undefined method 'sgc' for an instance of OnlyOutput")
+```
+
+And about the same for `OnlyEncode` instances
+```ruby
+    # Yeah this might need a name change because of possible interfearence with the private method
+    expect {
+      oe.putc("hello")
+    }.to raise_error(NoMethodError, "private method 'putc' called for an instance of OnlyEncode")
+    expect {
+      oe.putcs("hello", reset: false)
+    }.to raise_error(NoMethodError, "undefined method 'putcs' for an instance of OnlyEncode")
+```
+
+### Context: But all I need is `#putcs`
+
+Well that is easy, use `Forwardable`
+
+Given a class only using `#putcs`
 ```ruby
-    expect(ENV).to receive(:fetch).with('NO_COLOR', false).and_return(true)
-    expect(colorize('<bold>world$!')).to eq(ok: true, result: "world!")
-        
+    class OnlyPutcs
+      extend Forwardable
+      def_delegators Color::Output, :putcs
+    end
+
+    let(:op) { OnlyPutcs.new } 
 ```
 
-## Context: `colorize_lines`
+Then we can call `#putcs` from an instance, of course
+```ruby
+  expect {
+    op.putcs(:bold, "Greetings", reset: false)
+  }.to output("\e[1mGreetings\n").to_stdout
+    
+```
 
-Given that you might not just get a result but just a colorized string
-Then you can do the following
+But we cannot use `#putc` 
 ```ruby
+    # Yeah this might need a name change because of possible interfearence with the private method
+    expect {
+      op.putc("hello")
+    }.to raise_error(NoMethodError, "private method 'putc' called for an instance of OnlyPutcs")
     
 ```
 
+## Context: #colorize parsing text to colorize it
+
+### Context: using the `Color` module again
+
+Then we can parse and colorize as follows
+```ruby
+  Color.colorize("<red>IMPORTANT").to_h ==> ok: true, result: "\e[31mIMPORTANT" 
+  Color.colorize("<yellow,bold>WARNING").to_h ==> ok: true, result: "\e[33m\e[1mWARNING" 
+  Color.colorize!("<aqua>IMPORTANT", reset: true) ==>  "\e[38;2;0;255;255mIMPORTANT\e[0m" 
+```
+And errors in syntax are reported
+```ruby
+  Color.colorize("<redIMPORTANT").to_h ==> ok: false, error: "Incomplete Color Spec redIMPORTANT"
+```
+And `$NO_COLOR` is again obeyed
+```ruby
+  original = ENV['NO_COLOR']
+  ENV['NO_COLOR'] = 'true'
+  # ENV['NO_COLOR'] is cached though
+  ExAequo::Color.instance_variable_set("@___no_color__", true)
+
+  Color.colorize("<red,bold>IMPORTANT").to_h ==> ok: true, result: "IMPORTANT" 
+  Color.colorize!("<aqua>IMPORTANT", reset: true) ==>  "IMPORTANT" 
+
+ensure
+  ENV['NO_COLOR'] = original
+  ExAequo::Color.instance_variable_set("@___no_color__", false)
+```
+But even with `$NO_COLOR` errors are reported or raised
+```ruby
+  original = ENV['NO_COLOR']
+  ENV['NO_COLOR'] = 'true'
+  # ENV['NO_COLOR'] is cached though
+  ExAequo::Color.instance_variable_set("@___no_color__", true)
+
+  Color.colorize("<red,boldIMPORTANT").to_h ==> ok: false, error: "Incomplete Color Spec boldIMPORTANT"
+  
+  expect {
+    Color.colorize!("<red")
+  }.to raise_error(
+    Color::SyntaxError, "Incomplete Color Spec red"
+  )
+
+ensure
+  ENV['NO_COLOR'] = original
+  ExAequo::Color.instance_variable_set("@___no_color__", false)
+  
+```
+
+## Context: Extending the `String` class
+
+Given we require that feature
+```ruby
+  require 'ex_aequo/color/string'
+```
+
+Then we can call `colored` on a `String` instance
+```ruby
+  "hello".colored(:orange) ==> "\e[38;2;255;128;0mhello\e[0m"
+  # N.B. We have reset defaulting to true here
+  "hello".colored(:orange, reset: false) ==> "\e[38;2;255;128;0mhello"
+```
+
+## Context: Printing with colors
+
+Given we intercept output
+```ruby
+  before do
+    expect(device).to receive(:puts).with(text)
+  end
+```
+
+### Context: We can print to $stderr with `#pcolored` by default
+
+Given the following setup
+```ruby
+  let(:device) { $stderr }
+  let(:text) { "\e[38;2;255;135;175mwhat a color?\e[0m" }
+```
+Then we can also print to a device
+```ruby
+  Color.pcolored(:pale_violet_red1, "what a color?")
+```
+
+### Context: We can print to any object responding to `:puts` with `#pcolored`
+
+Given the following setup
+```ruby
+  let(:device) { $stdout }
+  let(:text) { "\e[38;2;255;135;175mwhat a color?" }
+```
+Then we can also print to a device
+```ruby
+  Color.pcolored(:pale_violet_red1, "what a color?", device:, reset: false)
+```
+
+## Context: Printing lines, defaults to `$stdout`
+
+Then we can do the following
+```ruby
+  expect($stdout)
+    .to receive(:puts).with("\e[31ma").ordered
+  expect($stdout)
+    .to receive(:puts).with("\e[34mb").ordered
+
+    Color.colorize_lines("<red>a\n<blue>b")
+```
+
+But we will be warned about errors
+```ruby
+  expect($stderr).to receive(:puts).with("ERROR in line 1 ** Incomplete Color Spec re **")
+
+  Color.colorize_lines("<re")
+```
+
+## Context: Printing files, defaults to `$stdout`
+
+Given a file
+```ruby
+  lines = [
+  "<bold>Hello",
+  "and <magenta,dim>World"
+  ]
+
+  require 'fileutils'
+  FileUtils.mkdir_p 'tmp'
+  file = File.join('tmp', SecureRandom.alphanumeric)
+  File.write(file, lines.join("\n"))
+```
+
+Then we can do the following
+```ruby
+  expect($stdout).to receive(:puts).with("\e[1mHello").ordered
+  expect($stdout).to receive(:puts).with("and \e[35m\e[2mWorld").ordered
+
+    Color.colorize_file(file)
+```
+
+Or we can write to a different device
+```ruby
+  output = StringIO.new
+  Color.colorize_file(file, device: output, reset: true)
+  output.rewind
+  expect(output.read).to eq("\e[1mHello\e[0m\nand \e[35m\e[2mWorld\e[0m\n")
+```
+
+
 ## Author
 
 Copyright 2025 Robert Dober robert.dober@gmail.com

data/lib/ex_aequo/color/all.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'ex_aequo/base/kernel'
+require_relative '../color'
+require_relative '../color/colorizer'
+require_relative '../color/string'
+
+Color = ExAequo::Color
+Colorizer = Color::Colorizer
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/color/ansi_color_names.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module ExAequo
+  module Color
+
+      EIGHT_BIT_COLORS = {
+        bg_black: 40,
+        bg_red: 41,
+        bg_green: 42,
+        bg_yellow: 43,
+        bg_blue: 44,
+        bg_magenta: 45,
+        bg_cyan: 46,
+        bg_white: 47,
+        black: 30,
+        blue: 34,
+        bold: 1,
+        cyan: 36,
+        dim: 2,
+        green: 32,
+        italic: 3,
+        magenta: 35,
+        red: 31,
+        reset: 0,
+        uline: 4,
+        underline: 4,
+        white: 37,
+        yellow: 33
+      }
+
+      RGB_COLORS = {
+        aqua: [0, 255, 255],
+        aquamarine1: [95, 255, 215],
+        aquamarine3: [95, 215, 175],
+        azure1: [240, 255, 255],
+        blue1: [0, 0, 255],
+        blue3: [0, 0, 175],
+        blue_violet: [95, 0, 255],
+        cadet_blue: [95, 175, 135],
+        chartreuse1: [135, 255, 0],
+        chartreuse2: [95, 255, 0],
+        chartreuse3: [95, 175, 0],
+        chartreuse4: [95, 135, 0],
+        cornflower_blue: [95, 135, 255],
+        cornsilk1: [255, 255, 215],
+        cyan1: [0, 255, 255],
+        cyan2: [0, 255, 215],
+        cyan3: [0, 215, 175],
+        dark_blue: [0, 0, 135],
+        dark_cyan: [0, 175, 135],
+        dark_goldenrod: [175, 135, 0],
+        dark_green: [0, 95, 0],
+        dark_khaki: [175, 175, 95],
+        dark_magenta: [135, 0, 135],
+        dark_olive_green1: [215, 255, 95],
+        dark_olive_green2: [175, 255, 95],
+        dark_olive_green3: [135, 175, 95],
+        dark_orange3: [175, 95, 0],
+        dark_orange: [255, 135, 0],
+        dark_red: [95, 0, 0],
+        dark_sea_green1: [175, 255, 215],
+        dark_sea_green2: [175, 215, 175],
+        dark_sea_green3: [135, 215, 175],
+        dark_sea_green4: [95, 135, 95],
+        dark_sea_green: [135, 175, 135],
+        dark_slate_gray1: [135, 255, 255],
+        dark_slate_gray2: [95, 255, 255],
+        dark_slate_gray3: [135, 215, 215],
+        dark_turquoise: [0, 215, 215],
+        dark_violet: [135, 0, 215],
+        deep_pink1: [255, 0, 135],
+        deep_pink2: [255, 0, 95],
+        deep_pink3: [215, 0, 95],
+        deep_pink4: [95, 0, 95],
+        deep_sky_blue1: [0, 175, 255],
+        deep_sky_blue2: [0, 175, 215],
+        deep_sky_blue3: [0, 135, 175],
+        deep_sky_blue4: [0, 95, 95],
+        dodger_blue1: [0, 135, 255],
+        dodger_blue2: [0, 95, 255],
+        dodger_blue3: [0, 95, 215],
+        fuchsia: [255, 0, 255],
+        gold1: [255, 215, 0],
+        gold3: [175, 175, 0],
+        green1: [0, 255, 0],
+        green3: [0, 175, 0],
+        green4: [0, 135, 0],
+        green_yellow: [175, 255, 0],
+        grey0: [0, 0, 0],
+        grey100: [255, 255, 255],
+        grey11: [28, 28, 28],
+        grey15: [38, 38, 38],
+        grey19: [48, 48, 48],
+        grey23: [58, 58, 58],
+        grey27: [68, 68, 68],
+        grey30: [78, 78, 78],
+        grey35: [88, 88, 88],
+        grey37: [95, 95, 95],
+        grey39: [98, 98, 98],
+        grey3: [8, 8, 8],
+        grey42: [108, 108, 108],
+        grey46: [118, 118, 118],
+        grey50: [128, 128, 128],
+        grey53: [135, 135, 135],
+        grey54: [138, 138, 138],
+        grey58: [148, 148, 148],
+        grey62: [158, 158, 158],
+        grey63: [175, 135, 175],
+        grey66: [168, 168, 168],
+        grey69: [175, 175, 175],
+        grey70: [178, 178, 178],
+        grey74: [188, 188, 188],
+        grey78: [198, 198, 198],
+        grey7: [18, 18, 18],
+        grey82: [208, 208, 208],
+        grey84: [215, 215, 215],
+        grey85: [218, 218, 218],
+        grey89: [228, 228, 228],
+        grey93: [238, 238, 238],
+        grey: [128, 128, 128],
+        honeydew2: [215, 255, 215],
+        hot_pink2: [215, 95, 175],
+        hot_pink3: [175, 95, 135],
+        hot_pink: [255, 95, 175],
+        indian_red1: [255, 95, 95],
+        indian_red: [175, 95, 95],
+        khaki1: [255, 255, 135],
+        khaki3: [215, 215, 95],
+        light_coral: [255, 135, 135],
+        light_cyan1: [215, 255, 255],
+        light_cyan3: [175, 215, 215],
+        light_goldenrod1: [255, 255, 95],
+        light_goldenrod2: [215, 215, 135],
+        light_goldenrod3: [215, 175, 95],
+        light_green: [135, 255, 95],
+        light_pink1: [255, 175, 175],
+        light_pink3: [215, 135, 135],
+        light_pink4: [135, 95, 95],
+        light_salmon1: [255, 175, 135],
+        light_salmon3: [175, 135, 95],
+        light_sea_green: [0, 175, 175],
+        light_sky_blue1: [175, 215, 255],
+        light_sky_blue3: [135, 175, 175],
+        light_slate_blue: [135, 135, 255],
+        light_slate_grey: [135, 135, 175],
+        light_steel_blue1: [215, 215, 255],
+        light_steel_blue3: [175, 175, 215],
+        light_steel_blue: [175, 175, 255],
+        light_yellow3: [215, 215, 175],
+        lime: [0, 255, 0],
+        magenta1: [255, 0, 255],
+        magenta2: [215, 0, 255],
+        magenta3: [175, 0, 175],
+        maroon: [128, 0, 0],
+        medium_orchid1: [215, 95, 255],
+        medium_orchid3: [175, 95, 175],
+        medium_orchid: [175, 95, 215],
+        medium_purple1: [175, 135, 255],
+        medium_purple2: [175, 95, 255],
+        medium_purple3: [135, 95, 175],
+        medium_purple4: [95, 95, 135],
+        medium_purple: [135, 135, 215],
+        medium_spring_green: [0, 255, 175],
+        medium_turquoise: [95, 215, 215],
+        medium_violet_red: [175, 0, 135],
+        misty_rose1: [255, 215, 215],
+        misty_rose3: [215, 175, 175],
+        navajo_white1: [255, 215, 175],
+        navajo_white3: [175, 175, 135],
+        navy: [0, 0, 128],
+        navy_blue: [0, 0, 95],
+        olive: [128, 128, 0],
+        orange: [255, 128, 0],
+        orange1: [255, 175, 0],
+        orange3: [215, 135, 0],
+        orange4: [95, 95, 0],
+        orange_red1: [255, 95, 0],
+        orchid1: [255, 135, 255],
+        orchid2: [255, 135, 215],
+        orchid: [215, 95, 215],
+        pale_green1: [135, 255, 175],
+        pale_green3: [95, 215, 95],
+        pale_turquoise1: [175, 255, 255],
+        pale_turquoise4: [95, 135, 135],
+        pale_violet_red1: [255, 135, 175],
+        pink1: [255, 175, 215],
+        pink3: [215, 135, 175],
+        plum1: [255, 175, 255],
+        plum2: [215, 175, 255],
+        plum3: [215, 135, 215],
+        plum4: [135, 95, 135],
+        purple3: [95, 0, 215],
+        purple4: [95, 0, 135],
+        purple: [128, 0, 128],
+        red1: [255, 0, 0],
+        red3: [175, 0, 0],
+        rosy_brown: [175, 135, 135],
+        royal_blue1: [95, 95, 255],
+        salmon1: [255, 135, 95],
+        sandy_brown: [255, 175, 95],
+        sea_green1: [95, 255, 135],
+        sea_green2: [95, 255, 95],
+        sea_green3: [95, 215, 135],
+        silver: [192, 192, 192],
+        sky_blue1: [135, 215, 255],
+        sky_blue2: [135, 175, 255],
+        sky_blue3: [95, 175, 215],
+        slate_blue1: [135, 95, 255],
+        slate_blue3: [95, 95, 175],
+        spring_green1: [0, 255, 135],
+        spring_green2: [0, 215, 135],
+        spring_green3: [0, 175, 95],
+        spring_green4: [0, 135, 95],
+        steel_blue1: [95, 175, 255],
+        steel_blue3: [95, 135, 215],
+        steel_blue: [95, 135, 175],
+        tan: [215, 175, 135],
+        teal: [0, 128, 128],
+        thistle1: [255, 215, 255],
+        thistle3: [215, 175, 215],
+        turquoise2: [0, 215, 255],
+        turquoise4: [0, 135, 135],
+        violet: [215, 135, 255],
+        wheat1: [255, 255, 175],
+        wheat4: [135, 135, 95],
+        yellow1: [255, 255, 0],
+        yellow2: [215, 255, 0],
+        yellow3: [175, 215, 0],
+        yellow4: [135, 135, 0]
+      }
+
+      ANSI_COLOR_NAMES = 
+        (0..255)
+        .map {["color#{it}".to_sym, [:color, it]]}
+        .to_h
+        .merge(EIGHT_BIT_COLORS, RGB_COLORS)
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/ex_aequo/color/color_definitions.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+
+require_relative 'ansi_color_names'
+module ExAequo
+  module Color
+    module ColorDefinitions extend self
+      CSI = "\e["
+
+      def get(color, no_color)
+        color = find_color(color)
+        if color
+          return '' if no_color
+          color
+        end
+      end
+
+      def sgc(value) ="#{CSI}#{value}m"
+
+      private
+      def find_color(color)
+        case ANSI_COLOR_NAMES.fetch(color.to_sym, nil)
+        in [_, _, _] => rgb 
+          sgc("38;2;#{rgb.join(";")}")
+        in [:color, col]
+          sgc("38;5;#{col}")
+        in value unless value.nil?
+          sgc(value)
+        else
+          nil
+          # raise BadColorSpecification, "bad color specification: #{color}"
+        end
+      end
+      # From ex_aequo/base
+      # def find_color(color)
+      #   case ANSI_COLORS.fetch(color.to_sym, nil)
+      #   in [r, g, b] 
+      #     "\e[38;2;#{r};#{g};#{b}m"
+      #   in [:color, col]
+      #     "\e[35;5;#{col}m"
+      #   in nil
+      #     nil
+      #   in value
+      #     "\e[#{value}m"
+      #   end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later