kramdown-ansi 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1518a44da5a730fbc604c32cfcff2bfd7841de1423a6fe17ab4c60265cb108e6
-  data.tar.gz: bcbd914a3469fcbe72367e2638bd868e7f4322244b9db5b62e7e27f20333a536
+  metadata.gz: 3a6aa1a68093731d47d9bc460ea4a2e5d498ae9dd126c56402e87affd2b6e00e
+  data.tar.gz: 2a1acad5300c9f9efb133e277998937a983256e2a90a1e9932fc6a3af9db5ec4
 SHA512:
-  metadata.gz: 8fd9aed00b8212f853b34697991bc0eb88b18b99356c263ae062a8b69e10d973f6565a06013a6e767fae656dea7df169487987604e0f53c84d2cba57186fa346
-  data.tar.gz: bc2438d30689ae6e3db356ac33c6ff76576b817bd1cc96d088820d984dbbbfa3567cb83be64a2fc1777f1cfb177f67e290d257b9d5c059d75dc38254d46231c5
+  metadata.gz: a7e3e9028eae28075319c67afe076404f3cc4164c7f8c476cf0f1ac1fe67f5eba3b4cd1d6418c24730a7ef65af947b929abe5d9f47338e573f5764545c16214b
+  data.tar.gz: 1c8ae07dbceba44a93195567e70fb0e4f03d4db8e21768d4107e44e9e14b5c82279c58b0fe2fd80890d5016bf29557ac286b7d3adbde5da2af31d7abc35b8d97

data/CHANGES.md

@@ -1,10 +1,32 @@
 # Changes
 
+## 2025-08-17 v0.1.0
+
+- Added comprehensive ANSI style configuration support with
+  `Kramdown::ANSI::Styles` class
+- Implemented `from_json` and `from_env_var` methods for loading styles
+  programmatically
+- Added environment variable precedence for style configuration:
+  - `KRAMDOWN_ANSI_GIT_MD_STYLES` → `KRAMDOWN_ANSI_STYLES`
+  - `KRAMDOWN_ANSI_MD_STYLES` → `KRAMDOWN_ANSI_STYLES`
+- Updated `md` and `git-md` executables to use new style configuration system
+- Added **JSON** dependency to gemspec
+- Enhanced README with documentation for style configuration
+- Added extensive test coverage for `Styles` class functionality
+- Supported custom ANSI styles via `ansi_styles` option in
+  `Kramdown::ANSI.parse`
+- Implemented proper fallback logic for default styles when custom
+  configurations are applied
+- Updated license reference to link to LICENSE file
+- Updated `gem_hadar` development dependency from version **1.20** to **2.0**
+- Simplified test coverage initialization with `GemHadar::SimpleCov.start`
+- Updated RSpec syntax in spec files, changing `RSpec.describe` to `describe`
+
 ## 2025-07-09 v0.0.4
 
 * **Pager Detection Update**
   + Updated pager detection to use the `--get` option with `git config` instead
-    of `get`.
+    of `get` in `git-md`.
 
 ## 2025-02-28 v0.0.3
 

data/README.md

@@ -2,8 +2,8 @@
 
 ## Description
 
-Kramdown::ANSI: A library for rendering Markdown(ish) documents with beautiful
-ANSI escape sequences in the terminal.
+**Kramdown::ANSI**: A library for rendering Markdown(ish) documents with beautiful
+ANSI escape sequences _in the terminal_.
 
 ## Installation (gem & bundler)
 
@@ -35,12 +35,59 @@ require 'kramdown/ansi'
 puts Kramdown::ANSI.parse(markdown)
 ```
 
+### Custom ANSI Styles
+
+You can customize the ANSI styles by passing an `ansi_styles` option:
+
+```ruby
+require 'kramdown/ansi'
+
+ansi_styles = {
+  header: [:bold, :magenta],
+  strong: :green,
+  em:     :yellow,
+  code:   [:cyan, :underline]
+}
+
+puts Kramdown::ANSI.parse(markdown, ansi_styles:)
+```
+
+### Custom ANSI Styles from JSON and JSON env vars
+
+You can configure ANSI styles programmatically from JSON using the built-in
+methods:
+
+```ruby
+require 'kramdown/ansi'
+
+# Using from_json method
+json_config = '{"header": ["bold", "magenta"], "code": ["cyan", "underline"]}'
+ansi_styles = Kramdown::ANSI::Styles.from_json(json_config)
+
+# Apply to parsing
+puts Kramdown::ANSI.parse(markdown, ansi_styles:)
+
+# Using from_env_var method  
+ENV['MY_STYLES'] = '{"em": "yellow", "strong": "green"}'
+ansi_styles = Kramdown::ANSI::Styles.from_env_var('MY_STYLES')
+
+# Apply to parsing
+puts Kramdown::ANSI.parse(markdown, ansi_styles:)
+```
+
 ## Executables
 
-| Method | Description |
-| :----- | :---------- |
-| `md` executable | Outputs [Markdown](https://spec.commonmark.org/current/) files with ANSI escape sequences in the terminal |
-| `git-md` executable | A Git plugin that outputs [Markdown](https://spec.commonmark.org/current/) formatted git commit messages into the terminal |
+| Method | Description | Environment Variables |
+| :------- | :---------- | :-------------------- |
+| `md` executable | Outputs [Markdown](https://spec.commonmark.org/current/) files with ANSI escape sequences in the terminal | `PAGER`, `KRAMDOWN_ANSI_MD_STYLES`, `KRAMDOWN_ANSI_STYLES` |
+| `git-md` executable | A Git plugin that outputs [Markdown](https://spec.commonmark.org/current/) formatted git commit messages into the terminal | `PAGER`, `GIT_PAGER`, `KRAMDOWN_ANSI_GIT_MD_STYLES`, `KRAMDOWN_ANSI_STYLES` |
+
+The `md` executable first checks for `KRAMDOWN_ANSI_MD_STYLES` environment
+variable, and if not found, falls back to `KRAMDOWN_ANSI_STYLES`. These
+variables can be used to customize ANSI styles for Markdown rendering. The
+`git-md` executable follows the same pattern, checking
+`KRAMDOWN_ANSI_GIT_MD_STYLES` first, then `KRAMDOWN_ANSI_STYLES`, allowing
+customization of ANSI styles for Git commit message formatting.
 
 ### The md executable
 
@@ -66,6 +113,14 @@ The output of the `md` command can be seen in this screenshot:
 
 ![md output](./img/md.png)
 
+
+### Example: Configuring `md` with Specific Environment Variable
+
+```bash
+# Using KRAMDOWN_ANSI_MD_STYLES (most specific for md executable)
+KRAMDOWN_ANSI_MD_STYLES='{"header": ["bold", "magenta"], "code": ["cyan", "underline"]}' md README.md
+```
+
 ### The git-md executable
 
 The `git-md` executable is a git plugin that can be used to output markdown
@@ -93,6 +148,12 @@ The output of the `git md` command can be seen in this screenshot:
 
 ![git md output](./img/git-md.png)
 
+### Example: Configuring `git-md` with Specific Environment Variable
+
+```bash
+# Using KRAMDOWN_ANSI_GIT_MD_STYLES (most specific for git-md executable)
+KRAMDOWN_ANSI_GIT_MD_STYLES='{"header": ["bold", "blue"], "code": "red"}' git md
+```
 
 ## Download
 
@@ -106,7 +167,7 @@ The homepage of this library is located at
 
 ## License
 
-This software is licensed under the <i>MIT</i> license.
+[MIT License](./LICENSE)
 
 ## Mandatory Kitten Image
 

data/Rakefile

@@ -29,6 +29,7 @@ GemHadar do
   dependency             'term-ansicolor',        '~> 1.11'
   dependency             'kramdown-parser-gfm',   '~> 1.1'
   dependency             'terminal-table',        '~> 3.0'
+  dependency             'json',                  '~> 2.0'
   development_dependency 'all_images',            '~> 0.4'
   development_dependency 'rspec',                 '~> 3.2'
   development_dependency 'debug'

data/bin/git-md

@@ -4,6 +4,12 @@ require 'kramdown/ansi'
 include Term::ANSIColor
 require 'shellwords'
 
+ansi_styles =
+  if env_var = %w[ KRAMDOWN_ANSI_GIT_MD_STYLES KRAMDOWN_ANSI_STYLES ].find { ENV.key?(_1) }
+    Kramdown::ANSI::Styles.from_env_var(env_var).ansi_styles
+  else
+    Kramdown::ANSI::Styles.new.ansi_styles
+  end
 cmd = %{git log --color=always --pretty=format:"commit %H%C(auto)%d%nDate:   %Cgreen%cD (%cr)%Creset%nAuthor: %Cblue%an <%ae>%Creset%n%nMARKUP%n%s%n%n%b%nMARKDOWN%n"}
 
 core_pager     = `git config --get core.pager`.chomp.full?
@@ -31,7 +37,7 @@ Kramdown::ANSI::Pager.pager(command: my_pager) do |output|
         when /^MARKUP$/
           message =  ''
         when /^MARKDOWN$/
-          output.puts Kramdown::ANSI.parse(message + "\n---\n")
+          output.puts Kramdown::ANSI.parse(message + "\n---\n", ansi_styles:)
           message = nil
         else
           if message

data/bin/md

@@ -2,7 +2,13 @@
 
 require 'kramdown/ansi'
 
-rendered      = Kramdown::ANSI.parse(ARGF.read)
+ansi_styles =
+  if env_var = %w[ KRAMDOWN_ANSI_MD_STYLES KRAMDOWN_ANSI_STYLES ].find { ENV.key?(_1) }
+    Kramdown::ANSI::Styles.from_env_var(env_var).ansi_styles
+  else
+    Kramdown::ANSI::Styles.new.ansi_styles
+  end
+rendered      = Kramdown::ANSI.parse(ARGF.read, ansi_styles:)
 default_pager = ENV['PAGER'].full?
 if fallback_pager = `which less`.chomp.full? || `which more`.chomp.full?
   fallback_pager << ' -r'

data/kramdown-ansi.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: kramdown-ansi 0.0.4 ruby lib
+# stub: kramdown-ansi 0.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "kramdown-ansi".freeze
-  s.version = "0.0.4".freeze
+  s.version = "0.1.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
@@ -12,19 +12,19 @@ Gem::Specification.new do |s|
   s.description = "Kramdown::ANSI: A library for rendering Markdown(ish) documents with\nbeautiful ANSI escape sequences in the terminal.\n".freeze
   s.email = "flori@ping.de".freeze
   s.executables = ["md".freeze, "git-md".freeze]
-  s.extra_rdoc_files = ["README.md".freeze, "lib/kramdown/ansi.rb".freeze, "lib/kramdown/ansi/pager.rb".freeze, "lib/kramdown/ansi/width.rb".freeze, "lib/kramdown/version.rb".freeze]
-  s.files = ["CHANGES.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "bin/git-md".freeze, "bin/md".freeze, "img/git-md.png".freeze, "img/md.png".freeze, "kramdown-ansi.gemspec".freeze, "lib/kramdown/ansi.rb".freeze, "lib/kramdown/ansi/pager.rb".freeze, "lib/kramdown/ansi/width.rb".freeze, "lib/kramdown/version.rb".freeze, "spec/assets/README.ansi".freeze, "spec/assets/kitten.jpg".freeze, "spec/kramdown/ansi/pager_spec.rb".freeze, "spec/kramdown/ansi/width_spec.rb".freeze, "spec/kramdown/ansi_spec.rb".freeze, "spec/spec_helper.rb".freeze]
+  s.extra_rdoc_files = ["README.md".freeze, "lib/kramdown/ansi.rb".freeze, "lib/kramdown/ansi/pager.rb".freeze, "lib/kramdown/ansi/styles.rb".freeze, "lib/kramdown/ansi/width.rb".freeze, "lib/kramdown/version.rb".freeze]
+  s.files = ["CHANGES.md".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.md".freeze, "Rakefile".freeze, "bin/git-md".freeze, "bin/md".freeze, "img/git-md.png".freeze, "img/md.png".freeze, "kramdown-ansi.gemspec".freeze, "lib/kramdown/ansi.rb".freeze, "lib/kramdown/ansi/pager.rb".freeze, "lib/kramdown/ansi/styles.rb".freeze, "lib/kramdown/ansi/width.rb".freeze, "lib/kramdown/version.rb".freeze, "spec/assets/README.ansi".freeze, "spec/assets/kitten.jpg".freeze, "spec/kramdown/ansi/pager_spec.rb".freeze, "spec/kramdown/ansi/styles_spec.rb".freeze, "spec/kramdown/ansi/width_spec.rb".freeze, "spec/kramdown/ansi_spec.rb".freeze, "spec/spec_helper.rb".freeze]
   s.homepage = "https://github.com/flori/kramdown-ansi".freeze
   s.licenses = ["MIT".freeze]
   s.rdoc_options = ["--title".freeze, "Kramdown-ansi - Output markdown in the terminal with ANSI escape sequences".freeze, "--main".freeze, "README.md".freeze]
   s.required_ruby_version = Gem::Requirement.new("~> 3.1".freeze)
   s.rubygems_version = "3.6.9".freeze
   s.summary = "Output markdown in the terminal with ANSI escape sequences".freeze
-  s.test_files = ["spec/kramdown/ansi/pager_spec.rb".freeze, "spec/kramdown/ansi/width_spec.rb".freeze, "spec/kramdown/ansi_spec.rb".freeze, "spec/spec_helper.rb".freeze]
+  s.test_files = ["spec/kramdown/ansi/pager_spec.rb".freeze, "spec/kramdown/ansi/styles_spec.rb".freeze, "spec/kramdown/ansi/width_spec.rb".freeze, "spec/kramdown/ansi_spec.rb".freeze, "spec/spec_helper.rb".freeze]
 
   s.specification_version = 4
 
-  s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 1.20".freeze])
+  s.add_development_dependency(%q<gem_hadar>.freeze, ["~> 2.0".freeze])
   s.add_development_dependency(%q<all_images>.freeze, ["~> 0.4".freeze])
   s.add_development_dependency(%q<rspec>.freeze, ["~> 3.2".freeze])
   s.add_development_dependency(%q<debug>.freeze, [">= 0".freeze])
@@ -32,4 +32,5 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency(%q<term-ansicolor>.freeze, ["~> 1.11".freeze])
   s.add_runtime_dependency(%q<kramdown-parser-gfm>.freeze, ["~> 1.1".freeze])
   s.add_runtime_dependency(%q<terminal-table>.freeze, ["~> 3.0".freeze])
+  s.add_runtime_dependency(%q<json>.freeze, ["~> 2.0".freeze])
 end

data/lib/kramdown/ansi/pager.rb

@@ -1,6 +1,20 @@
 require 'tins/terminal'
 require 'term/ansicolor'
 
+# A module that provides paging functionality for terminal output.
+#
+# The Pager module handles the logic for determining when to use a pager
+# command like 'less' or 'more' when the output exceeds the terminal's line
+# capacity. It also manages the execution of these pagers and ensures proper
+# terminal state restoration when paging is used.
+#
+# @example Using the pager with a block
+#   Kramdown::ANSI::Pager.pager(command: 'less', lines: 50) do |output|
+#     output.puts "Content to display"
+#   end
+#
+# @example Checking if a pager is needed
+#   pager_command = Kramdown::ANSI::Pager.pager(command: 'more', lines: 100)
 module Kramdown::ANSI::Pager
   module_function
 

data/lib/kramdown/ansi/styles.rb

@@ -0,0 +1,129 @@
+require 'json'
+
+# A configuration class for managing ANSI styles used in Markdown rendering.
+#
+# The Styles class provides functionality to initialize default ANSI styling
+# options for various Markdown elements and allows customization through
+# JSON configuration or environment variables.
+#
+# @example Using default styles
+#   styles = Kramdown::ANSI::Styles.new
+#
+# @example Creating styles from JSON configuration
+#   json_config = '{"header": ["bold", "underline"], "code": "red"}'
+#   styles = Kramdown::ANSI::Styles.from_json(json_config)
+#
+# @example Creating styles from environment variable
+#   ENV['MY_STYLES'] = '{"em": "italic"}'
+#   styles = Kramdown::ANSI::Styles.from_env_var('MY_STYLES')
+class Kramdown::ANSI::Styles
+  # Initializes a new instance with default ANSI styles configuration.
+  #
+  # Sets up the default styling options for various Markdown elements and
+  # prepares the instance variable to hold the current ANSI style
+  # configuration.
+  def initialize
+    @default_ansi_styles = {
+      header: %i[ bold underline ],
+      strong: :bold,
+      em:     :italic,
+      code:   :blue,
+    }
+    @ansi_styles = @default_ansi_styles.dup
+  end
+
+  # The default_ansi_styles reader method provides access to the default ANSI
+  # style configuration used by the Styles class.
+  #
+  # This method returns the @default_ansi_styles instance variable, which holds
+  # the predefined styling options for various Markdown elements before any
+  # custom configuration has been applied.
+  #
+  # @return [Hash] the default ANSI styles configuration hash containing symbol keys
+  # and style value arrays or single style values
+  attr_reader :default_ansi_styles
+
+  # The ansi_styles reader method provides access to the current ANSI style
+  # configuration.
+  #
+  # This method returns the @ansi_styles instance variable, which holds the
+  # active ANSI styling options used for formatting Markdown elements in
+  # terminal output.
+  #
+  # @return [Hash] the current ANSI styles configuration hash
+  attr_reader :ansi_styles
+
+  # Creates a new instance by parsing JSON configuration and applying it.
+  #
+  # @param json [String] A JSON string containing the configuration options
+  # @return [Kramdown::ANSI::Styles] A new instance with the parsed
+  # configuration applied
+  def self.from_json(json)
+    new.configure(JSON.parse(json))
+  end
+
+  # Creates a new Styles instance by parsing JSON configuration from an
+  # environment variable.
+  #
+  # @param name [String] the name of the environment variable containing the
+  # JSON configuration
+  # @return [Kramdown::ANSI::Styles] a new instance with the parsed
+  # configuration applied
+  def self.from_env_var(name)
+    from_json(ENV.fetch(name))
+  end
+
+  # Configures the ANSI styles using the provided options.
+  #
+  # Merges the given options with the default ANSI styles to customize the
+  # styling configuration for Markdown elements.
+  #
+  # @param options [Hash] a hash containing style configuration options
+  # @return [Kramdown::ANSI::Styles] returns self to allow for method chaining
+  def configure(options)
+    options_ansi_styles = options.to_h.transform_keys(&:to_sym).
+      transform_values {
+        array = Array(_1).map(&:to_sym)
+        array.size == 1 ? array.first : array
+      }
+    @ansi_styles = @default_ansi_styles.merge(options_ansi_styles)
+    self
+  end
+
+  # Applies ANSI styles to the given text block based on the specified style
+  # name.
+  #
+  # @param name [Symbol] the style name to apply
+  # @yield [String] the text to be styled
+  # @return [String] the text with ANSI styles applied
+  def apply(name, &block)
+    styles = Array(@ansi_styles.fetch(name))
+    styles.reverse_each.reduce(block.()) do |text, style|
+      if style.is_a?(Symbol) || style.is_a?(String)
+        text = Term::ANSIColor.send(style) { text }
+      end
+      text
+    end
+  end
+
+  # The as_json method converts the current ANSI styles configuration into a
+  # JSON-serializable format.
+  #
+  # @return [Hash] A hash representation of the current ANSI styles configuration.
+  def as_json(*)
+    @ansi_styles
+  end
+
+  alias to_hash as_json
+
+  alias to_h to_hash
+
+  # The to_json method converts the current ANSI styles configuration into a
+  # JSON-serializable format.
+  #
+  # @return [String] A JSON string representation of the current ANSI styles
+  # configuration.
+  def to_json(*)
+    as_json.to_json(*)
+  end
+end

data/lib/kramdown/ansi/width.rb

@@ -1,6 +1,18 @@
 require 'tins/terminal'
 require 'term/ansicolor'
 
+# A module that provides functionality for calculating terminal width
+# percentages and wrapping/truncating text accordingly.
+#
+# The Width module includes methods to determine the available terminal width
+# based on a percentage, and provides text wrapping and truncation capabilities
+# that respect terminal dimensions.
+#
+# @example Wrapping text to 80% of terminal width
+#   Kramdown::ANSI::Width.wrap("This is a long line of text", percentage: 80)
+#
+# @example Truncating text to 50 characters
+#   Kramdown::ANSI::Width.truncate("This is a long line of text", length: 50)
 module Kramdown::ANSI::Width
   include Term::ANSIColor
   extend Term::ANSIColor

data/lib/kramdown/ansi.rb

@@ -2,23 +2,74 @@ require 'kramdown'
 require 'kramdown-parser-gfm'
 require 'terminal-table'
 require 'term/ansicolor'
+
+# A namespace module for the Kramdown::ANSI library.
+#
+# The Kramdown module serves as the root namespace for the Kramdown::ANSI
+# library, which provides functionality for rendering Markdown documents with
+# ANSI escape sequences in terminal environments. This module encapsulates the
+# core components and converters necessary for transforming Markdown content
+# into beautifully formatted terminal output.
 module Kramdown
   class Kramdown::ANSI < Kramdown::Converter::Base
   end
 end
 require 'kramdown/ansi/width'
 require 'kramdown/ansi/pager'
-
+require 'kramdown/ansi/styles'
+
+# A converter class that transforms Kramdown documents into ANSI-formatted
+# terminal output.
+#
+# The Kramdown::ANSI class extends Kramdown::Converter::Base to provide
+# functionality for rendering Markdown documents with ANSI escape sequences for
+# terminal display. It handles various Markdown elements such as headers,
+# paragraphs, lists, and code blocks, applying configurable ANSI styles to
+# enhance the visual presentation in terminals.
+#
+# @example Converting a markdown string to ANSI formatted output
+#   ansi_output = Kramdown::ANSI.parse(markdown_string)
+#
+# @example Using custom ANSI styles
+#   styles = { header: [:bold, :underline], code: :red }
+#   ansi_output = Kramdown::ANSI.parse(markdown_string, ansi_styles: styles)
 class Kramdown::ANSI < Kramdown::Converter::Base
-  include Term::ANSIColor
   include Kramdown::ANSI::Width
 
+  # A utility module that provides ANSI escape sequence removal functionality
+  # for terminal table content.
+  #
+  # The Terminal::Table::Util module contains helper methods for processing
+  # text that may contain ANSI escape sequences, particularly for cleaning up
+  # terminal table output before further processing or display.
+  #
+  # @example Removing ANSI escape sequences from table lines
+  #   cleaned_line = Terminal::Table::Util.ansi_escape("\e[1mBold Text\e[0m")
   module Terminal::Table::Util
+    # Removes ANSI escape sequences from the given line of text.
+    #
+    # This method strips out all ANSI escape codes that are commonly used to
+    # format terminal output with colors, styles, and cursor movements.
+    #
+    # @param line [String] the input string that may contain ANSI escape
+    # sequences
+    # @return [String] a copy of the input string with all ANSI escape
+    # sequences removed
     def self.ansi_escape(line)
       line.to_s.gsub(/\e\[.*?m|\e\].*?(\e|\a)\\?/, '')
     end
   end
 
+  # A custom Markdown parser that extends GFM to provide enhanced parsing
+  # capabilities for Kramdown::ANSI.
+  #
+  # This class modifies the standard GFM parser by disabling certain quirks and
+  # removing specific block and span parsers to tailor the Markdown processing
+  # for ANSI terminal output.
+  #
+  # @example Using the Mygfm parser with Kramdown::ANSI
+  #   parser = Kramdown::Parser::Mygfm.new(markdown_content, {})
+  #   document = Kramdown::Document.new(markdown_content, input: :mygfm)
   class ::Kramdown::Parser::Mygfm <  ::Kramdown::Parser::GFM
     def initialize(source, options)
       options[:gfm_quirks] << :no_auto_typographic
@@ -31,20 +82,49 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     end
   end
 
-  def self.parse(source)
-    @doc = Kramdown::Document.new(
-      source, input: :mygfm, auto_ids: false, entity_output: :as_char
-    ).to_ansi
-  end
-
+  # Parses the given markdown source into ANSI formatted terminal output.
+  #
+  # @param source [String] the markdown content to be converted
+  # @param options [Hash] additional options for the parsing process
+  # @return [String] the ANSI formatted terminal output
+  def self.parse(source, options = {})
+    options = { input: :mygfm, auto_ids: false, entity_output: :as_char }.merge(
+      options.transform_keys(&:to_sym)
+    )
+    @doc = Kramdown::Document.new(source, options).to_ansi
+  end
+
+  # Initializes a new Kramdown::ANSI converter instance with optional ANSI
+  # styling configuration.
+  #
+  # @param root [Kramdown::Element] the root element of the document to convert
+  # @param options [Hash] additional options for the conversion process
+  # @return [void]
   def initialize(root, options)
+    @ansi_styles = Kramdown::ANSI::Styles.new.configure(options.delete(:ansi_styles))
     super
   end
 
+  # The convert method dispatches to type-specific conversion methods based on
+  # the element's type.
+  #
+  # @param el [Kramdown::Element] the element to convert
+  # @param opts [Hash] additional options for the conversion process
+  # @return [String] the converted content of the element
   def convert(el, opts = {})
     send("convert_#{el.type}", el, opts)
   end
 
+  # The inner method processes child elements of a given element and applies
+  # optional block processing to each child.
+  #
+  # @param el [Kramdown::Element] the element whose children will be processed
+  # @param opts [Hash] additional options for the processing
+  # @yield [Kramdown::Element, Integer, String] optional block to customize processing of each child element
+  # @yieldparam inner_el [Kramdown::Element] the current child element being processed
+  # @yieldparam index [Integer] the index of the current child element
+  # @yieldparam content [String] the converted content of the current child element
+  # @return [String] the concatenated result of processing all child elements
   def inner(el, opts, &block)
     result = +''
     options = opts.dup.merge(parent: el)
@@ -61,57 +141,156 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     result
   end
 
+  # The convert_root method processes the root element of a Kramdown document.
+  #
+  # This method serves as the entry point for converting the top-level element
+  # of a Markdown document into its ANSI-formatted terminal representation.
+  # It delegates the actual processing to the inner method, which handles
+  # the recursive conversion of child elements.
+  #
+  # @param el [Kramdown::Element] the root element to convert
+  # @param opts [Hash] additional options for the conversion process
+  # @return [String] the ANSI formatted content of the root element and its children
   def convert_root(el, opts)
     inner(el, opts)
   end
 
+  # The convert_blank method handles blank line conversion in Markdown
+  # documents.
+  #
+  # This method determines whether a blank element should produce output based
+  # on the context of the surrounding content. It checks if the current result
+  # ends with double newlines or is empty, and returns an appropriate newline
+  # character to maintain proper spacing in the rendered output.
+  #
+  # @param _el [Kramdown::Element] the blank element being converted (unused)
+  # @param opts [Hash] conversion options containing the result context
+  # @return [String] either an empty string or a single newline character
   def convert_blank(_el, opts)
     opts[:result] =~ /\n\n\Z|\A\Z/ ? "" : "\n"
   end
 
+  # The convert_text method processes a text element by extracting its value.
+  #
+  # @param el [Kramdown::Element] the text element to convert
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] the raw text content of the element
   def convert_text(el, _opts)
     el.value
   end
 
+  # The convert_header method processes a header element by applying ANSI
+  # styling and adding a newline.
+  #
+  # @param el [Kramdown::Element] the header element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the styled header content with a trailing newline
   def convert_header(el, opts)
-    newline bold { underline { inner(el, opts) } }
+    newline apply_style(:header) { inner(el, opts) }
   end
 
+  # The convert_p method processes a paragraph element by calculating the
+  # appropriate text width based on the terminal size and list indentation,
+  # then wraps the content accordingly.
+  #
+  # @param el [Kramdown::Element] the paragraph element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the wrapped and formatted paragraph content with proper newlines
   def convert_p(el, opts)
     length = width(percentage: 90) - opts[:list_indent].to_i
     length < 0 and return ''
     newline wrap(inner(el, opts), length:)
   end
 
+  # The convert_strong method processes a strong emphasis element by applying
+  # ANSI styling to its content.
+  #
+  # @param el [Kramdown::Element] the strong element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the styled strong content
   def convert_strong(el, opts)
-    bold { inner(el, opts) }
+    apply_style(:strong) { inner(el, opts) }
   end
 
+  # The convert_em method processes an emphasis element by applying ANSI
+  # styling to its content.
+  #
+  # @param el [Kramdown::Element] the emphasis element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the styled emphasis content
   def convert_em(el, opts)
-    italic { inner(el, opts) }
+    apply_style(:em) { inner(el, opts) }
   end
 
+  # The convert_a method processes an anchor element by applying hyperlink
+  # formatting to its content.
+  #
+  # @param el [Kramdown::Element] the anchor element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the hyperlink formatted content
   def convert_a(el, opts)
     url = el.attr['href']
     hyperlink(url) { inner(el, opts) }
   end
 
+  # The convert_codespan method processes a code span element by applying ANSI
+  # styling to its content.
+  #
+  # @param el [Kramdown::Element] the code span element to convert
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] the styled code span content
   def convert_codespan(el, _opts)
-    blue { el.value }
+    apply_style(:code) { el.value }
   end
 
+  # The convert_codeblock method processes a code block element by applying
+  # ANSI styling to its content.
+  #
+  # @param el [Kramdown::Element] the code block element to convert
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] the styled code block content
   def convert_codeblock(el, _opts)
-    blue { el.value }
-  end
-
+    apply_style(:code) { el.value }
+  end
+
+  # The convert_blockquote method processes a blockquote element by applying
+  # proper formatting.
+  #
+  # This method takes a blockquote element and formats its content with
+  # quotation marks while ensuring appropriate newline handling. It delegates
+  # the inner content processing to the inner method and then wraps the result
+  # with quotation marks.
+  #
+  # @param el [Kramdown::Element] the blockquote element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the formatted blockquote content with quotation marks and
+  # proper newlines
   def convert_blockquote(el, opts)
     newline ?“ + inner(el, opts).sub(/\n+\z/, '') + ?”
   end
 
+  # The convert_hr method processes a horizontal rule element by generating a
+  # full-width separator line.
+  #
+  # This method creates a horizontal rule (divider) using the Unicode
+  # line-drawing character and applies proper newline formatting to ensure
+  # correct spacing in the terminal output.
+  #
+  # @param _el [Kramdown::Element] the horizontal rule element to convert (unused)
+  # @param _opts [Hash] conversion options (unused)
+  # @return [String] a formatted horizontal rule line spanning the full
+  # terminal width with newlines
   def convert_hr(_el, _opts)
     newline ?─ * width(percentage: 100)
   end
 
+  # The convert_img method processes an image element by extracting its source
+  # URL and alternative text, formatting the display with a fallback to the URL
+  # if the alt text is empty, and applying hyperlink styling.
+  #
+  # @param el [Kramdown::Element] the image element to convert
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] the formatted image content with hyperlink styling
   def convert_img(el, _opts)
     url = el.attr['src']
     alt = el.attr['alt']
@@ -120,6 +299,18 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     hyperlink(url) { alt }
   end
 
+  # The convert_ul method processes an unordered list element by applying
+  # bullet point formatting and indentation.
+  #
+  # This method takes an unordered list element and formats its child elements
+  # with bullet points, applying appropriate newline handling based on the list
+  # item's position, and adding indentation to align the content properly
+  # within the terminal output.
+  #
+  # @param el [Kramdown::Element] the unordered list element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the formatted unordered list content with bullet points
+  # and proper indentation
   def convert_ul(el, opts)
     list_indent = opts[:list_indent].to_i
     inner(el, opts) { |_inner_el, index, content|
@@ -129,6 +320,18 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     }
   end
 
+  # The convert_ol method processes an ordered list element by applying
+  # numbered bullet point formatting and indentation.
+  #
+  # This method takes an ordered list element and formats its child elements
+  # with sequential numbers, applying appropriate newline handling based on the
+  # list item's position, and adding indentation to align the content properly
+  # within the terminal output.
+  #
+  # @param el [Kramdown::Element] the ordered list element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the formatted ordered list content with numbered points
+  # and proper indentation
   def convert_ol(el, opts)
     list_indent = opts[:list_indent].to_i
     inner(el, opts) { |_inner_el, index, content|
@@ -138,22 +341,50 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     }
   end
 
+  # The convert_li method processes a list item element by applying indentation
+  # and handling newlines.
+  #
+  # This method takes a list item element and modifies the conversion options
+  # to include appropriate indentation for nested lists. It then delegates the
+  # inner content processing to the inner method and ensures proper newline
+  # handling at the end of the content.
+  #
+  # @param el [Kramdown::Element] the list item element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the formatted list item content with proper indentation
+  # and newlines
   def convert_li(el, opts)
     opts = opts.dup
     opts[:list_indent] = 2 + opts[:list_indent].to_i
     newline inner(el, opts).sub(/\n+\Z/, '')
   end
 
+  # The convert_html_element method processes HTML inline elements such as <i>,
+  # <em>, <b>, and <strong> by applying the corresponding ANSI styles to their
+  # content. It handles emphasis and strong formatting tags specifically, while
+  # ignoring other HTML elements by returning an empty string.
+  #
+  # @param el [Kramdown::Element] the HTML element being converted
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the styled content for emphasis or strong elements, or an
+  # empty string for other elements
   def convert_html_element(el, opts)
     if el.value == 'i' || el.value == 'em'
-      italic { inner(el, opts) }
+      apply_style(:em) { inner(el, opts) }
     elsif el.value == 'b' || el.value == 'strong'
-      bold { inner(el, opts) }
+      apply_style(:strong) { inner(el, opts) }
     else
       ''
     end
   end
 
+  # The convert_table method processes a table element by creating a terminal
+  # table instance, applying styling and alignment options, and generating
+  # formatted output with newlines.
+  #
+  # @param el [Kramdown::Element] the table element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the formatted table content with proper styling and newlines
   def convert_table(el, opts)
     table = Terminal::Table.new
     table.style = {
@@ -169,6 +400,14 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     newline table.to_s
   end
 
+  # The convert_thead method processes a table header element by extracting and
+  # formatting the heading rows from the table content, then assigns them to
+  # the terminal table instance.
+  #
+  # @param el [Kramdown::Element] the table header element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] an empty string to indicate successful processing and
+  # assignment of headings to the table instance
   def convert_thead(el, opts)
     rows = inner(el, opts)
     rows = rows.split(/\s*\|\s*/)[1..].map(&:strip)
@@ -176,15 +415,46 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     ''
   end
 
+  # The convert_tbody method processes a table body element by collecting its
+  # inner content.
+  #
+  # This method handles the conversion of HTML table body elements, gathering
+  # all child elements' content and returning it as a string. It serves as part
+  # of the table conversion process, working in conjunction with other
+  # table-related methods to generate properly formatted terminal output.
+  #
+  # @param el [Kramdown::Element] the table body element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the concatenated content of all child elements within the
+  # table body
   def convert_tbody(el, opts)
     res = +''
     res << inner(el, opts)
   end
 
+  # The convert_tfoot method handles the conversion of table footer elements.
+  #
+  # This method processes table footer elements by returning an empty string,
+  # effectively ignoring footer content during the ANSI terminal output
+  # conversion. It is part of the table conversion process, working alongside
+  # other table-related methods to generate properly formatted terminal output.
+  #
+  # @param el [Kramdown::Element] the table footer element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] an empty string to indicate successful handling of the
+  # footer element
   def convert_tfoot(el, opts)
     ''
   end
 
+  # The convert_tr method processes a table row element by calculating column
+  # widths based on content size, wrapping text to fit within the terminal
+  # width, and adding the formatted row to the terminal table instance.
+  #
+  # @param el [Kramdown::Element] the table row element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] an empty string to indicate successful processing and
+  # addition of the row to the table instance
   def convert_tr(el, opts)
     return '' if el.children.empty?
     full_width = width(percentage: 90)
@@ -198,33 +468,104 @@ class Kramdown::ANSI < Kramdown::Converter::Base
     ''
   end
 
+  # The convert_td method processes a table data cell element by delegating its
+  # content conversion to the inner method.
+  #
+  # @param el [Kramdown::Element] the table data cell element to convert
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] the converted content of the table data cell element
   def convert_td(el, opts)
     inner(el, opts)
   end
 
+  # The convert_entity method processes an entity element by extracting its
+  # character value.
+  #
+  # @param el [Kramdown::Element] the entity element to convert
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] the character representation of the entity
   def convert_entity(el, _opts)
     el.value.char
   end
 
+  # The convert_xml_comment method handles XML comment elements by returning an
+  # empty string.
+  #
+  # This method is part of the Kramdown::ANSI converter and is responsible for
+  # processing XML comment elements that appear in the Markdown document. It
+  # ignores XML comments during the ANSI terminal output conversion process,
+  # returning an empty string to indicate that no content should be rendered
+  # for these elements.
+  #
+  # @return [String] an empty string to indicate that XML comments are ignored
+  # during conversion
   def convert_xml_comment(*)
     ''
   end
 
+  # The convert_xml_pi method handles the conversion of XML processing
+  # instruction elements.
+  #
+  # This method is part of the Kramdown::ANSI converter and is responsible for
+  # processing XML processing instruction elements that appear in the Markdown
+  # document. It ignores these elements during the ANSI terminal output
+  # conversion process, returning an empty string to indicate that no content
+  # should be rendered for these elements.
+  #
+  # @return [String] an empty string to indicate that XML processing
+  # instructions are ignored during conversion
   def convert_xml_pi(*)
     ''
   end
 
+  # The convert_br method handles the conversion of line break elements.
+  #
+  # This method processes HTML line break elements (br tags) by returning an
+  # empty string, effectively ignoring them during the ANSI terminal output
+  # conversion process. It is part of the Kramdown::ANSI converter's element
+  # handling suite.
+  #
+  # @param _el [Kramdown::Element] the line break element being converted (unused)
+  # @param opts [Hash] conversion options containing context for processing
+  # @return [String] an empty string to indicate that line breaks are ignored
+  # during conversion
   def convert_br(_el, opts)
     ''
   end
 
+  # The convert_smart_quote method processes smart quote entities by
+  # determining whether to output a double quotation mark or single quotation
+  # mark based on the entity's type.
+  #
+  # @param el [Kramdown::Element] the smart quote element being converted
+  # @param _opts [Hash] additional options (unused)
+  # @return [String] a double quotation mark for right double quotes or left
+  # double quotes, and a single quotation mark for other smart quote entities
   def convert_smart_quote(el, _opts)
     el.value.to_s =~ /[rl]dquo/ ? "\"" : "'"
   end
 
+  # The newline method appends a specified number of newline characters to the
+  # end of a given text string.
+  #
+  # @param text [String] the input text to which newlines will be appended
+  # @param count [Integer] the number of newline characters to append (defaults to 1)
+  # @return [String] the text with the specified number of trailing newline characters
   def newline(text, count: 1)
     text.gsub(/\n*\z/, ?\n * count)
   end
+
+  private
+
+  # The apply_style method applies ANSI styling to content by utilizing the
+  # configured styles and yielding the content to be styled.
+  #
+  # @param name [Symbol] the style name to apply
+  # @yield [String] the content to be styled
+  # @return [String] the content with the specified ANSI styles applied
+  def apply_style(name, &block)
+    @ansi_styles.apply(name, &block)
+  end
 end
 
 Kramdown::Converter.const_set(:Ansi, Kramdown::ANSI)

data/lib/kramdown/version.rb

@@ -1,6 +1,6 @@
 module Kramdown
   # Kramdown version
-  VERSION         = '0.0.4'
+  VERSION         = '0.1.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/spec/kramdown/ansi/pager_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Kramdown::ANSI::Pager do
+describe Kramdown::ANSI::Pager do
   let :command do
     'cat'
   end

data/spec/kramdown/ansi/styles_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+
+describe Kramdown::ANSI::Styles do
+  describe '.from_json' do
+    it 'configures styles from JSON' do
+      json = '{"header": ["bold", "underline"], "code": "red"}'
+      styles = described_class.from_json(json)
+
+      expect(styles.ansi_styles[:header]).to eq([:bold, :underline])
+      expect(styles.ansi_styles[:code]).to eq(:red)
+    end
+  end
+
+  describe '.from_env_var' do
+    around do |example|
+      ENV['TEST_STYLES'] = '{"em": "yellow"}'
+      example.run
+      ENV.delete('TEST_STYLES')
+    end
+
+    it 'configures styles from environment variable' do
+      styles = described_class.from_env_var('TEST_STYLES')
+
+      expect(styles.ansi_styles[:em]).to eq(:yellow)
+    end
+
+    it 'raises an error when env var is not set' do
+      ENV.delete('TEST_STYLES')
+      expect {
+        described_class.from_env_var('TEST_STYLES')
+      }.to raise_error(KeyError)
+    end
+  end
+
+  describe '#as_json' do
+    it 'can be prepared for JSON conversion' do
+      expect(described_class.new.as_json).to include(:code)
+    end
+  end
+
+  describe '#to_hash' do
+    it 'can be converted to a hash' do
+      expect(described_class.new.to_hash).to include(:code)
+    end
+  end
+
+  describe '#to_h' do
+    it 'can be converted to a hash more forecefully' do
+      expect(described_class.new.to_h).to include(:code)
+    end
+  end
+
+  describe '#to_json' do
+    it 'can be converted to JSON' do
+      expect(described_class.new.to_json).to include('"code":')
+    end
+  end
+
+  describe '#configure' do
+    let(:styles) { described_class.new }
+
+    it 'merges options with defaults' do
+      styles.configure(header: [:bold, :underline])
+
+      expect(styles.ansi_styles[:header]).to eq([:bold, :underline])
+      expect(styles.ansi_styles[:strong]).to eq(:bold) # default preserved
+    end
+
+    it 'handles string keys gracefully' do
+      styles.configure('em' => 'italic')
+
+      expect(styles.ansi_styles[:em]).to eq(:italic)
+    end
+
+    it 'preserves default styles when not overridden' do
+      styles.configure(code: :green)
+
+      expect(styles.default_ansi_styles[:header]).to eq(%i[bold underline])
+      expect(styles.ansi_styles[:header]).to eq(%i[bold underline])
+      expect(styles.ansi_styles[:code]).to eq(:green)
+    end
+  end
+
+  describe '#apply' do
+    let(:styles) { described_class.new }
+
+    it 'applies single style to text' do
+      result = styles.apply(:strong) { "Hello" }
+      expect(result).to include("\e[1m") # bold ANSI code
+    end
+
+    it 'applies multiple styles in correct order' do
+      result = styles.apply(:header) { "Header" }
+      expect(result).to include("\e[1m\e[4m") # bold + underline
+    end
+
+    it 'handles non-existent style by raising KeyError' do
+      expect {
+        styles.apply(:nonexistent) { "Text" }
+      }.to raise_error(KeyError)
+    end
+
+    it 'applies styles correctly with complex text' do
+      result = styles.apply(:code) { "puts 'hello'" }
+      expect(result).to include("\e[34m") # blue ANSI code
+    end
+
+    it 'allows inspection of current configuration' do
+      expect(styles.ansi_styles).to eq(styles.default_ansi_styles)
+
+      styles.configure(em: :underline)
+      expect(styles.ansi_styles[:em]).to eq(:underline)
+      expect(styles.ansi_styles[:strong]).to eq(:bold) # unchanged
+    end
+  end
+end

data/spec/kramdown/ansi/width_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Kramdown::ANSI::Width do
+describe Kramdown::ANSI::Width do
   before do
     allow(Tins::Terminal).to receive(:columns).and_return 80
   end

data/spec/kramdown/ansi_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'pathname'
 
-RSpec.describe Kramdown::ANSI do
+describe Kramdown::ANSI do
   let :source  do
     File.read(Pathname.new(__dir__) + '..' + '..' + 'README.md')
   end
@@ -9,8 +9,31 @@ RSpec.describe Kramdown::ANSI do
   it 'can parse' do
     File.open('tmp/README.ansi', ?w) do |output|
       ansi = described_class.parse(source)
-      expect(ansi).to match("This is the end.")
+      expect(ansi).to include("\e[1m\e[4mDescription\e[0m\e[0m")
+      expect(ansi).to include("\e[1mKramdown::ANSI\e[0m")
+      expect(ansi).to include("\e[3min the terminal\e[0m")
+      expect(ansi).to include("\e[34mgem install kramdown-ansi\n\e[0m")
+      expect(ansi).to include("\e[34mbundle install\e[0m")
+      expect(ansi).to include("This is the end.")
       output.puts ansi
     end
   end
+
+  it 'can parse with options' do
+    File.open('tmp/README.ansi', ?w) do |output|
+      ansi_styles = Kramdown::ANSI::Styles.new.configure(
+        header: %i[ red underline ],
+        strong: %i[ green ],
+        em:     %i[ yellow ],
+        code:   %i[ bold color208 ],
+      )
+      ansi = described_class.parse(source, ansi_styles:)
+      expect(ansi).to include("\e[31m\e[4mDescription\e[0m\e[0")
+      expect(ansi).to include("\e[32mKramdown::ANSI\e[0m")
+      expect(ansi).to include("\e[33min the terminal\e[0m")
+      expect(ansi).to include("\e[1m\e[38;5;208mgem install kramdown-ansi\n\e[0m\e[0m")
+      expect(ansi).to include("\e[1m\e[38;5;208mbundle install\e[0m\e[0m")
+      expect(ansi).to include("This is the end.")
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,5 @@
-if ENV['START_SIMPLECOV'].to_i == 1
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "#{File.basename(File.dirname(__FILE__))}/"
-  end
-end
+require 'gem_hadar/simplecov'
+GemHadar::SimpleCov.start
 require 'rspec'
 begin
   require 'debug'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kramdown-ansi
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Florian Frank
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.20'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.20'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: all_images
   requirement: !ruby/object:Gem::Requirement
@@ -121,6 +121,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: |
   Kramdown::ANSI: A library for rendering Markdown(ish) documents with
   beautiful ANSI escape sequences in the terminal.
@@ -133,6 +147,7 @@ extra_rdoc_files:
 - README.md
 - lib/kramdown/ansi.rb
 - lib/kramdown/ansi/pager.rb
+- lib/kramdown/ansi/styles.rb
 - lib/kramdown/ansi/width.rb
 - lib/kramdown/version.rb
 files:
@@ -148,11 +163,13 @@ files:
 - kramdown-ansi.gemspec
 - lib/kramdown/ansi.rb
 - lib/kramdown/ansi/pager.rb
+- lib/kramdown/ansi/styles.rb
 - lib/kramdown/ansi/width.rb
 - lib/kramdown/version.rb
 - spec/assets/README.ansi
 - spec/assets/kitten.jpg
 - spec/kramdown/ansi/pager_spec.rb
+- spec/kramdown/ansi/styles_spec.rb
 - spec/kramdown/ansi/width_spec.rb
 - spec/kramdown/ansi_spec.rb
 - spec/spec_helper.rb
@@ -183,6 +200,7 @@ specification_version: 4
 summary: Output markdown in the terminal with ANSI escape sequences
 test_files:
 - spec/kramdown/ansi/pager_spec.rb
+- spec/kramdown/ansi/styles_spec.rb
 - spec/kramdown/ansi/width_spec.rb
 - spec/kramdown/ansi_spec.rb
 - spec/spec_helper.rb