ansi256 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e0c06de0d942deeb5906752ed223248b699408b93a2bba463bbb848d6b06aea
-  data.tar.gz: a7ea18e9b3902806d43fe46e7b388c8d0152e4e0e365bdb552ad35d11064b12a
+  metadata.gz: 193fb48fa8076a77689d28fc6923216d4d144fa0614d209a7c8c10289564f5e2
+  data.tar.gz: 9f6159c21e0a94c54dc14f9306251f55faba36e596b298286ba995a84602d5fd
 SHA512:
-  metadata.gz: 8d10be011d96e91b58ccfef63608a466052dfaca7bd25e05ee1c6b83cabc6deaeeefc1e0de4e9f99b19267714f0b88a04b42bac031fe4c5937fc39b9c078c043
-  data.tar.gz: b15f5eab61b1f5be118a69bd9cdbd5972a7ea0adc13a51e462665aaf282c71b4967d917d6ebbc8b17c7e6eb97ecbdae76e2a1d7349ef014330177926ff4829b6
+  metadata.gz: 9b3dd2434b21092bac623baf058ee31725ce9f3c131687150f03936b6e5aa0d863ea11dee9ba683bda5322faa160e7115b046a19503c8ae69d778622f8455ab3
+  data.tar.gz: 7d0cfc94e225eb7da1aba42fd82e2d6c4733d36f5dd26a9054fc3b520d7c911064b368e4f2b434204712873b111b66386280b5393bcab1cdabd1241d689e0bb2

data/README.md

@@ -1,10 +1,11 @@
 # ansi256
 
-ansi256 is a rubygem for colorizing text with 256-color ANSI codes.
+ansi256 is a rubygem for colorizing text with ANSI escape codes.
 
 Features:
 
-- Supports both named color codes and numeric 256-color codes
+- True 24-bit color, named colors, and 256-color support
+- Underline styles (curly, double, dotted, dashed) and underline colors
 - Allows nesting of colored text
 - Generates optimal(shortest) code sequence
 
@@ -29,6 +30,13 @@ puts "Colorize me".fg(111).bg(226)
 # Also with underline
 puts "Colorize me".fg(111).bg(226).underline
 
+# Underline styles (single, double, curly, dotted, dashed)
+puts "Colorize me".underline(:curly)
+
+# Underline with color (256-color index or hex RGB)
+puts "Colorize me".underline(:curly, 'ff9900')
+puts "Colorize me".underline(214)
+
 # Strip ANSI codes
 puts "Colorize me".fg(111).bg(226).underline.plain
 ```
@@ -51,7 +59,9 @@ puts [ s.white,   s.white.bold,   s.white.bold.on_white   ].join ' '
 
 ![colorize-me-16](https://github.com/junegunn/ansi256/raw/master/colorize-me-16.png)
 
-### RGB color approximated to 256-color ANSI code
+### RGB hex colors
+
+RGB hex strings produce true 24-bit color (`\e[38;2;R;G;Bm`) by default.
 
 ```ruby
 puts "RGB Color (RRGGBB)".fg('ff9930').bg('203366')
@@ -61,6 +71,12 @@ puts "RGB Color (R-G-B-)".fg('f90').bg('036')
 puts "RGB Color (Monochrome)".fg('ef').bg('3f')
 ```
 
+To approximate RGB to 256-color indices instead (for legacy terminals):
+
+```ruby
+Ansi256.truecolor = false
+```
+
 Nesting
 -------
 
@@ -110,43 +126,6 @@ Ansi256.enabled = $stdout.tty?
   # Hello
 ```
 
-ansi256 executable
-------------------
-
-Ansi256 comes with `ansi256` script which can be used as follows
-
-```bash
-usage: ansi256 [-b] [-d] [-i] [-u] <[fg][/bg]> [message]
-
-# Numeric color codes
-ansi256 232 "Hello world"
-ansi256 /226 "Hello world"
-ansi256 232/226 "Hello world"
-
-# Named color codes
-ansi256 yellow "Hello world"
-ansi256 /blue "Hello world"
-ansi256 yellow/blue "Hello world"
-
-# RGB colors (only support 6-letter hex codes)
-ansi256 ff9900/000033 "Hello world"
-
-# Mixed color codes
-ansi256 yellow/232 "Hello world"
-
-# Bold yellow
-ansi256 yellow/232 -b "Hello world"
-
-# With underline
-ansi256 yellow/232 -b -u "Hello world"
-
-# Colorizing STDIN
-find / | ansi256 -u /226
-
-# Nesting
-ansi256 30 "Say '$(ansi256 230/75 "Hello $(ansi256 -u 232/226 World)")'"
-```
-
 Color chart
 -----------
 

data/bin/ansi256

@@ -1,6 +1,9 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# Deprecated: this CLI is no longer maintained.
+# Use the library API directly instead.
+
 require 'rubygems'
 require 'ansi256'
 

data/lib/ansi256/code.rb

@@ -27,6 +27,14 @@ module Ansi256
     on_white: 47
   }.freeze
 
+  UNDERLINE_STYLES = {
+    single: '4:1',
+    double: '4:2',
+    curly:  '4:3',
+    dotted: '4:4',
+    dashed: '4:5',
+  }.freeze
+
   NAMED_COLORS = Set[
    :black,
    :red,

data/lib/ansi256/mixin.rb

@@ -27,6 +27,12 @@ module Ansi256
               Ansi256.send name, self
             end
           end
+
+          # Override underline to accept style and color
+          undef_method(:underline) if method_defined?(:underline)
+          define_method :underline do |*props|
+            Ansi256.underline(self, *props)
+          end
         end
 
         Ansi256.class_eval do
@@ -58,6 +64,12 @@ module Ansi256
               self
             end
           end
+
+          # Override underline to accept style and color (disabled mode)
+          undef_method(:underline) if method_defined?(:underline)
+          define_method :underline do |*props|
+            self
+          end
         end
 
         Ansi256.class_eval do
@@ -74,4 +86,3 @@ module Ansi256
     end
   end
 end
-

data/lib/ansi256/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ansi256
-  VERSION = '0.5.0'
+  VERSION = '0.6.1'
 end

data/lib/ansi256.rb

@@ -7,6 +7,8 @@ require 'ansi256/mixin'
 
 module Ansi256
   class << self
+    attr_accessor :truecolor
+
     def fg(code, str = nil)
       if str
         wrap str, Ansi256.fg(code)
@@ -14,8 +16,12 @@ module Ansi256
         "\e[#{CODE[code]}m"
       elsif code.is_a?(Integer) && (0..255).include?(code)
         "\e[38;5;#{code}m"
-      elsif ansirgb = ansicode_for_rgb(code)
-        "\e[38;5;#{ansirgb}m"
+      elsif rgb = parse_rgb(code)
+        if truecolor
+          "\e[38;2;#{rgb.join(';')}m"
+        else
+          "\e[38;5;#{ansicode_for_rgb(code)}m"
+        end
       else
         raise ArgumentError, "Invalid color code: #{code}"
       end
@@ -28,14 +34,20 @@ module Ansi256
         "\e[#{CODE[code] + 10}m"
       elsif code.is_a?(Integer) && (0..255).include?(code)
         "\e[48;5;#{code}m"
-      elsif ansirgb = ansicode_for_rgb(code)
-        "\e[48;5;#{ansirgb}m"
+      elsif rgb = parse_rgb(code)
+        if truecolor
+          "\e[48;2;#{rgb.join(';')}m"
+        else
+          "\e[48;5;#{ansicode_for_rgb(code)}m"
+        end
       else
         raise ArgumentError, "Invalid color code: #{code}"
       end
     end
 
     CODE.each do |name, code|
+      next if name == :underline # defined below
+
       define_method name do |*arg|
         if str = arg.first
           wrap str, "\e[#{code}m"
@@ -45,88 +57,223 @@ module Ansi256
       end
     end
 
+    # Underline with optional styles and colors
+    def underline(str = nil, *props)
+      if str.nil?
+        build_underline_sgr(*props)
+      else
+        wrap str, build_underline_sgr(*props)
+      end
+    end
+
     def plain(str)
       str.gsub(PATTERN, '')
     end
 
     private
 
-    PATTERN       = /\e\[[0-9;]+m/
-    MULTI_PATTERN = /(?:\e\[[0-9;]+m)+/
-    EMPTY_TRIPLE  = [nil, nil, Set.new].freeze
+    PATTERN       = /\e\[[0-9;:]+m/
+    MULTI_PATTERN = /(?:\e\[[0-9;:]+m)+/
+    # State: [fg, bg, ul_style, ul_color, attrs_set]
+    # ul_style is only for sub-parameter styles (4:1, 4:2, etc.)
+    # Basic underline (4) stays in attrs_set for backward compat
+    EMPTY_STATE   = [nil, nil, nil, nil, Set.new].freeze
+
+    def build_underline_sgr(*args)
+      style = nil
+      color = nil
+
+      args.each do |arg|
+        case arg
+        when nil
+          next
+        when Symbol
+          if UNDERLINE_STYLES[arg]
+            style = arg
+          elsif NAMED_COLORS.include?(arg)
+            color = arg
+          else
+            raise ArgumentError, "Invalid underline argument: #{arg}"
+          end
+        when Integer, String
+          color = arg
+        else
+          raise ArgumentError, "Invalid underline argument: #{arg}"
+        end
+      end
+
+      return "\e[4m" unless style || color
+
+      parts = []
+      parts << (style ? UNDERLINE_STYLES[style] : '4')
+      parts << underline_color_code(color) if color
+
+      "\e[#{parts.join(';')}m"
+    end
+
+    def underline_color_code(color)
+      case color
+      when Symbol
+        raise ArgumentError, "Invalid underline color: #{color}" unless NAMED_COLORS.include?(color)
+        "58;5;#{CODE[color] - 30}"
+      when Integer
+        raise ArgumentError, "Invalid underline color: #{color}" unless (0..255).include?(color)
+        "58;5;#{color}"
+      when String
+        rgb = parse_rgb(color)
+        raise ArgumentError, "Invalid underline color: #{color}" unless rgb
+        if truecolor
+          "58;2;#{rgb.join(';')}"
+        else
+          "58;5;#{ansicode_for_rgb(color)}"
+        end
+      else
+        raise ArgumentError, "Invalid underline color: #{color}"
+      end
+    end
 
     def ansify(prev, curr)
       nums = []
       nums << curr[0] if prev[0] != curr[0]
       nums << curr[1] if prev[1] != curr[1]
-      nums.concat curr[2].to_a if prev[2] != curr[2]
+      nums << curr[2] if prev[2] != curr[2]
+      nums << curr[3] if prev[3] != curr[3]
+      nums.concat curr[4].to_a if prev[4] != curr[4]
       "\e[#{nums.compact.join ';'}m"
     end
 
-    def ansicode_for_rgb(rgb)
-      return unless rgb.is_a?(String) &&
-                    rgb =~ /^#?([0-9a-f]+)$/i
+    def parse_rgb(code)
+      return unless code.is_a?(String) &&
+                    code =~ /^#?([0-9a-f]+)$/i
 
-      rgb = ::Regexp.last_match(1)
+      hex = ::Regexp.last_match(1)
 
-      case rgb.length
+      case hex.length
       when 2
-        m = (256 - 231) * rgb.to_i(16) / 256
-        return m == 0 ? 16 : (231 + m)
+        v = hex.to_i(16)
+        [v, v, v]
       when 3
-        r, g, b = rgb.each_char.map { |e| (e * 2).to_i(16) }
+        hex.each_char.map { |e| (e * 2).to_i(16) }
       when 6
-        r, g, b = rgb.each_char.each_slice(2).map { |e| e.join.to_i(16) }
-      else
-        return
+        hex.each_char.each_slice(2).map { |e| e.join.to_i(16) }
       end
+    end
 
+    def rgb_to_ansi256(r, g, b)
       r, g, b = [r, g, b].map { |e| 6 * e / 256 }
       r * 36 + g * 6 + b + 16
     end
 
+    def ansicode_for_rgb(code)
+      return unless code.is_a?(String) &&
+                    code =~ /^#?([0-9a-f]+)$/i
+
+      hex = ::Regexp.last_match(1)
+
+      # 2-char monochrome uses grayscale ramp (232-255)
+      if hex.length == 2
+        m = 25 * hex.to_i(16) / 256
+        return m == 0 ? 16 : (231 + m)
+      end
+
+      rgb = parse_rgb(code)
+      return unless rgb
+
+      rgb_to_ansi256(*rgb)
+    end
+
     def wrap(str, color)
-      current = [nil, nil, Set.new]
+      current = [nil, nil, nil, nil, Set.new]
 
       (color + str.gsub(PATTERN) do |m|
-        if m =~ /\e\[[^m]*\b0m/
+        if m == "\e[0m"
           m + color
         else
           m
         end
       end << reset).gsub(MULTI_PATTERN) do |ansi|
         prev = current.dup
-        prev[2] = prev[2].dup
-        codes = ansi.scan(/\d+/).map(&:to_i)
-
-        idx = -1
-        while (idx += 1) < codes.length
-          case code = codes[idx]
-          when 38
-            current[0] = codes[idx, 3].join ';'
-            idx += 2 # 38;5;11
-          when 48
-            current[1] = codes[idx, 3].join ';'
-            idx += 2 # 38;5;11
-          when 30..37
-            current[0] = codes[idx]
-          when 40..47
-            current[1] = codes[idx]
-          when 0
-            current[0] = current[1] = nil
-            current[2].clear
-          else
-            current[2] << code
+        prev[4] = prev[4].dup
+
+        # Extract individual SGR sequences and parse each
+        seqs = ansi.scan(/\e\[([^\e]*?)m/).map { |cap| cap[0] }
+        seqs.each do |seq|
+          # Split by semicolon, preserving colon sub-params within groups
+          groups = seq.split(';')
+
+          idx = -1
+          while (idx += 1) < groups.length
+            group = groups[idx]
+
+            if group.include?(':')
+              # Sub-parameter group (e.g., "4:3")
+              main, sub = group.split(':', 2)
+              main_i = main.to_i
+              if main_i == 4
+                if sub == '0'
+                  current[2] = nil
+                  current[4].delete(4)
+                else
+                  current[2] = group
+                  current[4].delete(4)
+                end
+              end
+            else
+              code = group.to_i
+              case code
+              when 38
+                if groups[idx + 1] == '2'
+                  current[0] = groups[idx, 5].join(';')
+                  idx += 4
+                else
+                  current[0] = groups[idx, 3].join(';')
+                  idx += 2
+                end
+              when 48
+                if groups[idx + 1] == '2'
+                  current[1] = groups[idx, 5].join(';')
+                  idx += 4
+                else
+                  current[1] = groups[idx, 3].join(';')
+                  idx += 2
+                end
+              when 58
+                if groups[idx + 1] == '2'
+                  current[3] = groups[idx, 5].join(';')
+                  idx += 4
+                else
+                  current[3] = groups[idx, 3].join(';')
+                  idx += 2
+                end
+              when 30..37
+                current[0] = code
+              when 40..47
+                current[1] = code
+              when 0
+                current[0] = current[1] = current[2] = current[3] = nil
+                current[4].clear
+              when 24
+                current[2] = nil
+                current[4].delete(4)
+              when 59
+                current[3] = nil
+              when 4
+                # Basic underline goes in attrs set for backward compat
+                current[4] << 4
+              else
+                current[4] << code
+              end
+            end
           end
         end
 
         if current == prev
           ''
-        elsif current == EMPTY_TRIPLE
+        elsif current == EMPTY_STATE
           reset
         else
-          if (0..1).any? { |i| prev[i] && !current[i] } || current[2].proper_subset?(prev[2])
-            prev = EMPTY_TRIPLE
+          if (0..3).any? { |i| prev[i] && !current[i] } || current[4].proper_subset?(prev[4])
+            prev = EMPTY_STATE
             reset
           else
             ''
@@ -138,3 +285,4 @@ module Ansi256
 end
 
 Ansi256.enabled = true
+Ansi256.truecolor = true

data/test/test_ansi256.rb

@@ -149,34 +149,39 @@ class TestAnsi256 < Minitest::Test
   end
 
   def test_rgb
+    # Truecolor mode (default): 38;2;R;G;B
     {
-      '00' => 16,
-      '000000' => 16,
-      '111' => 16,
-      '11' => 232,
-      '101010' => 16,
-      '1a' => 233,
-      '1a1a1a' => 16,
-      '20' => 234,
-      '22' => 234,
-      '202020' => 16,
-      '222222' => 16,
-      '222222' => 16,
-      'ff' => 255,
-      'ffffff' => 231,
-      'FFFFFF' => 231,
-      'ff0' => 226,
-      'ffff00' => 226,
-      'ff0000' => 196,
-      '00ff00' => 46,
-      '0000ff' => 21,
-      'ff9900' => 214,
-      '00ffff' => 51,
-      '0ff' => 51
-    }.each do |rgb, ansi|
-      assert_equal ansi, Ansi256.fg(rgb).scan(/[0-9]+/).last.to_i
-      assert_equal ansi, Ansi256.bg(rgb).scan(/[0-9]+/).last.to_i
+      '00'     => [0, 0, 0],
+      '000000' => [0, 0, 0],
+      '111'    => [17, 17, 17],
+      '11'     => [17, 17, 17],
+      '101010' => [16, 16, 16],
+      '1a'     => [26, 26, 26],
+      '1a1a1a' => [26, 26, 26],
+      '20'     => [32, 32, 32],
+      '22'     => [34, 34, 34],
+      '202020' => [32, 32, 32],
+      '222222' => [34, 34, 34],
+      'ff'     => [255, 255, 255],
+      'ffffff' => [255, 255, 255],
+      'FFFFFF' => [255, 255, 255],
+      'ff0'    => [255, 255, 0],
+      'ffff00' => [255, 255, 0],
+      'ff0000' => [255, 0, 0],
+      '00ff00' => [0, 255, 0],
+      '0000ff' => [0, 0, 255],
+      'ff9900' => [255, 153, 0],
+      '00ffff' => [0, 255, 255],
+      '0ff'    => [0, 255, 255],
+    }.each do |hex, (r, g, b)|
+      assert_equal "\e[38;2;#{r};#{g};#{b}m", Ansi256.fg(hex)
+      assert_equal "\e[48;2;#{r};#{g};#{b}m", Ansi256.bg(hex)
     end
+    # # prefix
+    assert_equal "\e[38;2;255;153;0m", Ansi256.fg('#ff9900')
+    assert_equal "\e[48;2;0;51;102m",  Ansi256.bg('#003366')
+
+    # Visual output
     %i[bg fg].each do |m|
       (0..255).each do |r|
         color = r.to_s(16).rjust(2, '0') * 3
@@ -201,6 +206,59 @@ class TestAnsi256 < Minitest::Test
     puts 'RGB Color (Monochrome)'.fg('ef').bg('3a')
   end
 
+  def test_rgb_nesting
+    # Truecolor inner nested inside truecolor outer
+    assert_equal "\e[38;2;0;51;102mHello \e[38;2;255;153;0mWorld\e[38;2;0;51;102m !\e[0m",
+                 "Hello #{'World'.fg('ff9900')} !".fg('003366')
+
+    # Truecolor fg with integer bg
+    assert_equal "\e[38;2;255;153;0;48;5;100mHello\e[0m",
+                 'Hello'.fg('ff9900').bg(100)
+
+    # Integer fg nested inside truecolor fg
+    assert_equal "\e[38;2;0;51;102mHello \e[38;5;100mWorld\e[38;2;0;51;102m !\e[0m",
+                 "Hello #{'World'.fg(100)} !".fg('003366')
+
+    # Truecolor underline color in nesting
+    inner = 'world'.underline(:curly, 'ff0000')
+    result = "hello #{inner} end".fg('003366')
+    assert_equal "\e[38;2;0;51;102mhello \e[4:3;58;2;255;0;0mworld\e[0m\e[38;2;0;51;102m end\e[0m", result
+  end
+
+  def test_rgb_approximation
+    # When truecolor is disabled, fall back to 256-color approximation
+    Ansi256.truecolor = false
+    {
+      '00'     => 16,
+      '000000' => 16,
+      '111'    => 16,
+      '11'     => 232,
+      '101010' => 16,
+      '1a'     => 233,
+      '1a1a1a' => 16,
+      '20'     => 234,
+      '22'     => 234,
+      '202020' => 16,
+      '222222' => 16,
+      'ff'     => 255,
+      'ffffff' => 231,
+      'FFFFFF' => 231,
+      'ff0'    => 226,
+      'ffff00' => 226,
+      'ff0000' => 196,
+      '00ff00' => 46,
+      '0000ff' => 21,
+      'ff9900' => 214,
+      '00ffff' => 51,
+      '0ff'    => 51,
+    }.each do |rgb, ansi|
+      assert_equal ansi, Ansi256.fg(rgb).scan(/[0-9]+/).last.to_i
+      assert_equal ansi, Ansi256.bg(rgb).scan(/[0-9]+/).last.to_i
+    end
+  ensure
+    Ansi256.truecolor = true
+  end
+
   def test_enabled
     2.times do
       %i[fg bg].each do |m|
@@ -219,4 +277,92 @@ class TestAnsi256 < Minitest::Test
       end
     end
   end
+
+  # --- Extended underline tests ---
+
+  def test_underline_backward_compat
+    # No-arg: returns SGR code
+    assert_equal "\e[4m", Ansi256.underline
+
+    # String arg: wraps with basic underline
+    assert_equal "\e[4mhello\e[0m", Ansi256.underline('hello')
+    assert_equal "\e[4mhello\e[0m", 'hello'.underline
+  end
+
+  def test_underline_styles
+    assert_equal "\e[4:1mhello\e[0m", 'hello'.underline(:single)
+    assert_equal "\e[4:2mhello\e[0m", 'hello'.underline(:double)
+    assert_equal "\e[4:3mhello\e[0m", 'hello'.underline(:curly)
+    assert_equal "\e[4:4mhello\e[0m", 'hello'.underline(:dotted)
+    assert_equal "\e[4:5mhello\e[0m", 'hello'.underline(:dashed)
+  end
+
+  def test_underline_color_integer
+    assert_equal "\e[58;5;214;4mhello\e[0m", 'hello'.underline(214)
+  end
+
+  def test_underline_color_hex
+    assert_equal "\e[58;2;255;153;0;4mhello\e[0m", 'hello'.underline('ff9900')
+    assert_equal "\e[58;2;255;153;0;4mhello\e[0m", 'hello'.underline('#ff9900')
+    assert_equal "\e[58;2;255;153;0;4mhello\e[0m", 'hello'.underline('f90')
+  end
+
+  def test_underline_style_with_color
+    assert_equal "\e[4:3;58;2;255;153;0mhello\e[0m", 'hello'.underline(:curly, 'ff9900')
+    assert_equal "\e[4:2;58;5;100mhello\e[0m", 'hello'.underline(:double, 100)
+  end
+
+  def test_underline_invalid_style
+    assert_raises(ArgumentError) { 'hello'.underline(:wavy) }
+  end
+
+  def test_underline_invalid_color
+    assert_raises(ArgumentError) { 'hello'.underline(:curly, 'zzzzzz') }
+    assert_raises(ArgumentError) { 'hello'.underline(:curly, -1) }
+    assert_raises(ArgumentError) { 'hello'.underline(:curly, 256) }
+  end
+
+  def test_underline_style_nesting_with_fg
+    # Styled underline nested inside fg color
+    inner = 'world'.underline(:curly)
+    result = "hello #{inner} end".fg(100)
+    assert_equal "\e[38;5;100mhello \e[4:3mworld\e[0m\e[38;5;100m end\e[0m", result
+  end
+
+  def test_underline_color_nesting_with_fg
+    inner = 'world'.underline(:curly, 196)
+    result = "hello #{inner} end".fg(100)
+    assert_equal "\e[38;5;100mhello \e[4:3;58;5;196mworld\e[0m\e[38;5;100m end\e[0m", result
+  end
+
+  def test_underline_disabled_mode
+    Ansi256.enabled = false
+    assert_equal 'hello', 'hello'.underline
+    assert_equal 'hello', 'hello'.underline(:curly)
+    assert_equal 'hello', 'hello'.underline(:curly, 'ff9900')
+    assert_equal 'hello', 'hello'.underline(214)
+    Ansi256.enabled = true
+  end
+
+  def test_underline_module_method_with_style
+    assert_equal "\e[4:3mhello\e[0m", Ansi256.underline('hello', :curly)
+    assert_equal "\e[4:3;58;2;255;153;0mhello\e[0m", Ansi256.underline('hello', :curly, 'ff9900')
+    assert_equal "\e[58;5;214;4mhello\e[0m", Ansi256.underline('hello', 214)
+  end
+
+  def test_underline_named_color
+    # Named color as sole argument (basic underline + color)
+    assert_equal "\e[58;5;1;4mhello\e[0m", 'hello'.underline(:red)
+    assert_equal "\e[58;5;4;4mhello\e[0m", 'hello'.underline(:blue)
+    assert_equal "\e[58;5;0;4mhello\e[0m", 'hello'.underline(:black)
+    assert_equal "\e[58;5;7;4mhello\e[0m", 'hello'.underline(:white)
+
+    # Named color as second argument (style + color)
+    assert_equal "\e[4:3;58;5;1mhello\e[0m", 'hello'.underline(:curly, :red)
+    assert_equal "\e[4:2;58;5;4mhello\e[0m", 'hello'.underline(:double, :blue)
+
+    # Swapped order: color first, style second
+    assert_equal "\e[4:3;58;5;1mhello\e[0m", 'hello'.underline(:red, :curly)
+    assert_equal "\e[4:2;58;5;4mhello\e[0m", 'hello'.underline(:blue, :double)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ansi256
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Junegunn Choi
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Colorize text using 256-color ANSI codes
 test_files: