rich-ruby 1.0.0

data/lib/rich/markdown.rb

@@ -0,0 +1,509 @@
+# frozen_string_literal: true
+
+require_relative "style"
+require_relative "segment"
+require_relative "text"
+require_relative "panel"
+require_relative "box"
+require_relative "cells"
+
+module Rich
+  # Markdown rendering for terminal output.
+  # Parses and renders Markdown content with styling.
+  class Markdown
+    # Default styles for Markdown elements
+    DEFAULT_STYLES = {
+      # Headings
+      h1: Style.new(color: Color.parse("bright_cyan"), bold: true),
+      h2: Style.new(color: Color.parse("cyan"), bold: true),
+      h3: Style.new(color: Color.parse("bright_blue"), bold: true),
+      h4: Style.new(color: Color.parse("blue"), bold: true),
+      h5: Style.new(color: Color.parse("bright_magenta")),
+      h6: Style.new(color: Color.parse("magenta")),
+
+      # Text formatting
+      bold: Style.new(bold: true),
+      italic: Style.new(italic: true),
+      bold_italic: Style.new(bold: true, italic: true),
+      strikethrough: Style.new(strike: true),
+      code_inline: Style.new(color: Color.parse("bright_green"), bgcolor: Color.parse("color(236)")),
+
+      # Links and references
+      link: Style.new(color: Color.parse("bright_blue"), underline: true),
+      link_url: Style.new(color: Color.parse("blue"), dim: true),
+
+      # Lists
+      bullet: Style.new(color: Color.parse("yellow")),
+      list_number: Style.new(color: Color.parse("yellow")),
+
+      # Blockquotes
+      blockquote: Style.new(color: Color.parse("bright_black"), italic: true),
+      blockquote_border: Style.new(color: Color.parse("magenta")),
+
+      # Code blocks
+      code_block: Style.new(bgcolor: Color.parse("color(236)")),
+      code_border: Style.new(color: Color.parse("bright_black")),
+
+      # Horizontal rule
+      hr: Style.new(color: Color.parse("bright_black")),
+
+      # Table
+      table_header: Style.new(bold: true, color: Color.parse("cyan")),
+      table_border: Style.new(color: Color.parse("bright_black"))
+    }.freeze
+
+    # @return [String] Source markdown
+    attr_reader :source
+
+    # @return [Hash] Style configuration
+    attr_reader :styles
+
+    # @return [Boolean] Use hyperlinks
+    attr_reader :hyperlinks
+
+    # @return [Integer] Code block indent
+    attr_reader :code_indent
+
+    # Create a new Markdown renderer
+    # @param source [String] Markdown source text
+    # @param styles [Hash] Custom styles to override defaults
+    # @param hyperlinks [Boolean] Enable terminal hyperlinks
+    # @param code_indent [Integer] Indent for code blocks
+    def initialize(source, styles: {}, hyperlinks: true, code_indent: 4)
+      @source = source.to_s
+      @styles = DEFAULT_STYLES.merge(styles)
+      @hyperlinks = hyperlinks
+      @code_indent = code_indent
+    end
+
+    # Render markdown to string with ANSI codes
+    # @param max_width [Integer] Maximum width
+    # @return [String]
+    def render(max_width: 80)
+      lines = parse_and_render(max_width: max_width)
+      lines.join("\n")
+    end
+
+    # Convert to segments
+    # @param max_width [Integer] Maximum width
+    # @return [Array<Segment>]
+    def to_segments(max_width: 80)
+      segments = []
+      lines = parse_and_render(max_width: max_width)
+
+      lines.each_with_index do |line, i|
+        # Line is already a rendered string with ANSI codes
+        segments << Segment.new(line)
+        segments << Segment.new("\n") if i < lines.length - 1
+      end
+
+      segments
+    end
+
+    class << self
+      # Render markdown from string
+      # @param source [String] Markdown text
+      # @param kwargs [Hash] Options
+      # @return [String]
+      def render(source, **kwargs)
+        new(source, **kwargs).render(**kwargs)
+      end
+
+      # Render markdown from file
+      # @param path [String] File path
+      # @param kwargs [Hash] Options
+      # @return [String]
+      def from_file(path, **kwargs)
+        source = File.read(path)
+        new(source, **kwargs)
+      end
+    end
+
+    private
+
+    # Parse and render markdown
+    # @param max_width [Integer] Maximum width
+    # @return [Array<String>]
+    def parse_and_render(max_width:)
+      lines = @source.lines.map(&:chomp)
+      output = []
+      i = 0
+
+      while i < lines.length
+        line = lines[i]
+
+        # Blank line
+        if line.strip.empty?
+          output << ""
+          i += 1
+          next
+        end
+
+        # Fenced code block
+        if line.match?(/^```/)
+          lang = line[3..].strip
+          code_lines = []
+          i += 1
+          while i < lines.length && !lines[i].start_with?("```")
+            code_lines << lines[i]
+            i += 1
+          end
+          output.concat(render_code_block(code_lines.join("\n"), lang, max_width))
+          i += 1
+          next
+        end
+
+        # Heading
+        if line.match?(%r{^\#{1,6}\s})
+          output.concat(render_heading(line, max_width))
+          i += 1
+          next
+        end
+
+        # Horizontal rule
+        if line.match?(/^[-*_]{3,}\s*$/)
+          output << render_hr(max_width)
+          i += 1
+          next
+        end
+
+        # Unordered list
+        if line.match?(/^\s*[-*+]\s/)
+          list_lines = [line]
+          i += 1
+          while i < lines.length && (lines[i].match?(/^\s*[-*+]\s/) || lines[i].match?(/^\s{2,}/))
+            list_lines << lines[i]
+            i += 1
+          end
+          output.concat(render_unordered_list(list_lines, max_width))
+          next
+        end
+
+        # Ordered list
+        if line.match?(/^\s*\d+\.\s/)
+          list_lines = [line]
+          i += 1
+          while i < lines.length && (lines[i].match?(/^\s*\d+\.\s/) || lines[i].match?(/^\s{2,}/))
+            list_lines << lines[i]
+            i += 1
+          end
+          output.concat(render_ordered_list(list_lines, max_width))
+          next
+        end
+
+        # Blockquote
+        if line.start_with?(">")
+          quote_lines = [line]
+          i += 1
+          while i < lines.length && (lines[i].start_with?(">") || (!lines[i].strip.empty? && !lines[i].match?(/^[#\-*+\d]/)))
+            quote_lines << lines[i]
+            i += 1
+          end
+          output.concat(render_blockquote(quote_lines, max_width))
+          next
+        end
+
+        # Table
+        if line.include?("|") && i + 1 < lines.length && lines[i + 1].match?(/^\|?\s*[-:]+/)
+          table_lines = [line]
+          i += 1
+          while i < lines.length && lines[i].include?("|")
+            table_lines << lines[i]
+            i += 1
+          end
+          output.concat(render_table(table_lines, max_width))
+          next
+        end
+
+        # Regular paragraph
+        para_lines = [line]
+        i += 1
+        while i < lines.length && !lines[i].strip.empty? && !lines[i].match?(/^[\#\-*+>\d`|]/)
+          para_lines << lines[i]
+          i += 1
+        end
+        output.concat(render_paragraph(para_lines.join(" "), max_width))
+      end
+
+      output
+    end
+
+    # Render a heading
+    def render_heading(line, max_width)
+      match = line.match(%r{^(\#{1,6})\s+(.*)})
+      return [line] unless match
+
+      level = match[1].length
+      text = match[2]
+
+      style = @styles[:"h#{level}"] || @styles[:h1]
+      styled_text = apply_inline_styles(text)
+
+      result = []
+
+      # Add decorations based on level
+      case level
+      when 1
+        border = style.render + ("=" * [text.length + 4, max_width].min) + "\e[0m"
+        result << border
+        result << style.render + "  #{styled_text}  " + "\e[0m"
+        result << border
+      when 2
+        result << style.render + styled_text + "\e[0m"
+        result << style.render + ("-" * [text.length, max_width].min) + "\e[0m"
+      else
+        prefix = "#" * level + " "
+        result << style.render + prefix + styled_text + "\e[0m"
+      end
+
+      result << ""
+      result
+    end
+
+    # Render horizontal rule
+    def render_hr(max_width)
+      @styles[:hr].render + ("─" * max_width) + "\e[0m"
+    end
+
+    # Render unordered list
+    def render_unordered_list(lines, max_width)
+      result = []
+      indent = 0
+
+      lines.each do |line|
+        match = line.match(/^(\s*)([-*+])\s+(.*)/)
+        next unless match
+
+        spaces = match[1]
+        content = match[3]
+
+        # Calculate indent level
+        indent = spaces.length / 2
+
+        bullet_char = case indent
+                      when 0 then "•"
+                      when 1 then "◦"
+                      else "▪"
+                      end
+
+        prefix = "  " * indent
+        bullet = @styles[:bullet].render + bullet_char + "\e[0m "
+        styled_content = apply_inline_styles(content)
+
+        result << prefix + bullet + styled_content
+      end
+
+      result << ""
+      result
+    end
+
+    # Render ordered list
+    def render_ordered_list(lines, max_width)
+      result = []
+      counter = 0
+
+      lines.each do |line|
+        match = line.match(/^(\s*)(\d+)\.\s+(.*)/)
+        next unless match
+
+        spaces = match[1]
+        counter += 1
+        content = match[3]
+
+        indent = spaces.length / 2
+        prefix = "  " * indent
+        num = @styles[:list_number].render + "#{counter}." + "\e[0m "
+        styled_content = apply_inline_styles(content)
+
+        result << prefix + num + styled_content
+      end
+
+      result << ""
+      result
+    end
+
+    # Render blockquote
+    def render_blockquote(lines, max_width)
+      result = []
+      border_style = @styles[:blockquote_border]
+      text_style = @styles[:blockquote]
+
+      lines.each do |line|
+        content = line.sub(/^>\s*/, "")
+        styled = text_style.render + apply_inline_styles(content) + "\e[0m"
+        result << border_style.render + "│ " + "\e[0m" + styled
+      end
+
+      result << ""
+      result
+    end
+
+    # Render code block
+    def render_code_block(code, language, max_width)
+      result = []
+      indent = " " * @code_indent
+      style = @styles[:code_block]
+
+      # Header with language
+      if language && !language.empty?
+        lang_display = "  #{language}  "
+        result << @styles[:code_border].render + "┌" + ("─" * (max_width - 2)) + "┐" + "\e[0m"
+        result << @styles[:code_border].render + "│" + "\e[0m" + " " + lang_display.ljust(max_width - 4) + @styles[:code_border].render + " │" + "\e[0m"
+        result << @styles[:code_border].render + "├" + ("─" * (max_width - 2)) + "┤" + "\e[0m"
+      else
+        result << @styles[:code_border].render + "┌" + ("─" * (max_width - 2)) + "┐" + "\e[0m"
+      end
+
+      # Code lines
+      code.each_line do |line|
+        line = line.chomp
+        padded = line.ljust(max_width - 4)
+        result << @styles[:code_border].render + "│ " + "\e[0m" + style.render + padded + "\e[0m" + @styles[:code_border].render + " │" + "\e[0m"
+      end
+
+      # Footer
+      result << @styles[:code_border].render + "└" + ("─" * (max_width - 2)) + "┘" + "\e[0m"
+      result << ""
+
+      result
+    end
+
+    # Render table
+    def render_table(lines, max_width)
+      return [] if lines.empty?
+
+      # Parse table
+      rows = lines.map do |line|
+        line.split("|").map(&:strip).reject(&:empty?)
+      end
+
+      return [] if rows.empty?
+
+      # Skip separator row
+      rows.reject! { |row| row.all? { |cell| cell.match?(/^[-:]+$/) } }
+      return [] if rows.empty?
+
+      header = rows.first
+      body = rows[1..]
+
+      # Calculate column widths
+      col_widths = header.map(&:length)
+      body&.each do |row|
+        row.each_with_index do |cell, i|
+          col_widths[i] = [col_widths[i] || 0, cell.length].max
+        end
+      end
+
+      result = []
+      border_style = @styles[:table_border]
+      header_style = @styles[:table_header]
+
+      # Top border
+      top = col_widths.map { |w| "─" * (w + 2) }.join("┬")
+      result << border_style.render + "┌" + top + "┐" + "\e[0m"
+
+      # Header row
+      header_cells = header.each_with_index.map do |cell, i|
+        " " + header_style.render + cell.ljust(col_widths[i]) + "\e[0m" + " "
+      end
+      result << border_style.render + "│" + "\e[0m" + header_cells.join(border_style.render + "│" + "\e[0m") + border_style.render + "│" + "\e[0m"
+
+      # Header separator
+      sep = col_widths.map { |w| "━" * (w + 2) }.join("┿")
+      result << border_style.render + "┝" + sep + "┥" + "\e[0m"
+
+      # Body rows
+      body&.each do |row|
+        cells = row.each_with_index.map do |cell, i|
+          width = col_widths[i] || cell.length
+          " " + apply_inline_styles(cell).ljust(width) + " "
+        end
+        # Pad missing cells
+        while cells.length < col_widths.length
+          cells << " " * (col_widths[cells.length] + 2)
+        end
+        result << border_style.render + "│" + "\e[0m" + cells.join(border_style.render + "│" + "\e[0m") + border_style.render + "│" + "\e[0m"
+      end
+
+      # Bottom border
+      bottom = col_widths.map { |w| "─" * (w + 2) }.join("┴")
+      result << border_style.render + "└" + bottom + "┘" + "\e[0m"
+
+      result << ""
+      result
+    end
+
+    # Render paragraph
+    def render_paragraph(text, max_width)
+      styled = apply_inline_styles(text)
+
+      # Word wrap
+      words = styled.split(/(\s+)/)
+      lines = []
+      current_line = ""
+      current_width = 0
+
+      words.each do |word|
+        word_width = Cells.cell_len(Control.strip_ansi(word))
+
+        if current_width + word_width > max_width && !current_line.empty?
+          lines << current_line.rstrip
+          current_line = ""
+          current_width = 0
+        end
+
+        current_line += word
+        current_width += word_width
+      end
+
+      lines << current_line.rstrip unless current_line.empty?
+      lines << ""
+
+      lines
+    end
+
+    # Apply inline styles (bold, italic, code, links)
+    def apply_inline_styles(text)
+      result = text.dup
+
+      # Bold italic (***text*** or ___text___)
+      result.gsub!(/(\*\*\*|___)([^*_]+)\1/) do
+        @styles[:bold_italic].render + ::Regexp.last_match(2) + "\e[0m"
+      end
+
+      # Bold (**text** or __text__)
+      result.gsub!(/(\*\*|__)([^*_]+)\1/) do
+        @styles[:bold].render + ::Regexp.last_match(2) + "\e[0m"
+      end
+
+      # Italic (*text* or _text_)
+      result.gsub!(/(\*|_)([^*_]+)\1/) do
+        @styles[:italic].render + ::Regexp.last_match(2) + "\e[0m"
+      end
+
+      # Strikethrough (~~text~~)
+      result.gsub!(/~~([^~]+)~~/) do
+        @styles[:strikethrough].render + ::Regexp.last_match(1) + "\e[0m"
+      end
+
+      # Inline code (`code`)
+      result.gsub!(/`([^`]+)`/) do
+        @styles[:code_inline].render + ::Regexp.last_match(1) + "\e[0m"
+      end
+
+      # Links [text](url)
+      result.gsub!(/\[([^\]]+)\]\(([^)]+)\)/) do
+        text_part = ::Regexp.last_match(1)
+        url = ::Regexp.last_match(2)
+
+        if @hyperlinks
+          @styles[:link].render + Control.hyperlink(url, text_part) + "\e[0m"
+        else
+          @styles[:link].render + text_part + "\e[0m" + " (" + @styles[:link_url].render + url + "\e[0m" + ")"
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/rich/markup.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative "style"
+require_relative "text"
+
+module Rich
+  # Markup parsing error
+  class MarkupError < StandardError
+  end
+
+  # Parser for Rich markup syntax: [style]text[/style]
+  module Markup
+    # Tag regex for matching markup tags, excluding escaped ones
+    TAG_REGEX = /(?<!\\)\[(?<closing>\/)?(?<tag>[^\[\]\/]*)\]/
+
+    class << self
+      # Parse markup into a Text object
+      # @param markup [String] Markup text
+      # @param style [Style, String, nil] Base style
+      # @return [Text]
+      def parse(markup, style: nil)
+        result_text = Text.new(style: style)
+        style_stack = []
+        pos = 0
+
+        markup.scan(TAG_REGEX) do
+          match = Regexp.last_match
+          tag_start = match.begin(0)
+
+          # Add text before tag
+          if tag_start > pos
+            pre_text = unescape(markup[pos...tag_start])
+            start_pos = result_text.length
+            result_text.append(pre_text)
+
+            # Apply stacked styles to this text
+            style_stack.each do |stacked_style|
+              result_text.spans << Span.new(start_pos, result_text.length, stacked_style)
+            end
+          end
+
+          # Process tag
+          if match[:closing]
+            # Closing tag - pop style
+            style_stack.pop unless style_stack.empty?
+          else
+            # Opening tag - parse and push style
+            tag_content = match[:tag].strip
+            if tag_content.empty?
+              # Literal []
+              result_text.append("[]")
+            else
+              begin
+                parsed_style = Style.parse(tag_content)
+                style_stack << parsed_style
+              rescue StandardError
+                # Invalid style, treat as literal text
+                result_text.append("[#{tag_content}]")
+              end
+            end
+          end
+
+          pos = match.end(0)
+        end
+
+        # Add remaining text
+        if pos < markup.length
+          remaining = unescape(markup[pos..])
+          start_pos = result_text.length
+          result_text.append(remaining)
+
+          style_stack.each do |stacked_style|
+            result_text.spans << Span.new(start_pos, result_text.length, stacked_style)
+          end
+        end
+
+        result_text
+      end
+
+      # Render markup directly to ANSI string
+      # @param markup [String] Markup text
+      # @param color_system [Symbol] Color system
+      # @return [String]
+      def render(markup, color_system: ColorSystem::TRUECOLOR)
+        parse(markup).render(color_system: color_system)
+      end
+
+      # Escape text for use in markup (escape square brackets)
+      # @param text [String] Text to escape
+      # @return [String]
+      def escape(text)
+        text.gsub(/[\[\]]/) { |m| "\\#{m}" }
+      end
+
+      # Unescape markup text
+      # @param text [String] Text to unescape
+      # @return [String]
+      def unescape(text)
+        text.gsub(/\\([\[\]\\])/, '\1')
+      end
+
+      # Strip markup tags from text
+      # @param markup [String] Markup text
+      # @return [String]
+      def strip(markup)
+        markup.gsub(TAG_REGEX, "")
+      end
+
+      # Check if text contains markup
+      # @param text [String] Text to check
+      # @return [Boolean]
+      def contains_markup?(text)
+        text.match?(TAG_REGEX)
+      end
+
+      # Extract all tags from markup
+      # @param markup [String] Markup text
+      # @return [Array<Hash>] Array of tag info
+      def extract_tags(markup)
+        tags = []
+
+        markup.scan(TAG_REGEX) do
+          match = Regexp.last_match
+          tags << {
+            position: match.begin(0),
+            closing: !match[:closing].nil?,
+            tag: match[:tag].to_s.strip,
+            full_match: match[0]
+          }
+        end
+
+        tags
+      end
+
+      # Validate markup (check for unclosed tags)
+      # @param markup [String] Markup to validate
+      # @return [Array<String>] List of errors (empty if valid)
+      def validate(markup)
+        errors = []
+        open_tags = []
+
+        extract_tags(markup).each do |tag|
+          if tag[:closing]
+            if open_tags.empty?
+              errors << "Unexpected closing tag [/#{tag[:tag]}] at position #{tag[:position]}"
+            else
+              # In Rich, [/] closes the LAST tag, [ /tag] closes specific tag
+              # Let's keep it simple for now: pop last.
+              # If tag name matches, pop it. If it doesn't match and not empty, it's an error.
+              last_tag = open_tags.pop
+              if !tag[:tag].empty? && tag[:tag] != last_tag
+                errors << "Mismatched closing tag [/#{tag[:tag]}] for [#{last_tag}]"
+              end
+            end
+          else
+            open_tags << tag[:tag]
+          end
+        end
+
+        open_tags.each do |tag|
+          errors << "Unclosed tag [#{tag}]"
+        end
+
+        errors
+      end
+
+      # Check if markup is valid
+      # @param markup [String] Markup to check
+      # @return [Boolean]
+      def valid?(markup)
+        validate(markup).empty?
+      end
+    end
+  end
+end