# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "zeitwerk"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            Zeitwerk::Loader.new.then do |loader|
          
        
      
        

          

            
              1
            

            
              
            

              loader.ignore "#{__dir__}/tone/rspec"
          
        
      
        

          

            
              1
            

            
              
            

              loader.tag = File.basename __FILE__, ".rb"
          
        
      
        

          

            
              1
            

            
              
            

              loader.push_dir __dir__
          
        
      
        

          

            
              1
            

            
              
            

              loader.setup
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            
              1
            

            
              
            

              DEFAULTS = Configuration::Loader.new.call
          
        
      
        

          

            
              1
            

            
              
            

              CONTAINER = {defaults: DEFAULTS, aliaser: Aliaser, encoder: Encoder, decoder: Decoder}.freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.loader registry = Zeitwerk::Registry
          
        
      
        

          

            
              4
            

            
              
            

                @loader ||= registry.loaders.each.find { |loader| loader.tag == File.basename(__FILE__, ".rb") }
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.new(...) = Client.new(...)
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            

            
              
            

              # Allows storage of custom custom which can be referenced when colorizing text.
          
        
      
        

          

            
              1
            

            
              
            

              class Aliaser
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :defaults
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize defaults: DEFAULTS
          
        
      
        

          

            
              90
            

            
              
            

                  @defaults = defaults
          
        
      
        

          

            
              90
            

            
              
            

                  @custom = {}
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get key
          
        
      
        

          

            
              60
            

            
              
            

                  symbol = String(key).to_sym
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              60
            

            
              
            

                  custom.fetch symbol do
          
        
      
        

          

            
              55
            

            
              
                
                  then: 51
                
              
                
                  else: 4
                
              
            

                    return key if defaults.key? symbol
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                    usage = defaults.keys.append(*custom.keys).to_usage "and/or"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                    fail Error, "Invalid alias or default: #{key.inspect}. Use: #{usage}."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def add(key, *styles)
          
        
      
        

          

            
              25
            

            
              
                
                  then: 2
                
              
                
                  else: 23
                
              
            

                  fail Error, "Alias must have styles: #{key.inspect}." if styles.tap(&:compact!).empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              23
            

            
              
            

                  custom[key.to_sym] = validate key, styles.map(&:to_sym)
          
        
      
        

          

            
              21
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def to_h = custom.dup
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :custom
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def validate key, styles
          
        
      
        

          

            
              23
            

            
              
            

                  check_duplicate key
          
        
      
        

          

            
              61
            

            
              
            

                  styles.each { |style| check_style key, style }
          
        
      
        

          

            
              21
            

            
              
            

                  styles
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def check_duplicate key
          
        
      
        

          

            
              23
            

            
              
                
                  then: 1
                
              
                
                  else: 22
                
              
            

                  fail Error, "Alias mustn't duplicate (override) default: #{key.inspect}." if defaults.key? key
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def check_style key, style
          
        
      
        

          

            
              39
            

            
              
            

                  defaults.fetch style do
          
        
      
        

          

            
              1
            

            
              
            

                    usage = defaults.keys.to_usage "and/or"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    fail Error, "Invalid style (#{style.inspect}) for key (#{key.inspect}). Use: #{usage}."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            

            
              
            

              # The primary interface for working with colorized text.
          
        
      
        

          

            
              1
            

            
              
            

              class Client
          
        
      
        

          

            
              1
            

            
              
            

                def initialize enabled: $stdout.tty?, container: Tone::CONTAINER
          
        
      
        

          

            
              21
            

            
              
            

                  @aliaser = container.fetch(:aliaser).new defaults: container.fetch(:defaults)
          
        
      
        

          

            
              21
            

            
              
            

                  @encoder = container.fetch(:encoder).new(aliaser:, enabled:)
          
        
      
        

          

            
              21
            

            
              
            

                  @decoder = container.fetch(:decoder).new defaults: aliaser.defaults
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def defaults = aliaser.defaults
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def aliases = aliaser.to_h
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def add_alias(...)
          
        
      
        

          

            
              4
            

            
              
            

                  aliaser.add(...)
          
        
      
        

          

            
              4
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def get_alias(...) = aliaser.get(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def encode(...) = encoder.call(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias [] encode
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def decode(...) = decoder.call(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def find_code(key) = defaults[key]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def find_codes(*keys) = defaults.values_at(*keys)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def find_symbol(code) = defaults.invert[code]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def find_symbols(*codes) = defaults.invert.values_at(*codes)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def inspect = %(#<#{self.class} @encoder=#{encoder} @decoder=#{decoder} @aliaser=#{aliaser})
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :aliaser, :encoder, :decoder
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "pathname"
          
        
      
        

          

            
              1
            

            
              
            

            require "yaml"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            
              1
            

            
              
            

              module Configuration
          
        
      
        

          

            

            
              
            

                # Loads the default configuration into memory as a frozen hash.
          
        
      
        

          

            
              1
            

            
              
            

                class Loader
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize path = Pathname("#{__dir__}/defaults.yml")
          
        
      
        

          

            
              3
            

            
              
            

                    @path = path
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call = YAML.safe_load_file path, symbolize_names: true, freeze: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :path
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "strscan"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            

            
              
            

              # Decodes color encoded text into metadata (hash).
          
        
      
        

          

            
              1
            

            
              
            

              class Decoder
          
        
      
        

          

            
              1
            

            
              
            

                PATTERN = /
          
        
      
        

          

            

            
              
            

                  \e\[              # Start.
          
        
      
        

          

            

            
              
            

                  (?<codes>[\d;]+)  # Style codes.
          
        
      
        

          

            

            
              
            

                  m                 # Start suffix.
          
        
      
        

          

            

            
              
            

                  (?<text>.+?)      # Lazy text.
          
        
      
        

          

            

            
              
            

                  \e\[0m            # Stop.
          
        
      
        

          

            

            
              
            

                /mx
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize pattern: PATTERN, defaults: DEFAULTS, client: StringScanner
          
        
      
        

          

            
              33
            

            
              
            

                  @pattern = pattern
          
        
      
        

          

            
              33
            

            
              
            

                  @defaults = defaults
          
        
      
        

          

            
              33
            

            
              
            

                  @client = client
          
        
      
        

          

            
              33
            

            
              
            

                  @prefix_pattern = /.*#{pattern}/m
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def call(text) = scan client.new(text.to_s)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :pattern, :defaults, :client, :prefix_pattern
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def scan scanner, collection: []
          
        
      
        

          

            
              13
            

            
              
                
                  body: 20
                
              
            

                  until scanner.eos?
          
        
      
        

          

            
              20
            

            
              
            

                    match = scanner.scan_until pattern
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              20
            

            
              
                
                  else: 17
                
              
                
                  then: 3
                
              
            

                    return collection.append [scanner.string[scanner.rest]] unless match
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17
            

            
              
            

                    normal = scanner.pre_match.sub prefix_pattern, ""
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17
            

            
              
                
                  else: 8
                
              
                
                  then: 9
                
              
            

                    collection << [normal] unless normal.empty?
          
        
      
        

          

            
              17
            

            
              
            

                    collection << extract_captures(scanner)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                  collection
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def extract_captures scanner
          
        
      
        

          

            
              17
            

            
              
            

                  codes, text = scanner.captures
          
        
      
        

          

            
              17
            

            
              
            

                  [text, *symbolize(codes)]
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def symbolize(codes) = defaults.invert.values_at(*String(codes).split(";").map(&:to_i))
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            

            
              
            

              # Encodes plain text as colorized text.
          
        
      
        

          

            
              1
            

            
              
            

              class Encoder
          
        
      
        

          

            
              1
            

            
              
            

                using Refinements::Array
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize aliaser: Aliaser.new, enabled: $stdout.tty?
          
        
      
        

          

            
              71
            

            
              
            

                  @aliaser = aliaser
          
        
      
        

          

            
              71
            

            
              
            

                  @enabled = enabled
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def call(text, *styles)
          
        
      
        

          

            
              53
            

            
              
                
                  then: 2
                
              
                
                  else: 51
                
              
            

                  return "" if String(text).empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              51
            

            
              
                
                  then: 3
                
              
                
                  else: 48
                
              
            

                  !enabled || styles.tap(&:compact!).empty? ? text : "#{start(*styles)}#{text}#{stop}"
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :aliaser, :enabled
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def start(*styles) = %(\e[#{escape(*styles)}m)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def stop = "\e[#{defaults.fetch :clear}m"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def escape(*styles)
          
        
      
        

          

            
              100
            

            
              
            

                  styles.reduce([]) { |expansion, key| expansion.append(*aliaser.get(key)) }
          
        
      
        

          

            
              53
            

            
              
            

                        .map { |key| defaults[key.to_sym] }
          
        
      
        

          

            

            
              
            

                        .join ";"
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def defaults = aliaser.defaults
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Tone
          
        
      
        

          

            

            
              
            

              # Root error class for gem.
          
        
      
        

          

            
              1
            

            
              
            

              class Error < StandardError
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end