tint_me 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32acd1788229fa045285ea19649c993b0b4f9e59758ae92ec9a0eee630b58544
-  data.tar.gz: 89cfff7bc922b2fcbf876263b2a2b8dccf8762663bf15777e0b877f127d57553
+  metadata.gz: 194d04d6b9fdf4c668e84163bce1e59301ba84512f56ff856c1b7e0bc9674ee4
+  data.tar.gz: 47b341342f5074b594ca4d2c171bd20303f3ea52638cbb352cbab3bff34d31a2
 SHA512:
-  metadata.gz: 118fa5cf809036f4169c0b7e0832fa4a90c14d92298db7f3afac16bb70bd7855200f8bed0b600369c3163a1a1a2f7d7d91c619a265a3720b030020207aeeea67
-  data.tar.gz: dc3e91e45584ed1c353bc28cf8d095af7a429ed0873d5aa88ea4ed2cf5e289c1e3259ac3ef24806d2147a0d2451f31dd313a3b6da4cc2aaf511cd4f538558cfe
+  metadata.gz: 67ece923c3216024f8a9d7a9c22d37c212a9253bc0e1d8328f7281b8c43e2470defb07b815eccb63562f6ea3b663a1ced75889234d44e01f9250fc43de935b06
+  data.tar.gz: 54fa3e283c219cecccd9ed00fc4a20defd15b59dd4a114a04638f000f0d6e1a8b5fe2be0f72f5e5e890c571c42c02d08c90647da601b53a959c5b8e049331c81

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.1.0] - 2025-11-02
+
+### Added
+- **Positional Arguments Support**: New concise syntax for style creation
+  - Single color as positional argument: `TIntMe[:red]` sets foreground
+  - Two colors as positional arguments: `TIntMe[:red, :yellow]` sets foreground and background
+  - Boolean flags as positional arguments: `TIntMe[:bold, :italic]`
+  - Mixed usage: `TIntMe[:red, :yellow, :bold, background: :blue]`
+  - Support for all color formats: symbols, hex strings (with/without #, 3/6 digits)
+  - Maximum 2 color arguments allowed (3+ raises ArgumentError)
+  - Keyword arguments take precedence over positional arguments
+- Type safety with dry-types `PositionalArgumentsArray` validation
+- Comprehensive test coverage for all positional argument scenarios
+
+### Development
+- Improved release workflow branch cleanup with existence check
+
 ## [1.0.0] - 2025-09-09
 
 ### Added

data/README.md

@@ -1,5 +1,11 @@
 # :lipstick: TIntMe! :nail_care:
 
+[![Gem Version](https://badge.fury.io/rb/tint_me.svg)](https://badge.fury.io/rb/tint_me)
+[![CI](https://github.com/sakuro/tint_me/workflows/CI/badge.svg)](https://github.com/sakuro/tint_me/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Gem Downloads](https://img.shields.io/gem/dt/tint_me.svg)](https://rubygems.org/gems/tint_me)
+[![Depfu](https://badges.depfu.com/badges/aec4d0a2094c04935f1db813351e5f56/overview.svg)](https://depfu.com/github/sakuro/tint_me)
+
 A Ruby library for terminal text styling with ANSI colors and effects. TIntMe! provides an elegant and composable API for applying colors, text decorations, and formatting to terminal output.
 
 ## Features
@@ -10,7 +16,7 @@ A Ruby library for terminal text styling with ANSI colors and effects. TIntMe! p
 - **Type Safety**: Comprehensive argument validation using dry-schema and dry-types
 - **Immutable Design**: All style operations return new instances, making them safe for concurrent use
 - **Zeitwerk Integration**: Automatic loading with proper module organization
-- **Comprehensive API**: Both explicit `Style.new` and convenient `TIntMe[]` shortcut syntax
+- **Positional Arguments**: Concise syntax with `TIntMe[:red, :bold]` for streamlined styling
 
 ## Installation
 
@@ -36,11 +42,13 @@ gem install tint_me
 
 ### Basic Styling
 
+TIntMe supports both keyword arguments and positional arguments for creating styles. Here are examples using keyword arguments:
+
 ```ruby
 require 'tint_me'
 
-# Create a style
-red_style = TIntMe::Style.new(foreground: :red)
+# Create a style with keyword arguments
+red_style = TIntMe[foreground: :red]
 puts red_style.call("Hello World")
 
 # Using the shortcut syntax
@@ -48,37 +56,104 @@ blue_style = TIntMe[foreground: :blue, bold: true]
 puts blue_style["Hello World"]
 ```
 
+### Positional Arguments
+
+TIntMe supports a concise positional argument syntax for common styling scenarios:
+
+#### Supported Positional Arguments
+
+**Colors** (applied as foreground):
+- Color symbols: `:red`, `:green`, `:blue`, `:yellow`, `:magenta`, `:cyan`, `:white`, `:black`, `:gray`  
+- Bright colors: `:bright_red`, `:bright_green`, `:bright_blue`, etc.
+- Special values: `:default`, `:reset`
+- Hex strings: `"#FF0000"`, `"FF0000"`, `"#F00"`, `"F00"`
+
+**Boolean flags** (set to `true`):
+- `:bold`, `:faint`, `:italic`, `:underline`, `:overline`, `:blink`, `:inverse`, `:conceal`
+
+#### Behavior Rules
+
+```ruby
+# Two colors: first is foreground, second is background
+TIntMe[:red, :yellow]                        # => foreground: :red, background: :yellow
+
+# Too many colors: error
+TIntMe[:red, :blue, :green]                  # => ArgumentError: Too many color arguments
+
+# Duplicate flags: idempotent (no error)  
+TIntMe[:bold, :italic, :bold]                # => bold: true, italic: true
+
+# Keyword arguments override positional
+TIntMe[:red, foreground: :blue]              # => foreground: :blue
+TIntMe[:red, :yellow, background: :green]    # => foreground: :red, background: :green
+TIntMe[:bold, bold: false]                   # => bold: false
+
+# Mix freely for complex styling
+TIntMe[:red, :yellow, :bold, underline: :double]  # => foreground: :red, background: :yellow, bold: true, underline: :double
+```
+
 ### Color Options
 
 ```ruby
-# Standard colors
+# Standard colors (keyword arguments)
 TIntMe[foreground: :red]
 TIntMe[background: :yellow]
 
-# Hex colors (with or without #)
+# Standard colors (positional arguments)
+TIntMe[:red]                          # Foreground color
+TIntMe[:bright_blue]                  # Bright colors supported
+
+# Hex colors (keyword arguments)
 TIntMe[foreground: "#FF0000"]
 TIntMe[background: "#00FF00"]
 TIntMe[foreground: "FF0000"]
+
+# Hex colors (positional arguments)
+TIntMe["#FF0000"]                                    # 6-digit with hash
+TIntMe["FF0000"]                                     # 6-digit without hash
+TIntMe["#F00"]                                       # 3-digit with hash
+TIntMe["F00"]                                        # 3-digit without hash
+
+# Mix positional and keyword arguments
+TIntMe[:red, background: :yellow]                    # Red foreground, yellow background
+TIntMe["#00FF00", :bold, background: :black]         # Green foreground, bold, black background
 ```
 
 ### Text Effects
 
 ```ruby
-# Individual effects
+# Individual effects (keyword arguments)
 TIntMe[bold: true]
-TIntMe[faint: true]          # Faint/dim text
+TIntMe[faint: true]                   # Faint/dim text
 TIntMe[italic: true]
 TIntMe[underline: true]
-TIntMe[underline: :double]   # Double underline
-TIntMe[overline: true]       # Overline decoration
-TIntMe[blink: true]          # Blinking text
-TIntMe[inverse: true]        # Reverse colors
-TIntMe[conceal: true]        # Hidden/concealed text
-
-# Multiple effects
+TIntMe[underline: :double]            # Double underline
+TIntMe[overline: true]                # Overline decoration
+TIntMe[blink: true]                   # Blinking text
+TIntMe[inverse: true]                 # Reverse colors
+TIntMe[conceal: true]                 # Hidden/concealed text
+
+# Individual effects (positional arguments)
+TIntMe[:bold]                         # Bold text
+TIntMe[:italic]                       # Italic text
+TIntMe[:underline]                    # Underlined text
+
+# Multiple effects (keyword arguments)
 TIntMe[foreground: :green, bold: true, underline: true]
+
+# Multiple effects (positional arguments)
+TIntMe[:bold, :italic, :underline]                   # Multiple boolean flags
+TIntMe[:red, :bold, :italic]                         # Color + effects
+TIntMe[:red, :yellow, :bold, :italic]                # Foreground + background + effects
+TIntMe["#FF5733", :bold, :underline, :blink]         # Hex color + effects
+
+# Mixed approaches
+TIntMe[:bold, :italic, background: :yellow]          # Positional flags + keyword background
+TIntMe[:red, :yellow, underline: :double]            # Positional colors + keyword underline
+TIntMe[:red, :bold, background: :blue]               # Positional color/flag + keyword background
 ```
 
+
 ### Style Composition
 
 ```ruby
@@ -101,10 +176,13 @@ final = base >> emphasis >> TIntMe[background: :white]
 ```ruby
 # ✅ RECOMMENDED: Pre-compose and reuse
 ERROR_STYLE = TIntMe[foreground: :red] >> TIntMe[bold: true]
-ERROR_STYLE.call("Error message")  # Fast: ~4.8M operations/sec
+# OR using positional arguments (equivalent)
+ERROR_STYLE = TIntMe[:red] >> TIntMe[:bold]
+ERROR_STYLE.call("Error message")            # Fast: ~4.8M operations/sec
 
-# ❌ AVOID: Runtime composition  
+# ❌ AVOID: Runtime composition
 (TIntMe[foreground: :red] >> TIntMe[bold: true]).call("Error")  # Slow: ~0.01M ops/sec
+(TIntMe[:red] >> TIntMe[:bold]).call("Error")                   # Also slow: ~0.01M ops/sec
 ```
 
 **Key Guidelines:**
@@ -124,26 +202,27 @@ ERROR_STYLE.call("Error message")  # Fast: ~4.8M operations/sec
 ```ruby
 # Terminal UI frameworks with predefined styles
 UI_STYLES = {
-  error:   TIntMe[foreground: :red] >> TIntMe[bold: true],
-  success: TIntMe[foreground: :green] >> TIntMe[bold: true],
-  info:    TIntMe[foreground: :blue] >> TIntMe[italic: true]
+  error:   TIntMe[:red, :bold],                      # Concise positional syntax
+  success: TIntMe[foreground: :green, bold: true],   # Or keyword arguments
+  warning: TIntMe[:yellow] >> TIntMe[:bold],         # Or use composition (combining styles)
+  info:    TIntMe[:blue, :italic]
 }
 
 def show_error(msg)
-  puts UI_STYLES[:error].call(msg)  # Extremely fast: ~4.8M ops/sec
+  puts UI_STYLES[:error].call(msg)          # Extremely fast: ~4.8M ops/sec
 end
 ```
 
 **Consider alternatives for:**
 ```ruby
 # Dynamic styling (use Paint gem instead)
-texts.each { |text| Paint[text, :red, :bold] }  # ~2M ops/sec
+texts.each { |text| Paint[text, :red, :bold] }          # ~2M ops/sec
 
 # One-time styling with readable syntax (use Rainbow gem)
-puts Rainbow("Success").green.bold  # ~0.5M ops/sec
+puts Rainbow("Success").green.bold                      # ~0.5M ops/sec
 
 # Avoid with TIntMe - creates unnecessary overhead
-texts.each { |text| (red >> bold).call(text) }  # Only ~0.01M ops/sec
+texts.each { |text| (red >> bold).call(text) }          # Only ~0.01M ops/sec
 ```
 
 **Design Philosophy:**
@@ -157,14 +236,14 @@ style = TIntMe[foreground: :red, bold: true]
 # All of these are equivalent
 puts style.call("Hello")
 puts style["Hello"]
-puts style.("Hello")  # Callable syntax
+puts style.("Hello")                  # Callable syntax
 ```
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb` and update the CHANGELOG.md, then create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org). However, there are GitHub Actions workflows set up to automate these processes, so please use those instead. See `RELEASING.md` for details.
 
 ## Contributing
 

data/lib/tint_me/sgr_builder.rb

@@ -97,7 +97,7 @@ module TIntMe
     #   prefix_codes(foreground: :red, bold: true)
     #   # => "\e[31;1m"
     #
-    # @example 256-color RGB (true color)
+    # @example RGB true color (24-bit)
     #   prefix_codes(foreground: "#FF6B35", background: "#F7931E")
     #   # => "\e[38;2;255;107;53;48;2;247;147;30m"
     #

data/lib/tint_me/style/types.rb

@@ -45,6 +45,27 @@ module TIntMe
 
       UnderlineOption = (Bool | Symbol.enum(:double, :reset)).optional
       public_constant :UnderlineOption
+
+      # Boolean flags that can be used as positional arguments
+      BooleanFlagSymbol = Symbol.enum(
+        :bold,
+        :faint,
+        :italic,
+        :underline,
+        :overline,
+        :blink,
+        :inverse,
+        :conceal
+      )
+      public_constant :BooleanFlagSymbol
+
+      # Valid positional arguments (color symbols + hex strings + boolean flags)
+      PositionalArgument = ColorSymbol | ColorString | BooleanFlagSymbol
+      public_constant :PositionalArgument
+
+      # Array of positional arguments for validation
+      PositionalArgumentsArray = Array.of(PositionalArgument)
+      public_constant :PositionalArgumentsArray
     end
   end
 end

data/lib/tint_me/style.rb

@@ -42,6 +42,70 @@ module TIntMe
   #     # ... other boolean effects: overline, blink, conceal
   #   )
   class Style
+    # Module to extend constructor with positional argument support
+    # @api private
+    module ConstructorExtensions
+      # Normalize positional and keyword arguments for Style construction
+      # @param args [Array] Positional arguments (colors and boolean flags)
+      # @param kwargs [Hash] Keyword arguments
+      # @return [Hash] Normalized keyword arguments
+      # @api private
+      def normalize_constructor_args(*args, **kwargs)
+        # Validate all positional arguments at once using array validation
+        Types::PositionalArgumentsArray[args] unless args.empty?
+
+        # Now normalize the positional arguments
+        normalized = kwargs.dup
+        colors = []
+
+        args.each do |arg|
+          # Determine if it's a color or a boolean flag
+          if Types::ColorSymbol.valid?(arg) || Types::ColorString.valid?(arg)
+            # Color argument - collect up to 2 colors
+            colors << arg
+          elsif Types::BooleanFlagSymbol.valid?(arg)
+            # Boolean flag - set to true (idempotent)
+            normalized[arg] = true unless normalized.key?(arg)
+          end
+        end
+
+        # Validate maximum 2 colors
+        if colors.length > 2
+          raise ArgumentError, "Too many color arguments (maximum 2 allowed, got #{colors.length})"
+        end
+
+        # Apply colors if specified (keyword arguments take precedence)
+        if colors.length >= 1 && !normalized.key?(:foreground)
+          normalized[:foreground] = colors[0]
+        end
+        if colors.length == 2 && !normalized.key?(:background)
+          normalized[:background] = colors[1]
+        end
+
+        normalized
+      rescue Dry::Types::CoercionError => e
+        # Extract the invalid argument from the error for a cleaner message
+        raise ArgumentError, "Invalid positional argument(s): #{e.message}"
+      end
+
+      # Override new to support positional arguments
+      def new(*args, **)
+        return super(**) if args.empty?
+
+        super(**normalize_constructor_args(*args, **))
+      end
+
+      # Override [] to support positional arguments
+      def [](*args, **)
+        return super(**) if args.empty?
+
+        super(**normalize_constructor_args(*args, **))
+      end
+    end
+
+    # Apply the constructor extensions to the singleton class
+    singleton_class.prepend ConstructorExtensions
+
     # Returns the singleton instance of SGRBuilder
     # @return [SGRBuilder] The SGR builder instance
     # @api private
@@ -96,6 +160,11 @@ module TIntMe
     # @example Valid usage
     #   Style.new(foreground: :red, bold: true)
     #   Style.new(underline: :double, background: "#FF0000")
+    # @example Positional arguments
+    #   Style.new(:red, :bold, :italic)          # foreground: :red, bold: true, italic: true
+    #   Style.new(:red, :yellow, :bold)          # foreground: :red, background: :yellow, bold: true
+    #   Style.new("#FF0000", "#00FF00")          # foreground: "#FF0000", background: "#00FF00"
+    #   Style[:blue, :bold]                      # foreground: :blue, bold: true
     # @example Invalid usage (raises ArgumentError)
     #   Style.new(foreground: 123)        # Invalid color type
     #   Style.new(bold: "true")           # Invalid boolean type

data/lib/tint_me/version.rb

@@ -3,6 +3,6 @@
 module TIntMe
   # Current version of the TIntMe gem
   # @return [String] The semantic version string
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
   public_constant :VERSION
 end

data/sig/dry-schema.rbs

@@ -0,0 +1,8 @@
+module Dry
+  module Schema
+    class Processor
+    end
+
+    def self.define: () { () -> void } -> Processor
+  end
+end

data/sig/dry-types.rbs

@@ -0,0 +1,11 @@
+module Dry
+  module Types
+    class Type
+    end
+
+    class Constructor < Type
+    end
+  end
+
+  def self.Types: () -> Module
+end

data/sig/tint_me/error.rbs

@@ -0,0 +1,4 @@
+module TIntMe
+  class Error < StandardError
+  end
+end

data/sig/tint_me/sgr_builder.rbs

@@ -0,0 +1,60 @@
+module TIntMe
+  class SGRBuilder
+    ESC: String
+    CSI: String
+    SGR_END: String
+    RESET_CODE: String
+    COLORS: Hash[Symbol, Integer]
+    EFFECTS: Hash[Symbol, Integer]
+
+    def self.instance: () -> SGRBuilder
+
+    private
+
+    def self.new: () -> void
+
+    public
+
+    def prefix_codes: (
+      ?foreground: (Symbol | String)?,
+      ?background: (Symbol | String)?,
+      ?bold: bool?,
+      ?faint: bool?,
+      ?italic: bool?,
+      ?underline: (bool | :double)?,
+      ?blink: bool?,
+      ?inverse: bool?,
+      ?conceal: bool?,
+      ?overline: bool?
+    ) -> String
+
+    def reset_code: () -> String
+
+    private
+
+    def rgb_to_sgr: (Integer red, Integer green, Integer blue, ?background: bool) -> String
+
+    def build_parameters: (
+      foreground: (Symbol | String)?,
+      background: (Symbol | String)?,
+      bold: bool?,
+      faint: bool?,
+      italic: bool?,
+      underline: (bool | :double)?,
+      blink: bool?,
+      inverse: bool?,
+      conceal: bool?,
+      overline: bool?
+    ) -> Array[Integer | String]
+
+    def process_foreground_color: (Symbol | String foreground) -> (Integer | String)
+
+    def process_background_color: (Symbol | String background) -> (Integer | String)
+
+    def build_sgr_sequence: (Array[Integer | String] parameters) -> String
+
+    def hex_color?: (String value) -> bool
+
+    def hex_to_rgb: (String hex) -> [Integer, Integer, Integer]
+  end
+end

data/sig/tint_me/style/schema.rbs

@@ -0,0 +1,5 @@
+module TIntMe
+  class Style
+    Schema: Dry::Schema::Processor
+  end
+end

data/sig/tint_me/style/types.rbs

@@ -0,0 +1,14 @@
+module TIntMe
+  class Style
+    module Types
+      ColorSymbol: Dry::Types::Type
+      ColorString: Dry::Types::Type
+      Color: Dry::Types::Type
+      BooleanOption: Dry::Types::Type
+      UnderlineOption: Dry::Types::Type
+      BooleanFlagSymbol: Dry::Types::Type
+      PositionalArgument: Dry::Types::Type
+      PositionalArgumentsArray: Dry::Types::Type
+    end
+  end
+end

data/sig/tint_me/style.rbs

@@ -0,0 +1,73 @@
+module TIntMe
+  class Style
+    type color_value = :default | :reset | :black | :red | :green | :yellow | :blue | :magenta | :cyan | :white | :gray | :bright_black | :bright_red | :bright_green | :bright_yellow | :bright_blue | :bright_magenta | :bright_cyan | :bright_white | String
+    type boolean_value = bool | :reset
+    type underline_value = bool | :double | :reset
+    type positional_arg = color_value | :bold | :faint | :italic | :underline | :overline | :blink | :inverse | :conceal
+    type attribute_value = color_value? | boolean_value? | underline_value?
+
+    attr_reader foreground: color_value?
+    attr_reader background: color_value?
+    attr_reader inverse: boolean_value?
+    attr_reader bold: boolean_value?
+    attr_reader faint: boolean_value?
+    attr_reader underline: underline_value?
+    attr_reader overline: boolean_value?
+    attr_reader blink: boolean_value?
+    attr_reader italic: boolean_value?
+    attr_reader conceal: boolean_value?
+
+    def self.sgr_builder: () -> SGRBuilder
+
+    def self.new: (
+      *positional_arg args,
+      ?foreground: color_value?,
+      ?background: color_value?,
+      ?inverse: boolean_value?,
+      ?bold: boolean_value?,
+      ?faint: boolean_value?,
+      ?underline: underline_value?,
+      ?overline: boolean_value?,
+      ?blink: boolean_value?,
+      ?italic: boolean_value?,
+      ?conceal: boolean_value?
+    ) -> Style
+
+    def self.[]: (
+      *positional_arg args,
+      ?foreground: color_value?,
+      ?background: color_value?,
+      ?inverse: boolean_value?,
+      ?bold: boolean_value?,
+      ?faint: boolean_value?,
+      ?underline: underline_value?,
+      ?overline: boolean_value?,
+      ?blink: boolean_value?,
+      ?italic: boolean_value?,
+      ?conceal: boolean_value?
+    ) -> Style
+
+    def initialize: (
+      ?foreground: color_value?,
+      ?background: color_value?,
+      ?inverse: boolean_value?,
+      ?bold: boolean_value?,
+      ?faint: boolean_value?,
+      ?underline: underline_value?,
+      ?overline: boolean_value?,
+      ?blink: boolean_value?,
+      ?italic: boolean_value?,
+      ?conceal: boolean_value?
+    ) -> void
+
+    def call: (String text) -> String
+
+    alias [] call
+
+    def >>: (Style other) -> Style
+
+    private
+
+    def compose_attribute: (attribute_value current, attribute_value other) -> attribute_value
+  end
+end

data/sig/tint_me.rbs

@@ -1,8 +1,8 @@
 module TIntMe
   VERSION: String
 
-  # Creates a new Style instance with the given options
   def self.[]: (
+    *Style::positional_arg args,
     ?foreground: Style::color_value?,
     ?background: Style::color_value?,
     ?bold: Style::boolean_value?,
@@ -14,48 +14,4 @@ module TIntMe
     ?inverse: Style::boolean_value?,
     ?conceal: Style::boolean_value?
   ) -> Style
-
-  class Style
-    type color_value = :red | :green | :blue | :cyan | :yellow | :magenta | :gray | :white | :black | :default | :reset | String
-    type underline_value = bool | :double | :reset
-    type boolean_value = bool | :reset
-    type style_attribute = :red | :green | :blue | :cyan | :yellow | :magenta | :gray | :white | :black |
-                          :underline | :double_underline | :overline | :bold | :faint | :blink | :italic | :inverse | :conceal |
-                          String | nil
-
-    attr_reader foreground: color_value?
-    attr_reader background: color_value?
-    attr_reader bold: boolean_value?
-    attr_reader faint: boolean_value?
-    attr_reader italic: boolean_value?
-    attr_reader underline: underline_value?
-    attr_reader overline: boolean_value?
-    attr_reader blink: boolean_value?
-    attr_reader inverse: boolean_value?
-    attr_reader conceal: boolean_value?
-
-    def initialize: (
-      ?foreground: color_value?,
-      ?background: color_value?,
-      ?bold: boolean_value?,
-      ?faint: boolean_value?,
-      ?italic: boolean_value?,
-      ?underline: underline_value?,
-      ?overline: boolean_value?,
-      ?blink: boolean_value?,
-      ?inverse: boolean_value?,
-      ?conceal: boolean_value?
-    ) -> void
-
-    def call: (String text) -> String
-
-    alias [] call
-
-    def >>: (Style other) -> Style
-
-    private
-
-    def compose_attribute: ((color_value | underline_value | boolean_value)?, (color_value | underline_value | boolean_value)?) -> (color_value | underline_value | boolean_value)?
-
-  end
 end