ruby_rich 0.4.7 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f66e41bbaf0499f11d62693a7d39addf65dd1bdf5e86f2a90a1f4048293bc639
-  data.tar.gz: cccaf6008a1c66532bb8efea80433b76532ee281e8c45f7ea9d29b39f315e0fa
+  metadata.gz: 852764b68219de1ce528f772a55c3e454b3556c35aa9f0c0e89c29f31c2293ba
+  data.tar.gz: e2827430cb5dada9ae7d8ca1cb59d9fbca4df95790404c1bcb893e7323864b95
 SHA512:
-  metadata.gz: 9a7da5985548800496d5f896fbd2d1335673140d3337375d4e44e25df4ec577c74026e8af363e601d3bf9a5813f670d7c2251839a5b9cab0bafef77a1f588239
-  data.tar.gz: 6c5cc67a1c8a8a85622021e17b5fdb6b65504c273713668ede8b1f641eb33ce2344fd14b852310f17761c026d044a9049a51f74cb8c8d053f294578c0a938c13
+  metadata.gz: 95388b58b409347a55ebd1ef3dded1d3520810c7f31292bb83e14dd73192f356ec453b5688dd9dc122ae1e626ff365d6738c2d9a4de799adf53df2b2cced8916
+  data.tar.gz: 342ed768c7a9f04fadc1da1ec1d775fbbbdf482fc446f55ed69b4eb880159118cd36f6860c11964ddcc7371e70bcc35adcca0203183fcc558a604bd43786091e

data/lib/ruby_rich/markdown.rb

@@ -1,213 +1,515 @@
-require 'redcarpet'
+require 'kramdown'
 
 module RubyRich
   class Markdown
-    # Converts markdown to ANSI-styled terminal output.
-    # Uses Redcarpet for block parsing with custom inline processing.
-    class TerminalRenderer < Redcarpet::Render::Base
-      INLINE_MARKERS = {
-        # triple-backtick must come before double-backtick
-        %r{```(.+?)```}m => ->(m) { codespan_compat(Regexp.last_match(1)) },
-        %r{``(.+?)``}m   => ->(m) { codespan_compat(Regexp.last_match(1)) },
-        %r{`(.+?)`}      => ->(m) { codespan_compat(Regexp.last_match(1)) },
-        %r{\*\*\*(.+?)\*\*\*} => ->(m) { "#{AnsiCode.bold}#{AnsiCode.italic}#{Regexp.last_match(1)}#{AnsiCode.reset}" },
-        %r{\*\*(.+?)\*\*}     => ->(m) { "#{AnsiCode.bold}#{Regexp.last_match(1)}#{AnsiCode.reset}" },
-        %r{(?<!\*)\*([^*]+)\*(?!\*)} => ->(m) { "#{AnsiCode.italic}#{Regexp.last_match(1)}#{AnsiCode.reset}" },
-        %r{~~(.+?)~~}     => ->(m) { "#{AnsiCode.strikethrough}#{Regexp.last_match(1)}#{AnsiCode.reset}" },
-        %r{\[([^\]]+)\]\(([^)]+)\)} => ->(m) {
-          link_text = Regexp.last_match(1)
-          url = Regexp.last_match(2)
-          "#{AnsiCode.color(:blue, true)}#{AnsiCode.underline}#{link_text}#{AnsiCode.reset} #{AnsiCode.color(:black, true)}(#{url})#{AnsiCode.reset}"
-        }
-      }.freeze
-
-      def initialize(options = {})
-        @options = {
-          width: 80,
-          indent: '  '
-        }.merge(options)
-        super()
-        reset_table_state
-      end
-
-      def reset_table_state
-        @table_state = { current_row: [], all_rows: [] }
-      end
-
-      # ---- block-level callbacks ----
-
-      def paragraph(text)
-        "#{process_inline(text)}\n\n"
-      end
-
-      def header(text, level)
-        processed = process_inline(text)
+    # 将 Markdown 转换为 ANSI 终端输出。
+    # 使用 kramdown 的 AST 遍历 + 自定义 Converter 实现。
+    #
+    # kramdown 比 redcarpet 的优势：
+    #   - 纯 Ruby 实现，无需 C 扩展编译
+    #   - 原生 GFM 支持（表格、任务列表、删除线）
+    #   - 定义列表 (definition lists)
+    #   - 脚注 (footnotes)
+    #   - 数学公式 (需 math engine)
+    #   - 缩写 (abbreviations)
+    #   - 活跃维护
+    class TerminalConverter < Kramdown::Converter::Base
+
+      def initialize(root, options)
+        super
+        @width = options[:width] || 80
+        @indent_str = options[:indent] || '  '
+        @table_border_style = options[:table_border_style] || :simple
+        # 用于有序列表编号
+        @list_counters = []
+      end
+
+      # 主分发方法 — 根据 AST 元素类型路由到对应处理方法
+      def convert(el, _indent = 0)
+        case el.type
+        when :root         then convert_children(el)
+        when :blank        then "\n"
+        when :text         then el.value
+        when :p            then convert_p(el)
+        when :header       then convert_header(el)
+        when :codeblock    then convert_codeblock(el)
+        when :codespan     then convert_codespan(el)
+        when :blockquote   then convert_blockquote(el)
+        when :ul           then convert_list(el)
+        when :ol           then convert_list(el)
+        when :li           then convert_li(el)
+        when :em           then convert_em(el)
+        when :strong       then convert_strong(el)
+        when :em_strong    then convert_em_strong(el)
+        when :a            then convert_link(el)
+        when :img          then convert_image(el)
+        when :hr           then convert_hr(el)
+        when :br           then "\n"
+        when :table        then convert_table(el)
+        when :thead        then convert_children(el)
+        when :tbody        then convert_children(el)
+        when :tr           then convert_table_row(el)
+        when :th           then convert_table_cell(el)
+        when :td           then convert_table_cell(el)
+        when :html_element then convert_html_element(el)
+        when :html_entity  then convert_html_entity(el)
+        when :smart_quote  then convert_smart_quote(el)
+        when :entity       then el.value.to_s
+        when :raw          then convert_raw(el)
+        when :comment      then ''
+        when :footnote     then convert_footnote(el)
+        when :dl           then convert_definition_list(el)
+        when :dt           then convert_definition_term(el)
+        when :dd           then convert_definition_desc(el)
+        when :abbreviation then convert_abbreviation(el)
+        when :math         then convert_math(el)
+        else
+          # 未知类型，递归处理子元素
+          if el.children && !el.children.empty?
+            convert_children(el)
+          else
+            el.value || el.text || ''
+          end
+        end
+      end
+
+      private
+
+      # ---- 辅助方法 ----
+
+      def convert_children(el)
+        return '' unless el.children
+        el.children.map { |child| convert(child) }.join
+      end
+
+      def inline_content(el)
+        return '' unless el.children
+        el.children.map { |child| convert(child) }.join
+      end
+
+      def visible_width(text)
+        text.to_s.gsub(/\e\[[0-9;]*m/, '').length
+      end
+
+      # ---- 块级元素 ----
+
+      def convert_p(el)
+        "#{inline_content(el)}\n\n"
+      end
+
+      def convert_header(el)
+        level = el.options[:level] || 1
+        text = inline_content(el)
+        vw = visible_width(text)
         case level
-        when 1 then "#{AnsiCode.font(:cyan, font_bright: true, bold: true)}#{processed}#{AnsiCode.reset}\n#{AnsiCode.color(:cyan, true)}#{'=' * visible_width(text)}#{AnsiCode.reset}\n\n"
-        when 2 then "#{AnsiCode.font(:blue, font_bright: true, bold: true)}#{processed}#{AnsiCode.reset}\n#{AnsiCode.color(:blue, true)}#{'-' * visible_width(text)}#{AnsiCode.reset}\n\n"
-        when 3 then "#{AnsiCode.font(:yellow, font_bright: true, bold: true)}### #{processed}#{AnsiCode.reset}\n\n"
-        else        "#{AnsiCode.font(:black, font_bright: true, bold: true)}#{'#' * level} #{processed}#{AnsiCode.reset}\n\n"
+        when 1
+          "#{AnsiCode.font(:cyan, font_bright: true, bold: true)}#{text}#{AnsiCode.reset}\n" \
+          "#{AnsiCode.color(:cyan, true)}#{'=' * [vw, 1].max}#{AnsiCode.reset}\n\n"
+        when 2
+          "#{AnsiCode.font(:blue, font_bright: true, bold: true)}#{text}#{AnsiCode.reset}\n" \
+          "#{AnsiCode.color(:blue, true)}#{'-' * [vw, 1].max}#{AnsiCode.reset}\n\n"
+        when 3
+          "#{AnsiCode.font(:yellow, font_bright: true, bold: true)}### #{text}#{AnsiCode.reset}\n\n"
+        else
+          prefix = '#' * level
+          "#{AnsiCode.font(:black, font_bright: true, bold: true)}#{prefix} #{text}#{AnsiCode.reset}\n\n"
         end
       end
 
-      def block_code(code, language)
-        lang = language&.strip
+      def convert_codeblock(el)
+        lang = el.options[:lang]&.strip
         lang = nil if lang && lang.empty?
-        highlighted = Syntax.highlight(code.strip, lang)
-        bg  = AnsiCode.background(:black, true)
-        fg  = AnsiCode.color(:white, true)
-        pad = @options[:indent]
+        code = el.value.strip
+        highlighted = Syntax.highlight(code, lang)
+        bg = AnsiCode.background(:black, true)
+        fg = AnsiCode.color(:white, true)
         "#{bg}#{fg}#{indent_lines(highlighted)}#{AnsiCode.reset}\n\n"
       end
 
-      def codespan(code)
+      def convert_codespan(el)
+        code = el.value
         "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{code} #{AnsiCode.reset}"
       end
 
-      def block_quote(quote)
-        lines = quote.strip.split("\n")
-        quoted_lines = lines.map { |line| "#{AnsiCode.color(:black, true)}│ #{AnsiCode.color(:white, true)}#{process_inline(line.strip)}" }
-        "#{quoted_lines.join("\n")}#{AnsiCode.reset}\n\n"
+      def convert_blockquote(el)
+        content = inline_content(el)
+        lines = content.strip.split("\n")
+        quoted = lines.map do |line|
+          "#{AnsiCode.color(:black, true)}│ #{AnsiCode.color(:white, true)}#{strip_ansi_reset(line)}"
+        end
+        "#{quoted.join("\n")}#{AnsiCode.reset}\n\n"
       end
 
-      def list_item(text, list_type)
-        marker = list_type == :ordered ? '1.' : '•'
-        "#{AnsiCode.color(:cyan, true)}#{marker}#{AnsiCode.reset} #{process_inline(text.strip)}\n"
+      # ---- 列表 ----
+
+      def convert_list(el)
+        # 保存/恢复计数器，支持嵌套列表
+        @list_counters.push(0)
+        result = convert_children(el)
+        @list_counters.pop
+        "#{result}\n"
       end
 
-      def list(contents, list_type)
-        "#{contents}\n"
+      def convert_li(el)
+        marker = if el.options[:parent]&.type == :ol
+          @list_counters[-1] += 1
+          "#{@list_counters[-1]}."
+        else
+          '•'
+        end
+        text = inline_content(el)
+        "#{AnsiCode.color(:cyan, true)}#{marker}#{AnsiCode.reset} #{text.strip}\n"
       end
 
-      def emphasis(text)
-        "#{AnsiCode.italic}#{text}#{AnsiCode.reset}"
+      # ---- 内联样式 ----
+
+      def convert_em(el)
+        "#{AnsiCode.italic}#{inline_content(el)}#{AnsiCode.reset}"
       end
-      def double_emphasis(text)
-        "#{AnsiCode.bold}#{text}#{AnsiCode.reset}"
+
+      def convert_strong(el)
+        "#{AnsiCode.bold}#{inline_content(el)}#{AnsiCode.reset}"
       end
-      def strikethrough(text)
-        "#{AnsiCode.strikethrough}#{text}#{AnsiCode.reset}"
+
+      def convert_em_strong(el)
+        "#{AnsiCode.bold}#{AnsiCode.italic}#{inline_content(el)}#{AnsiCode.reset}"
       end
 
-      def link(link, title, content)
+      # ---- 链接与图片 ----
+
+      def convert_link(el)
+        url = el.attr['href'] || ''
+        title = el.attr['title']
+        text = inline_content(el)
         title_part = title && !title.empty? ? " - #{title}" : ""
-        "#{AnsiCode.color(:blue, true)}#{AnsiCode.underline}#{content}#{AnsiCode.reset} #{AnsiCode.color(:black, true)}(#{link}#{title_part})#{AnsiCode.reset}"
+        "#{AnsiCode.color(:blue, true)}#{AnsiCode.underline}#{text}#{AnsiCode.reset} " \
+        "#{AnsiCode.color(:black, true)}(#{url}#{title_part})#{AnsiCode.reset}"
       end
 
-      def image(link, title, alt_text)
+      def convert_image(el)
+        url = el.attr['src'] || ''
+        title = el.attr['title']
+        alt = el.attr['alt'] || ''
         title_part = title && !title.empty? ? " - #{title}" : ""
-        "#{AnsiCode.color(:magenta, true)}[Image: #{alt_text}]#{AnsiCode.reset} #{AnsiCode.color(:black, true)}(#{link}#{title_part})#{AnsiCode.reset}"
+        "#{AnsiCode.color(:magenta, true)}[Image: #{alt}]#{AnsiCode.reset} " \
+        "#{AnsiCode.color(:black, true)}(#{url}#{title_part})#{AnsiCode.reset}"
       end
 
-      def hrule
-        "#{AnsiCode.color(:black, true)}#{"─" * @options[:width]}#{AnsiCode.reset}\n\n"
-      end
+      # ---- 水平线 ----
 
-      def linebreak
-        "\n"
+      def convert_hr(_el)
+        line_char = '─'
+        "#{AnsiCode.color(:black, true)}#{line_char * @width}#{AnsiCode.reset}\n\n"
       end
 
-      # ---- table callbacks ----
-
-      def table(header, body)
-        all_rows = @table_state[:all_rows]
-        reset_table_state
-        return "" if all_rows.empty?
-
-        header_line_count = [header.to_s.strip.split("\n").size, 1].max
-        header_rows = all_rows[0...header_line_count]
-        body_rows = all_rows[header_line_count..] || []
+      # ---- 表格（kramdown 原生 AST） ----
+
+      def convert_table(el)
+        # 收集表头行和表体行
+        header_rows = []
+        body_rows = []
+        el.children.each do |section|
+          case section.type
+          when :thead
+            section.children.each { |tr| header_rows << collect_row_cells(tr) }
+          when :tbody
+            section.children.each { |tr| body_rows << collect_row_cells(tr) }
+          when :tr
+            body_rows << collect_row_cells(section)
+          end
+        end
 
         return "" if header_rows.empty? || body_rows.empty?
 
-        headers = header_rows.last.map { |c| process_inline(c) }
+        headers, fitted_body_rows = fit_table_rows(header_rows.last, body_rows)
         begin
-          tbl = RubyRich::Table.new(headers: headers, border_style: @options[:table_border_style] || :simple)
-          body_rows.each do |row|
-            processed = row.map { |c| process_inline(c) }
-            padded = processed + Array.new([0, headers.length - processed.length].max, "")
+          tbl = RubyRich::Table.new(
+            headers: headers,
+            border_style: @table_border_style || :simple
+          )
+          fitted_body_rows.each do |row|
+            padded = row + Array.new([0, headers.length - row.length].max, "")
             tbl.add_row(padded[0...headers.length])
           end
-          return "#{tbl.render}\n\n"
+          "#{tbl.render}\n\n"
         rescue
-          # fallback
+          # fallback: plain text table
+          result = "\n"
+          result += header_rows.last.join(" | ")
+          result += "\n#{"-" * [result.strip.length, 20].min}\n"
+          body_rows.each { |row| result += row.join(" | ") + "\n" }
+          return "#{result}\n"
         end
+      end
 
-        result = "\n"
-        result += "#{header.strip}\n"
-        result += "#{"-" * [header.strip.length, 20].min}\n"
-        result += "#{body.strip}\n" if body && !body.strip.empty?
-        "#{result}\n"
+      # Extract cell text from a table row element.
+      def collect_row_cells(tr)
+        tr.children.select { |c| [:th, :td].include?(c.type) }
+          .map { |c| inline_content(c) }
       end
 
-      def table_row(content)
-        @table_state[:all_rows] << @table_state[:current_row].dup
-        @table_state[:current_row] = []
-        "#{content}\n"
+      def convert_table_row(el)
+        convert_children(el)
       end
 
-      def table_cell(content, alignment)
-        @table_state[:current_row] << content.strip
-        content
+      def convert_table_cell(el)
+        inline_content(el)
       end
 
-      private
+      # ---- 表格宽度自适应 ----
+
+      # Fit table cell content to terminal width by normalising column counts,
+      # calculating natural widths, constraining to available space, and wrapping
+      # cell text.
+      def fit_table_rows(header_row, body_rows)
+        column_count = [header_row.length, *body_rows.map(&:length)].max.to_i
+        normalized_header = header_row + Array.new([0, column_count - header_row.length].max, "")
+        normalized_body = body_rows.map { |row| row + Array.new([0, column_count - row.length].max, "") }
+        natural_widths = table_natural_widths(normalized_header, normalized_body)
+        column_widths = constrain_table_widths(natural_widths)
+
+        headers = normalized_header.each_with_index.map { |cell, index| wrap_table_cell(table_cell_text(cell), column_widths[index]) }
+        rows = normalized_body.map do |row|
+          row.each_with_index.map { |cell, index| wrap_table_cell(table_cell_text(cell), column_widths[index]) }
+        end
 
-      def process_inline(text)
-        return text if text.nil? || text.empty?
+        [headers, rows]
+      end
+
+      # Maximum display width per column.
+      def table_natural_widths(header_row, body_rows)
+        rows = [header_row] + body_rows
+        return [] if rows.empty?
 
-        result = text.dup
-        INLINE_MARKERS.each do |regex, handler|
-          result.gsub!(regex, &handler)
+        rows.transpose.map do |cells|
+          cells.map { |cell| cell_display_width(table_cell_text(cell)) }.max.to_i
         end
-        result
       end
 
-      def self.codespan_compat(code)
-        "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{code} #{AnsiCode.reset}"
+      # Strip ANSI escape sequences from a cell value.
+      def table_cell_text(cell)
+        cell.to_s.gsub(/\e\[[0-9;:]*m/, "")
+      end
+
+      # Shrink column widths proportionally to fit the terminal width.
+      def constrain_table_widths(natural_widths)
+        return natural_widths if natural_widths.empty?
+
+        border_overhead = (natural_widths.length * 3) + 1
+        max_table_width = [[(@width || 80).to_i - 1, 20].max, border_overhead + natural_widths.length].max
+        available_content_width = [max_table_width - border_overhead, natural_widths.length].max
+        widths = natural_widths.map { |width| [width, 1].max }
+        return widths if widths.sum <= available_content_width
+
+        min_width = available_content_width < natural_widths.length * 3 ? 1 : 3
+        while widths.sum > available_content_width
+          index = widths.each_with_index.select { |width, _| width > min_width }.max_by(&:first)&.last
+          break unless index
+
+          widths[index] -= 1
+        end
+        widths
+      end
+
+      # Wrap cell text to fit a given display width, splitting across newlines
+      # and wrapping long lines.
+      def wrap_table_cell(text, width)
+        width = [width.to_i, 1].max
+        text.to_s.split("\n", -1).flat_map do |line|
+          wrap_table_line(line, width)
+        end.join("\n")
       end
 
-      def wrap_text(text, width = nil)
-        width ||= @options[:width]
-        return text if text.length <= width
+      # Wrap a single line of text to the given display width, preserving any
+      # ANSI escape sequences (re-emitted on each wrapped segment).
+      def wrap_table_line(line, width)
+        return [""] if line.empty?
 
-        words = text.split(' ')
         lines = []
-        current_line = ''
+        current = +""
+        current_width = 0
+        in_escape = false
+        escape = +""
+
+        line.each_char do |char|
+          if in_escape
+            escape << char
+            if char == "m"
+              current << escape
+              escape = +""
+              in_escape = false
+            end
+            next
+          elsif char.ord == 27
+            escape << char
+            in_escape = true
+            next
+          end
 
-        words.each do |word|
-          if (current_line + ' ' + word).length <= width
-            current_line += current_line.empty? ? word : ' ' + word
-          else
-            lines << current_line unless current_line.empty?
-            current_line = word
+          char_width = Unicode::DisplayWidth.of(char)
+          if current_width.positive? && current_width + char_width > width
+            lines << current
+            current = +""
+            current_width = 0
           end
+          current << char
+          current_width += char_width
+        end
+
+        lines << current unless current.empty?
+        lines.empty? ? [""] : lines
+      end
+
+      # Display width of text after stripping ANSI escape sequences, taking the
+      # maximum across lines (for multi-line cells).
+      def cell_display_width(text)
+        text.to_s.gsub(/\e\[[0-9;:]*m/, "").split("\n").map(&:display_width).max.to_i
+      end
+
+      # ---- HTML 元素处理 ----
+
+      def convert_html_element(el)
+        tag = el.value.to_s.downcase
+        content = inline_content(el)
+
+        case tag
+        when 'del', 's', 'strike'
+          "#{AnsiCode.strikethrough}#{content}#{AnsiCode.reset}"
+        when 'ins', 'u'
+          "#{AnsiCode.underline}#{content}#{AnsiCode.reset}"
+        when 'sub'
+          content  # 终端无下标，保留文本
+        when 'sup'
+          content  # 终端无上标，保留文本
+        when 'kbd'
+          "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{content} #{AnsiCode.reset}"
+        when 'mark'
+          "#{AnsiCode.background(:yellow)}#{AnsiCode.color(:black)}#{content}#{AnsiCode.reset}"
+        when 'details', 'summary'
+          content
+        when 'br'
+          "\n"
+        when 'hr'
+          convert_hr(nil)
+        else
+          content
+        end
+      end
+
+      def convert_html_entity(el)
+        # kramdown 已解析 HTML 实体为 UTF-8 字符
+        el.value.to_s
+      end
+
+      # ---- 智能引号 ----
+
+      def convert_smart_quote(el)
+        case el.value
+        when :lsquo then "'"
+        when :rsquo then "'"
+        when :ldquo then '"'
+        when :rdquo then '"'
+        else el.value.to_s
+        end
+      end
+
+      # ---- 原始内容 ----
+
+      def convert_raw(el)
+        # 原始 HTML，在终端中通常跳过
+        el.value.to_s.start_with?('<') ? '' : el.value.to_s
+      end
+
+      # ---- 脚注 ----
+
+      def convert_footnote(el)
+        # 脚注内容在文档末尾自动收集
+        content = inline_content(el)
+        name = el.options[:name]
+        "#{AnsiCode.color(:magenta, true)}[^#{name}]#{AnsiCode.reset}"
+      end
+
+      # ---- 定义列表（kramdown 独有） ----
+
+      def convert_definition_list(el)
+        "#{convert_children(el)}\n"
+      end
+
+      def convert_definition_term(el)
+        "#{AnsiCode.bold}#{inline_content(el)}#{AnsiCode.reset}\n"
+      end
+
+      def convert_definition_desc(el)
+        "#{@indent_str}#{inline_content(el)}\n\n"
+      end
+
+      # ---- 缩写（kramdown 独有） ----
+
+      def convert_abbreviation(el)
+        title = el.attr['title']
+        text = inline_content(el)
+        if title && !title.empty?
+          "#{AnsiCode.underline}#{text}#{AnsiCode.reset}#{AnsiCode.color(:black, true)}(#{title})#{AnsiCode.reset}"
+        else
+          text
         end
+      end
+
+      # ---- 数学公式（kramdown 独有，需 math engine） ----
 
-        lines << current_line unless current_line.empty?
-        lines.join("\n")
+      def convert_math(el)
+        # 在终端中显示原始 LaTeX 公式
+        mode = el.options[:category] == :block ? 'block' : 'inline'
+        formula = el.value.to_s.strip
+        if mode == 'block'
+          "#{AnsiCode.color(:magenta, true)}[Math]\n#{formula}\n[/Math]#{AnsiCode.reset}\n\n"
+        else
+          "#{AnsiCode.color(:magenta, true)}[Math: #{formula}]#{AnsiCode.reset}"
+        end
       end
 
+      # ---- 辅助 ----
+
       def indent_lines(text)
-        text.split("\n").map { |line| "#{@options[:indent]}#{line}" }.join("\n")
+        text.split("\n").map { |line| "#{@indent_str}#{line}" }.join("\n")
       end
 
-      def visible_width(text)
-        text.gsub(/\e\[[0-9;]*m/, '').length
+      def strip_ansi_reset(text)
+        # 去掉末尾 AnsiCode.reset，让 blockquote 统一添加
+        text.gsub(/\e\[0m$/, '')
       end
     end
 
+    # ---- 公开 API ----
+
+    # 渲染 Markdown 文本为 ANSI 终端输出
+    #
+    # @param markdown_text [String] 输入的 Markdown 文本
+    # @param options [Hash] 渲染选项
+    # @option options [Integer] :width 终端宽度（默认 80）
+    # @option options [String] :indent 缩进字符串（默认 '  '）
+    # @option options [Symbol] :table_border_style 表格边框样式 (:none, :simple, :full)
+    # @option options [Hash] :kramdown 传递给 Kramdown::Document 的额外选项
+    #
+    # @return [String] ANSI 格式的终端输出
     def self.render(markdown_text, options = {})
-      renderer = TerminalRenderer.new(options)
-      markdown_processor = Redcarpet::Markdown.new(renderer, {
-        fenced_code_blocks: true,
-        tables: true,
-        autolink: true,
-        strikethrough: true,
-        space_after_headers: true
-      })
-
-      markdown_processor.render(markdown_text)
+      converter_options = {
+        width: options[:width] || 80,
+        indent: options[:indent] || '  ',
+        table_border_style: options[:table_border_style] || :simple
+      }
+
+      kramdown_opts = {
+        input: 'GFM',                 # GitHub Flavored Markdown
+        syntax_highlighter: nil,      # 自行处理语法高亮
+        hard_wrap: false,
+        html_to_native: true,
+        line_width: converter_options[:width]
+      }.merge(options[:kramdown] || {})
+
+      doc = Kramdown::Document.new(markdown_text, kramdown_opts)
+      result, _warnings = TerminalConverter.convert(doc.root, converter_options)
+      result
     end
 
     def initialize(options = {})
@@ -218,4 +520,4 @@ module RubyRich
       self.class.render(markdown_text, @options)
     end
   end
-end
+end

data/lib/ruby_rich/transcript.rb

@@ -412,6 +412,8 @@ module RubyRich
     private
 
     def render_entry(entry, index)
+      return entry.content.to_s.split("\n", -1) if entry.metadata[:plain]
+
       case entry.type
       when :user
         render_plain_message(entry.content, first_prefix: "#{AnsiCode.color(:blue, true)}●#{AnsiCode.reset} ", rest_prefix: "  ")

data/lib/ruby_rich/version.rb

@@ -1,3 +1,3 @@
 module RubyRich
-  VERSION = "0.4.7"
+  VERSION = "0.4.9"
 end

data/lib/ruby_rich/viewport.rb

@@ -1,11 +1,21 @@
 # frozen_string_literal: true
 
+require "base64"
+
 module RubyRich
   class Viewport
     attr_accessor :width, :height, :scroll_top
     attr_reader :content, :selected_text
 
-    def initialize(content = "", scrollbar: true, auto_scroll: false, scrollbar_style: :blue)
+    # drag_mode controls what left-click drag does in the content area:
+    #   :viewport  – drag scrolls the viewport (default, backward-compatible)
+    #   :selection – drag selects text
+    DRAG_MODES = [:viewport, :selection].freeze
+
+    def initialize(content = "",
+                   scrollbar: true, auto_scroll: false,
+                   scrollbar_style: :blue, auto_copy: true,
+                   drag_mode: :viewport)
       @content = content
       @scrollbar = scrollbar
       @auto_scroll = auto_scroll
@@ -22,6 +32,8 @@ module RubyRich
       @selection_end = nil
       @selected_text = ""
       @focused = true
+      @auto_copy = auto_copy
+      @drag_mode = DRAG_MODES.include?(drag_mode) ? drag_mode : :viewport
       @rendered_lines_cache_key = nil
       @rendered_lines_cache = nil
     end
@@ -88,10 +100,14 @@ module RubyRich
         true
       when :mouse_down
         return copy_selection if event_data[:button] == :right
-
-        start_scrollbar_drag(event_data, layout) || start_viewport_drag(event_data, layout)
+        if @drag_mode == :selection
+          start_scrollbar_drag(event_data, layout) || start_selection(event_data, layout)
+        else
+          start_scrollbar_drag(event_data, layout) || start_viewport_drag(event_data, layout)
+        end
       when :mouse_drag
-        drag_scrollbar(event_data, layout) || drag_viewport(event_data, layout) || drag_selection(event_data, layout)
+        drag_scrollbar(event_data, layout) ||
+          (@drag_mode == :selection ? drag_selection(event_data, layout) : (drag_viewport(event_data, layout) || drag_selection(event_data, layout)))
       when :mouse_up
         stop_scrollbar_drag || stop_viewport_drag || stop_selection
       else
@@ -415,7 +431,7 @@ module RubyRich
 
       @selecting = false
       @selected_text = extract_selected_text
-      copy_selection
+      copy_selection if @auto_copy
       true
     end
 
@@ -477,6 +493,7 @@ module RubyRich
           escape << char
           if char == "m"
             result << escape
+            result << AnsiCode.inverse if active
             escape = +""
             in_escape = false
           end
@@ -531,18 +548,61 @@ module RubyRich
       text.gsub(/\e\[[0-9;:]*m/, "")
     end
 
+    # Copy text to the system clipboard, trying every available method in
+    # sequence and falling back to the OSC 52 terminal clipboard so that
+    # remote (SSH) sessions also work.
     def copy_to_clipboard(text)
-      if RubyRich::Terminal.windows?
-        copy_to_windows_clipboard(text)
-      elsif ENV["WAYLAND_DISPLAY"]
-        IO.popen("wl-copy", "w") { |io| io.write(text) }
-      elsif ENV["DISPLAY"]
-        IO.popen("xclip -selection clipboard", "w") { |io| io.write(text) }
-      elsif RUBY_PLATFORM.match?(/darwin/)
-        IO.popen("pbcopy", "w") { |io| io.write(text) }
+      text = text.to_s
+      return false if text.empty?
+      return true if RubyRich::Terminal.windows? && try_windows_clipboard(text)
+
+      clipboard_commands.each do |command|
+        return true if write_clipboard_command(command, text)
+      end
+
+      copy_to_terminal_clipboard(text)
+    end
+
+    # Ordered list of [command, *args] arrays to try for clipboard access.
+    def clipboard_commands
+      commands = []
+      commands << ["wl-copy"] if ENV["WAYLAND_DISPLAY"]
+      if ENV["DISPLAY"]
+        commands << ["xclip", "-selection", "clipboard"]
+        commands << ["xsel", "--clipboard", "--input"]
       end
+      commands << ["pbcopy"] if RUBY_PLATFORM.match?(/darwin/)
+      commands
+    end
+
+    # Attempt to write text to a given clipboard command via a pipe.
+    # Returns true when the subprocess exits successfully.
+    def write_clipboard_command(command, text)
+      IO.popen(command, "w") { |io| io.write(text) }
+      $?&.success? == true
     rescue IOError, SystemCallError
-      nil
+      false
+    end
+
+    # Try the OS-specific Windows clipboard helper and return true when it
+    # succeeds (any IO/Syscall error is treated as failure).
+    def try_windows_clipboard(text)
+      copy_to_windows_clipboard(text)
+      true
+    rescue IOError, SystemCallError
+      false
+    end
+
+    # OSC 52 terminal clipboard – the only fallback that works over SSH.
+    # Encoded payload is emitted on stdout for the hosting terminal to
+    # capture.
+    def copy_to_terminal_clipboard(text)
+      encoded = Base64.strict_encode64(text.encode(Encoding::UTF_8))
+      $stdout.print("\e]52;c;#{encoded}\a")
+      $stdout.flush
+      true
+    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError, IOError, SystemCallError
+      false
     end
 
     def copy_to_windows_clipboard(text)
@@ -559,4 +619,4 @@ module RubyRich
       end
     end
   end
-end
+end

data/lib/ruby_rich.rb

@@ -5,7 +5,7 @@ require 'logger'
 require 'rouge'
 require 'tty-cursor'
 require 'tty-screen'
-require 'redcarpet'
+require 'kramdown'
 
 # Load all internal modules
 require_relative 'ruby_rich/console'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rich
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.9
 platform: ruby
 authors:
 - zhuang biaowei
@@ -86,19 +86,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.2
 - !ruby/object:Gem::Dependency
-  name: redcarpet
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.6.1
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.6.1
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
   requirement: !ruby/object:Gem::Requirement
@@ -176,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.13
 specification_version: 4
 summary: Rich text formatting and console output for Ruby
 test_files: []