ruby-ansi-formatter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b078adce12fac81b76b16aa90260a235bf855f2082ffd1a268fa7cd8abff7eb
+  data.tar.gz: c00bbaf68b69b8ea0f807a91541e6ca5db5caf29a7e0ce8c25b3cbb8471fc803
+SHA512:
+  metadata.gz: c0e0503b5d526dddc7a440565d2a64700e7d890af38d7b50d13ae780f0a35dce16144c99d4226b7ec8a00556ffc49d40bad9edc00daa9172a1b5e002f17f2b32
+  data.tar.gz: '08459dcc670e3c0d58dc71a6c0f8dabd35ef3618eededa7ec3ddb5e756f58e8357d0a1d82de70ab328ec75abb6f04b6fb8c29a7335795e1b6d5249cf50ed5e43'

data/lib/ansi.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+# Helpers for wrapping text in ANSI escape codes and expanding inline DSL tokens.
+module Ansi
+  NAME = "ruby-ansi-formatter"
+  VERSION = "0.1.0"
+
+  # Maps public formatter names to their DSL prefixes and ANSI escape codes.
+  FORMATS = {
+    reset: {
+      prefix: "R",
+      code: "\e[0m",
+    },
+    bold: {
+      prefix: "B",
+      code: "\e[1m",
+    },
+    dim: {
+      prefix: "D",
+      code: "\e[2m",
+    },
+    italic: {
+      prefix: "I",
+      code: "\e[3m",
+    },
+    underline: {
+      prefix: "U",
+      code: "\e[4m",
+    },
+    invert: {
+      prefix: "X",
+      code: "\e[7m",
+    },
+    hidden: {
+      prefix: "H",
+      code: "\e[8m",
+    },
+    strikethrough: {
+      prefix: "S",
+      code: "\e[9m",
+    },
+    double_underline: {
+      prefix: "DU",
+      code: "\e[21m",
+    },
+    overline: {
+      prefix: "OV",
+      code: "\e[53m",
+    },
+    red: {
+      prefix: "r",
+      code: "\e[31m",
+    },
+    green: {
+      prefix: "g",
+      code: "\e[32m",
+    },
+    yellow: {
+      prefix: "y",
+      code: "\e[33m",
+    },
+    blue: {
+      prefix: "b",
+      code: "\e[34m",
+    },
+    magenta: {
+      prefix: "m",
+      code: "\e[35m",
+    },
+    cyan: {
+      prefix: "c",
+      code: "\e[36m",
+    },
+    white: {
+      prefix: "w",
+      code: "\e[37m",
+    },
+    bright_red: {
+      prefix: "br",
+      code: "\e[91m",
+    },
+    bright_green: {
+      prefix: "bg",
+      code: "\e[92m",
+    },
+    bright_yellow: {
+      prefix: "by",
+      code: "\e[93m",
+    },
+    bright_blue: {
+      prefix: "bb",
+      code: "\e[94m",
+    },
+    bright_magenta: {
+      prefix: "bm",
+      code: "\e[95m",
+    },
+    bright_cyan: {
+      prefix: "bc",
+      code: "\e[96m",
+    },
+    bright_white: {
+      prefix: "bw",
+      code: "\e[97m",
+    },
+  }.freeze
+
+  class << self
+    # Defines formatter helpers for each entry in {FORMATS}.
+    #
+    # Each generated method accepts text and returns it wrapped in matching ANSI
+    # format code followed by reset code. Helpers are exposed under both format
+    # names like `bold` and DSL prefixes like `B`.
+    FORMATS.each do |format, data|
+      define_method(format) do |text|
+        "#{data[:code]}#{text}#{FORMATS[:reset][:code]}"
+      end
+
+      define_method(data[:prefix]) do |text|
+        "#{data[:code]}#{text}#{FORMATS[:reset][:code]}"
+      end
+    end
+
+    # Returns registered formatter names.
+    #
+    # @return [Array<Symbol>]
+    def formats
+      @formats ||= FORMATS.keys
+    end
+
+    # Returns DSL prefixes for all registered formatters.
+    #
+    # @return [Array<String>]
+    def prefixes
+      @prefixes ||= FORMATS.map do |_format, data|
+        data[:prefix]
+      end
+    end
+
+    # Returns ANSI escape codes for all registered formatters.
+    #
+    # @return [Array<String>]
+    def codes
+      @codes ||= FORMATS.map do |_format, data|
+        data[:code]
+      end
+    end
+
+    # Expands `%<prefix>(text)` and `%<format_name>(text)` DSL tokens in string.
+    #
+    # Supports multiline content, nested tokens, and restoration of outer active
+    # formatting after nested token resets.
+    #
+    # @param string [String]
+    # @return [String]
+    def format(string)
+      parse_text(string)
+    end
+
+    private
+
+    # Recursively expands DSL tokens while preserving outer active ANSI codes.
+    #
+    # @param string [String]
+    # @param active_codes [Array<String>]
+    # @return [String]
+    def parse_text(string, active_codes = [])
+      result = +""
+      index = 0
+
+      while index < string.length
+        token = extract_token(string, index)
+
+        unless token
+          result << string[index]
+          index += 1
+          next
+        end
+
+        code = token_data.fetch(token[:token]).fetch(:code)
+
+        result << code
+        result << parse_text(token[:text], active_codes + [code])
+        result << FORMATS.fetch(:reset).fetch(:code)
+        result << active_codes.join
+
+        index = token[:next_index]
+      end
+
+      result
+    end
+
+    # Extracts next complete DSL token starting at start_index.
+    #
+    # @param string [String]
+    # @param start_index [Integer]
+    # @return [Hash, nil]
+    def extract_token(string, start_index)
+      return unless string[start_index] == "%"
+
+      token = sorted_tokens.find do |candidate|
+        string[start_index + 1, candidate.length] == candidate &&
+          string[start_index + candidate.length + 1] == "("
+      end
+      return unless token
+
+      content_start = start_index + token.length + 2
+      depth = 1
+      index = content_start
+
+      while index < string.length
+        case string[index]
+        when "("
+          depth += 1
+        when ")"
+          depth -= 1
+
+          if depth.zero?
+            return {
+              token:,
+              text: string[content_start...index],
+              next_index: index + 1,
+            }
+          end
+        end
+
+        index += 1
+      end
+    end
+
+    # Builds lookup map from DSL token to formatter metadata.
+    #
+    # @return [Hash{String => Hash}]
+    def token_data
+      @token_data ||= FORMATS.each_with_object({}) do |(format, data), result|
+        result[data[:prefix]] = data
+        result[format.to_s] = data
+      end
+    end
+
+    # Returns DSL tokens sorted longest-first for greedy token matching.
+    #
+    # @return [Array<String>]
+    def sorted_tokens
+      @sorted_tokens ||= token_data.keys.sort_by { |token| -token.length }
+    end
+  end
+end

metadata

@@ -0,0 +1,43 @@
+--- !ruby/object:Gem::Specification
+name: ruby-ansi-formatter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Greenfield
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides helper methods to apply ANSI formatting to text as well as a
+  DSL for applying several formats in a single string
+email:
+- mattgreenfield1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ansi.rb
+homepage: https://github.com/omgreenfield/ruby-ansi-formatter
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby ANSI formatter
+test_files: []