ansi256 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf28c245bf8d2c7a888e05572ea1270a590bd2c0a906e37171099388ff4eb3a3
-  data.tar.gz: 1e5e1531cd270090d5ccaf931774f4d0cc54afbe2f0e1ba2d298829f5c5de651
+  metadata.gz: 5390f3352df81912c5dfb618a66256f8f41b21fab087748185b313a7f09913b3
+  data.tar.gz: a8bf49a8391b3b5221611026505fa27451a5a683526763776ad0d9344bf4f7f8
 SHA512:
-  metadata.gz: a4209529d49b0ce7ef7acdbfd7072264840c276502281bef42944fe07609828ca02de4b3542d4fafc68f0cfaeb7ef17ddfef24db5fcdcd5e2b12f13caf1723f6
-  data.tar.gz: 59462bdc1e6c8072957674d8fcf7548a0eb20c76cf7021f82a6bffdb93befd7012704991f9190cac4b7587bd27eb1b9b62142a7246d9176cd0e07c1ac5a16686
+  metadata.gz: 2078048aa2d6064a9f3886de024c485c12e266dc9bc37f0fc69ea95be98e6371e2e3e183c3ca357fc1fcc6a543070217cdc109b2c81d973f583e444f318af8e1
+  data.tar.gz: 9c7011943787d75ee81005820f1521317c869aa922136d5c6d0be5fc50070ddcb87ad324f698cf1c7a54656b5584505d706b3b994f06586f99ed683f47f519b9

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

@@ -1,28 +1,38 @@
 module Ansi256
   CODE = {
-    :reset      => 0,
-    :bold       => 1,
-    :dim        => 2,
-    :italic     => 3,
-    :underline  => 4,
+    reset: 0,
+    bold: 1,
+    dim: 2,
+    italic: 3,
+    underline: 4,
+    inverse: 7,
+    strikethrough: 9,
 
-    :black      => 30,
-    :red        => 31,
-    :green      => 32,
-    :yellow     => 33,
-    :blue       => 34,
-    :magenta    => 35,
-    :cyan       => 36,
-    :white      => 37,
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
 
-    :on_black   => 40,
-    :on_red     => 41,
-    :on_green   => 42,
-    :on_yellow  => 43,
-    :on_blue    => 44,
-    :on_magenta => 45,
-    :on_cyan    => 46,
-    :on_white   => 47,
+    on_black: 40,
+    on_red: 41,
+    on_green: 42,
+    on_yellow: 43,
+    on_blue: 44,
+    on_magenta: 45,
+    on_cyan: 46,
+    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[

data/lib/ansi256/mixin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ansi256
   class << self
     def enabled= bool
@@ -25,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
@@ -56,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
@@ -72,4 +86,3 @@ module Ansi256
     end
   end
 end
-

data/lib/ansi256/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ansi256
-  VERSION = "0.4.0"
+  VERSION = '0.6.0'
 end

data/lib/ansi256.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'ansi256/version'
 require 'ansi256/code'
@@ -5,29 +7,39 @@ require 'ansi256/mixin'
 
 module Ansi256
   class << self
-    def fg code, str = nil
+    attr_accessor :truecolor
+
+    def fg(code, str = nil)
       if str
         wrap str, Ansi256.fg(code)
       elsif NAMED_COLORS.include?(code)
         "\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
     end
 
-    def bg code, str = nil
+    def bg(code, str = nil)
       if str
         wrap str, Ansi256.bg(code)
       elsif NAMED_COLORS.include?(code)
         "\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
@@ -43,94 +55,232 @@ module Ansi256
       end
     end
 
-    def plain str
+    # Override underline to support 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/.freeze
-    MULTI_PATTERN = /(?:\e\[[0-9;]+m)+/.freeze
-    EMPTY_TRIPLE  = [nil, nil, Set.new].freeze
+    private
+
+    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
 
-    def ansify prev, curr
+      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
-      rgb = $1
+    def parse_rgb(code)
+      return unless code.is_a?(String) &&
+                    code =~ /^#?([0-9a-f]+)$/i
+
+      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 wrap str, color
-      current = [nil, nil, Set.new]
+    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, nil, nil, Set.new]
 
-      (color + str.gsub(PATTERN) { |m|
-        if m =~ /\e\[[^m]*\b0m/
+      (color + str.gsub(PATTERN) do |m|
+        if m == "\e[0m"
           m + color
         else
           m
         end
-      } << reset).gsub(MULTI_PATTERN) { |ansi|
+      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
             ''
           end + ansify(prev, current)
         end
-      }
+      end
     end
   end
 end
 
 Ansi256.enabled = true
+Ansi256.truecolor = true

data/test/test_ansi256.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 $VERBOSE = true
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 require 'ansi256'
 require 'minitest/autorun'
 
 class TestAnsi256 < Minitest::Test
-  def cfmt col
+  def cfmt(col)
     col.to_s.rjust(5).fg(232).bg(col)
   end
 
@@ -28,40 +30,40 @@ class TestAnsi256 < Minitest::Test
 
   def test_nesting_hello_world
     # Nesting
-    puts world = "World".bg(226).fg(232).underline
+    puts world = 'World'.bg(226).fg(232).underline
     puts hello = "Hello #{world} !".fg(230).bg(75)
     puts say_hello_world = "Say '#{hello}'".fg(30)
     puts say_hello_world.plain.fg(27)
   end
 
   def test_nesting_hello_world2
-    puts world = "World".bg(226).blue.underline
+    puts world = 'World'.bg(226).blue.underline
     puts hello = "Hello #{world} Hello".white.bold
     puts say_hello_world = "Say '#{hello}'".fg(30).underline
     puts say_hello_world.plain.fg(27)
   end
 
   def test_nesting_hello_world3
-    puts world = "World".blue.underline
+    puts world = 'World'.blue.underline
     puts hello = "Hello #{world} Hello".blue.bold
     puts say_hello_world = "Say '#{hello}'".fg(30).underline
     puts say_hello_world.plain.fg(27)
   end
 
   def test_named_colors
-    s = "Colorize me"
-    puts [ s.black,   s.black.bold,   s.white.bold.on_black   ].join ' '
-    puts [ s.red,     s.red.bold,     s.white.bold.on_red     ].join ' '
-    puts [ s.green,   s.green.bold,   s.white.bold.on_green   ].join ' '
-    puts [ s.yellow,  s.yellow.bold,  s.white.bold.on_yellow  ].join ' '
-    puts [ s.blue,    s.blue.bold,    s.white.bold.on_blue    ].join ' '
-    puts [ s.magenta, s.magenta.bold, s.white.bold.on_magenta ].join ' '
-    puts [ s.cyan,    s.cyan.bold,    s.white.bold.on_cyan    ].join ' '
-    puts [ s.white,   s.white.bold,   s.white.bold.on_white   ].join ' '
+    s = 'Colorize me'
+    puts [s.black,   s.black.bold,   s.white.bold.on_black].join ' '
+    puts [s.red,     s.red.bold,     s.white.bold.on_red].join ' '
+    puts [s.green,   s.green.bold,   s.white.bold.on_green].join ' '
+    puts [s.yellow,  s.yellow.bold,  s.white.bold.on_yellow].join ' '
+    puts [s.blue,    s.blue.bold,    s.white.bold.on_blue].join ' '
+    puts [s.magenta, s.magenta.bold, s.white.bold.on_magenta].join ' '
+    puts [s.cyan,    s.cyan.bold,    s.white.bold.on_cyan].join ' '
+    puts [s.white,   s.white.bold,   s.white.bold.on_white].join ' '
   end
 
   def test_named_color_code_with_fg_bg
-    puts "Colorize me".fg(:green).bg(:red).bold.underline
+    puts 'Colorize me'.fg(:green).bg(:red).bold.underline
   end
 
   def test_just_code
@@ -70,6 +72,8 @@ class TestAnsi256 < Minitest::Test
     assert_equal "\e[2m", Ansi256.dim
     assert_equal "\e[3m", Ansi256.italic
     assert_equal "\e[4m", Ansi256.underline
+    assert_equal "\e[7m", Ansi256.inverse
+    assert_equal "\e[9m", Ansi256.strikethrough
 
     assert_equal "\e[30m", Ansi256.black
     assert_equal "\e[31m", Ansi256.red
@@ -130,21 +134,100 @@ class TestAnsi256 < Minitest::Test
 
     assert_equal "\e[38;5;100mHello\e[38;5;200m world\e[0m", "#{'Hello'.fg(100)} world".fg(200)
     assert_equal "\e[38;5;200;4mWow \e[38;5;100mhello\e[38;5;200m world\e[0m",
-      "Wow #{'hello'.fg(100)} world".fg(200).underline
+                 "Wow #{'hello'.fg(100)} world".fg(200).underline
     assert_equal "\e[38;5;200mWow \e[38;5;100;4mhello\e[0m\e[38;5;200m world\e[0m",
-      "Wow #{'hello'.fg(100).underline} world".fg(200)
+                 "Wow #{'hello'.fg(100).underline} world".fg(200)
     assert_equal "\e[38;5;200mWow \e[38;5;100;48;5;50;4mhello\e[0m\e[38;5;200m world\e[0m",
-      "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200)
+                 "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200)
     assert_equal "\e[38;5;200;48;5;250mWow \e[38;5;100;48;5;50;4mhello\e[0m\e[38;5;200;48;5;250m world\e[0m",
-      "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200).bg(250)
-    assert_equal "Wow hello world",
-      "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200).bg(250).plain
+                 "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200).bg(250)
+    assert_equal 'Wow hello world',
+                 "Wow #{'hello'.fg(100).underline.bg(50)} world".fg(200).bg(250).plain
 
     assert_equal "\e[32;48;5;200;1mWow \e[38;5;100;44;1;4mhello\e[0m\e[32;48;5;200;1m world\e[0m",
-      "Wow #{'hello'.fg(100).underline.on_blue} world".green.bold.bg(200)
+                 "Wow #{'hello'.fg(100).underline.on_blue} world".green.bold.bg(200)
   end
 
   def test_rgb
+    # Truecolor mode (default): 38;2;R;G;B
+    {
+      '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
+        print Ansi256.send(m, color, color + ' ')
+      end
+      (0..255).each do |r|
+        color = r.to_s(16).rjust(2, '0')
+        print Ansi256.send(m, color, color + ' ')
+      end
+    end
+    0.step(255, 20) do |r|
+      0.step(255, 20) do |g|
+        0.step(255, 20) do |b|
+          color = [r, g, b].map { |c| c.to_s(16).rjust(2, '0') }.join
+          print Ansi256.bg(color, color + ' ')
+        end
+      end
+    end
+    puts 'RGB Color'.fg('ff9900').bg('003366')
+    puts 'RGB Color'.fg('f90').bg('#036')
+    puts 'RGB Color'.fg('#ff9900').bg('#003366')
+    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,
@@ -157,7 +240,6 @@ class TestAnsi256 < Minitest::Test
       '22'     => 234,
       '202020' => 16,
       '222222' => 16,
-      '222222' => 16,
       'ff'     => 255,
       'ffffff' => 231,
       'FFFFFF' => 231,
@@ -173,46 +255,114 @@ class TestAnsi256 < Minitest::Test
       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
-    [:bg, :fg].each do |m|
-      (0..255).each do |r|
-        color = r.to_s(16).rjust(2, '0') * 3
-        print Ansi256.send(m, color, color + ' ')
-      end
-      (0..255).each do |r|
-        color = r.to_s(16).rjust(2, '0')
-        print Ansi256.send(m, color, color + ' ')
-      end
-    end
-    0.step(255, 20) do |r|
-      0.step(255, 20) do |g|
-        0.step(255, 20) do |b|
-          color = [r, g, b].map { |c| c.to_s(16).rjust(2, '0') }.join
-          print Ansi256.bg(color, color + ' ')
-        end
-      end
-    end
-    puts "RGB Color".fg('ff9900').bg('003366')
-    puts "RGB Color".fg('f90').bg('#036')
-    puts "RGB Color".fg('#ff9900').bg('#003366')
-    puts "RGB Color (Monochrome)".fg('ef').bg('3a')
+  ensure
+    Ansi256.truecolor = true
   end
 
   def test_enabled
     2.times do
-      [:fg, :bg].each do |m|
+      %i[fg bg].each do |m|
         assert Ansi256.enabled?
-        hello = "hello".send(m, 'f90')
+        hello = 'hello'.send(m, 'f90')
         assert_equal 'hello', hello.plain
 
         Ansi256.enabled = false
         assert !Ansi256.enabled?
-        assert hello.length > "hello".send(m, 'f90').length
+        assert hello.length > 'hello'.send(m, 'f90').length
         assert_equal 'hello', hello.plain
 
         Ansi256.enabled = true
         assert Ansi256.enabled?
-        assert_equal hello, "hello".send(m, 'f90')
+        assert_equal hello, 'hello'.send(m, 'f90')
       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,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ansi256
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Junegunn Choi
 bindir: bin
 cert_chain: []
-date: 2025-02-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Colorize text using 256-color ANSI codes
 test_files: