ruby_rich 0.4.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 568e2001bde24749d1410dadda7e77090963eedc48e9ad9e6d77f036e245a51f
-  data.tar.gz: 99a40412ae33eb985e7b0e1d4dc0516b8539ca32eb79ae7ec881b673d350ecc5
+  metadata.gz: 6db3483399e193c2a8feb97472df06341391d165f07aafde1af299a0892bb83c
+  data.tar.gz: 71ef2db35e2b369953c7201e13bc751001f02815dd2717ea3358964ff12b30b3
 SHA512:
-  metadata.gz: 187311b6561fcfea7c51af5ab44bd8b8dcbead8fabd5108d9356b07eacf82f0994ef5c6c64e00db1764a7cd8a546feb6df17c2ab119f21e11898a924a485499e
-  data.tar.gz: ff1f361748e077f0ad6f59c30b22a8502e83a2196e7ab23a2365ee67362283036f0fb1e3da4eea102cdacfcea1c8c1ab1c08b15e8841c0da1b270182e0497e4b
+  metadata.gz: d4d3b29b2e73d8ebe31e883ba0001cb207f65b2683897d861601918e097823bce393302dd51b276fe15c71608959d28d61c6413e82c26fc0226245cf9b2c358b
+  data.tar.gz: 41274198774c77707e3d052a9b81b1d1e18d2ae293a63b0dadcdbf508b1d74c3892203433d2a4cd92759275ce44b31906f83bd4ee3e10a128fefe3e8b890bcd5

data/lib/ruby_rich/markdown.rb

@@ -13,6 +13,46 @@ module RubyRich
     #   - 数学公式 (需 math engine)
     #   - 缩写 (abbreviations)
     #   - 活跃维护
+
+    # === Markdown rendering colour theme. ===
+    # Each key maps to `[color, bright]` accepted by AnsiCode.
+    MarkdownTheme = {
+      heading_1:         [:cyan,     true],
+      heading_2:         [:blue,     true],
+      heading_3:         [:yellow,   true],
+      heading_4_6:       [:black,    true],
+      heading_underline: [:cyan,     true],  # H1
+      heading_underline2:[:blue,     true],  # H2
+      text:              [:white,    true],
+      strong_text:       [:white,    true],
+      code_border:       [:black,    true],
+      code_bg:           [:black,    true],
+      code_fg:           [:white,    true],
+      inline_code_fg:    [:black,    false],
+      inline_code_bg:    [:white,    false],
+      blockquote_marker: [:black,    true],
+      blockquote_text:   [:white,    true],
+      blockquote_italic: true,
+      list_level_1:      [:cyan,     true],
+      list_level_2:      [:magenta,  true],
+      list_level_3:      [:yellow,   true],
+      ordered_list:      [:cyan,     true],
+      task_checked:      [:green,    true],
+      task_unchecked:    [:black,    true],
+      link_text:         [:blue,     true],
+      link_url:          [:black,    true],
+      image_label:       [:magenta,  true],
+      rule:              [:black,    true],
+      footnote:          [:magenta,  true],
+      abbreviation:      [:black,    true],
+      math:              [:magenta,  true],
+      mark_fg:           [:black,    false],
+      mark_bg:           [:yellow,   false],
+      kbd_fg:            [:black,    false],
+      kbd_bg:            [:white,    false],
+      table_border:      :simple
+    }.freeze
+
     class TerminalConverter < Kramdown::Converter::Base
 
       def initialize(root, options)
@@ -20,8 +60,26 @@ module RubyRich
         @width = options[:width] || 80
         @indent_str = options[:indent] || '  '
         @table_border_style = options[:table_border_style] || :simple
+        @theme = (options[:theme] || MarkdownTheme).freeze
         # 用于有序列表编号
         @list_counters = []
+        @list_types = []
+      end
+    
+      # Shortcut: AnsiCode.color with theme lookup.
+      def tc(key)
+        color, bright = @theme[key]
+        AnsiCode.color(color, bright)
+      end
+
+      def tbg(key)
+        color, bright = @theme[key]
+        AnsiCode.background(color, bright)
+      end
+
+      def tfont(key, **overrides)
+        color, bright = @theme[key]
+        AnsiCode.font(color, font_bright: bright, **overrides)
       end
 
       # 主分发方法 — 根据 AST 元素类型路由到对应处理方法
@@ -88,7 +146,7 @@ module RubyRich
       end
 
       def visible_width(text)
-        text.to_s.gsub(/\e\[[0-9;]*m/, '').length
+        text.to_s.gsub(/\e\[[0-9;]*m/, '').display_width
       end
 
       # ---- 块级元素 ----
@@ -103,39 +161,112 @@ module RubyRich
         vw = visible_width(text)
         case level
         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"
+          "#{tfont(:heading_1, bold: true)}#{text}#{AnsiCode.reset}\n" \
+          "#{tc(:heading_underline)}#{'=' * [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"
+          "#{tfont(:heading_2, bold: true)}#{text}#{AnsiCode.reset}\n" \
+          "#{tc(:heading_underline2)}#{'-' * [vw, 1].max}#{AnsiCode.reset}\n\n"
         when 3
-          "#{AnsiCode.font(:yellow, font_bright: true, bold: true)}### #{text}#{AnsiCode.reset}\n\n"
+          "#{tfont(:heading_3, bold: true)}### #{text}#{AnsiCode.reset}\n\n"
         else
           prefix = '#' * level
-          "#{AnsiCode.font(:black, font_bright: true, bold: true)}#{prefix} #{text}#{AnsiCode.reset}\n\n"
+          "#{tfont(:heading_4_6, bold: true)}#{prefix} #{text}#{AnsiCode.reset}\n\n"
         end
       end
 
       def convert_codeblock(el)
         lang = el.options[:lang]&.strip
         lang = nil if lang && lang.empty?
-        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"
+        code = el.value
+        # Preserve trailing newlines for correct line count; strip leading/trailing
+        # blank lines that would produce empty first/last code rows.
+        code_lines = code.split("\n", -1)
+        code_lines.shift while code_lines.first&.strip&.empty?
+        code_lines.pop   while code_lines.last&.strip&.empty?
+        return "#{tc(:code_border)}┌─ #{lang || "text"} ─┐#{AnsiCode.reset}\n#{tc(:code_border)}└──┘#{AnsiCode.reset}\n\n" if code_lines.empty?
+
+        # Mermaid diagram support
+        if lang == "mermaid" || lang == "mmd"
+          rendered = MermaidRenderer.render(code, @width.to_i)
+          return "#{rendered}\n\n"
+        end
+
+        total_lines = code_lines.length
+        digit_width = [total_lines.to_s.length, 1].max
+        label = lang && !lang.empty? ? lang : "text"
+        # Left gutter: "│ " (2) + digits (digit_width) + " │ " (3) = 5 + digit_width
+        # Right: " │" (2).  Total overhead = 7 + digit_width.
+        gutter_width = 5 + digit_width
+        code_width = [@width.to_i - gutter_width - 1, 20].max
+
+        border = tc(:code_border)
+        rows = []
+        code_lines.each_with_index do |raw_line, idx|
+          num = format("%#{digit_width}d", idx + 1)
+          highlighted = Syntax.highlight(raw_line, lang)
+          fit = fit_code_line(highlighted, code_width)
+          rows << "#{border}│#{AnsiCode.reset} #{num} #{border}│#{AnsiCode.reset} #{fit}#{border}│#{AnsiCode.reset}"
+        end
+
+        top_border = "#{border}┌─ #{label} #{'─' * [@width.to_i - label.display_width - 5, 2].max}┐#{AnsiCode.reset}"
+        bottom_border = "#{border}└#{'─' * (@width.to_i - 2)}┘#{AnsiCode.reset}"
+
+        [top_border, rows.join("\n"), bottom_border, "", ""].join("\n")
+      end
+
+      # Fit a syntax-highlighted line to a given display width, preserving
+      # ANSI escape sequences and truncating with "…" when necessary.
+      def fit_code_line(line, max_width)
+        return "" if max_width <= 0
+
+        result = +""
+        width = 0
+        in_escape = false
+        escape = +""
+        truncated = false
+
+        line.each_char do |char|
+          if in_escape
+            escape << char
+            if char == "m"
+              result << escape
+              escape = +""
+              in_escape = false
+            end
+            next
+          elsif char.ord == 27
+            escape << char
+            in_escape = true
+            next
+          end
+
+          char_width = Unicode::DisplayWidth.of(char)
+          if width + char_width + 1 > max_width
+            truncated = true
+            break
+          end
+          result << char
+          width += char_width
+        end
+
+        result << "…" if truncated
+        result << " " * (max_width - width) unless truncated
+        result << AnsiCode.reset
+        result
       end
 
       def convert_codespan(el)
         code = el.value
-        "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{code} #{AnsiCode.reset}"
+        "#{tbg(:inline_code_bg)}#{tc(:inline_code_fg)} #{code} #{AnsiCode.reset}"
       end
 
       def convert_blockquote(el)
         content = inline_content(el)
         lines = content.strip.split("\n")
+        marker = tc(:blockquote_marker)
+        text_c = tc(:blockquote_text)
         quoted = lines.map do |line|
-          "#{AnsiCode.color(:black, true)}│ #{AnsiCode.color(:white, true)}#{strip_ansi_reset(line)}"
+          "#{marker}│ #{text_c}#{strip_ansi_reset(line)}"
         end
         "#{quoted.join("\n")}#{AnsiCode.reset}\n\n"
       end
@@ -145,20 +276,54 @@ module RubyRich
       def convert_list(el)
         # 保存/恢复计数器，支持嵌套列表
         @list_counters.push(0)
+        @list_types.push(el.type)
         result = convert_children(el)
+        @list_types.pop
         @list_counters.pop
         "#{result}\n"
       end
 
+      UNORDERED_MARKERS = { 1 => '•', 2 => '◦', 3 => '▸' }.freeze
+
       def convert_li(el)
-        marker = if el.options[:parent]&.type == :ol
+        depth = [@list_counters.length, 1].max
+        list_type = @list_types.last
+        marker = if list_type == :ol
           @list_counters[-1] += 1
           "#{@list_counters[-1]}."
         else
-          '•'
+          UNORDERED_MARKERS[depth.clamp(1, 3)] || '▸'
         end
+        task = detect_task_marker(el)
         text = inline_content(el)
-        "#{AnsiCode.color(:cyan, true)}#{marker}#{AnsiCode.reset} #{text.strip}\n"
+        if task
+          "#{tc(task ? :task_checked : :task_unchecked)}#{task}#{AnsiCode.reset} #{text.strip}\n"
+        else
+          "#{tc(list_type == :ol ? :ordered_list : :"list_level_#{depth.clamp(1, 3)}")}#{marker}#{AnsiCode.reset} #{text.strip}\n"
+        end
+      end
+
+      # Detect GitHub Flavored Markdown task list markers.
+      # kramdown-parser-gfm represents them as a child HTML input element
+      # inside the li's paragraph (p); we extract the checked state for
+      # terminal rendering.
+      TASK_CHECKED = '☑'.freeze
+      TASK_UNCHECKED = '☐'.freeze
+
+      def detect_task_marker(el)
+        return nil unless el.children
+
+        para = el.children.find { |c| c.type == :p }
+        return nil unless para&.children
+
+        input_idx = para.children.index { |c| c.type == :html_element && c.value.to_s.downcase == 'input' }
+        return nil unless input_idx
+
+        raw = para.children[input_idx].attr['checked']
+        checked = raw&.to_s&.downcase == 'checked'
+        # Remove the hidden input element so text is clean.
+        para.children.delete_at(input_idx)
+        checked ? TASK_CHECKED : TASK_UNCHECKED
       end
 
       # ---- 内联样式 ----
@@ -182,8 +347,8 @@ module RubyRich
         title = el.attr['title']
         text = inline_content(el)
         title_part = title && !title.empty? ? " - #{title}" : ""
-        "#{AnsiCode.color(:blue, true)}#{AnsiCode.underline}#{text}#{AnsiCode.reset} " \
-        "#{AnsiCode.color(:black, true)}(#{url}#{title_part})#{AnsiCode.reset}"
+        "#{tc(:link_text)}#{AnsiCode.underline}#{text}#{AnsiCode.reset} " \
+        "#{tc(:link_url)}(#{url}#{title_part})#{AnsiCode.reset}"
       end
 
       def convert_image(el)
@@ -191,15 +356,15 @@ module RubyRich
         title = el.attr['title']
         alt = el.attr['alt'] || ''
         title_part = title && !title.empty? ? " - #{title}" : ""
-        "#{AnsiCode.color(:magenta, true)}[Image: #{alt}]#{AnsiCode.reset} " \
-        "#{AnsiCode.color(:black, true)}(#{url}#{title_part})#{AnsiCode.reset}"
+        "#{tc(:image_label)}[Image: #{alt}]#{AnsiCode.reset} " \
+        "#{tc(:link_url)}(#{url}#{title_part})#{AnsiCode.reset}"
       end
 
       # ---- 水平线 ----
 
       def convert_hr(_el)
         line_char = '─'
-        "#{AnsiCode.color(:black, true)}#{line_char * @width}#{AnsiCode.reset}\n\n"
+        "#{tc(:rule)}#{line_char * @width}#{AnsiCode.reset}\n\n"
       end
 
       # ---- 表格（kramdown 原生 AST） ----
@@ -221,27 +386,28 @@ module RubyRich
 
         return "" if header_rows.empty? || body_rows.empty?
 
-        headers = header_rows.last
+        headers, fitted_body_rows = fit_table_rows(header_rows.last, body_rows)
         begin
           tbl = RubyRich::Table.new(
             headers: headers,
-            border_style: @table_border_style
+            border_style: @table_border_style || :simple
           )
-          body_rows.each do |row|
+          fitted_body_rows.each do |row|
             padded = row + Array.new([0, headers.length - row.length].max, "")
             tbl.add_row(padded[0...headers.length])
           end
           "#{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" }
-          "#{result}\n"
+          return "#{result}\n"
         end
       end
 
+      # 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) }
@@ -255,6 +421,116 @@ module RubyRich
         inline_content(el)
       end
 
+      # ---- 表格宽度自适应 ----
+
+      # 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
+
+        [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?
+
+        rows.transpose.map do |cells|
+          cells.map { |cell| cell_display_width(table_cell_text(cell)) }.max.to_i
+        end
+      end
+
+      # 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
+
+      # 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?
+
+        lines = []
+        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
+
+          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)
@@ -271,9 +547,9 @@ module RubyRich
         when 'sup'
           content  # 终端无上标，保留文本
         when 'kbd'
-          "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{content} #{AnsiCode.reset}"
+          "#{tbg(:kbd_bg)}#{tc(:kbd_fg)} #{content} #{AnsiCode.reset}"
         when 'mark'
-          "#{AnsiCode.background(:yellow)}#{AnsiCode.color(:black)}#{content}#{AnsiCode.reset}"
+          "#{tbg(:mark_bg)}#{tc(:mark_fg)}#{content}#{AnsiCode.reset}"
         when 'details', 'summary'
           content
         when 'br'
@@ -315,7 +591,7 @@ module RubyRich
         # 脚注内容在文档末尾自动收集
         content = inline_content(el)
         name = el.options[:name]
-        "#{AnsiCode.color(:magenta, true)}[^#{name}]#{AnsiCode.reset}"
+        "#{tc(:footnote)}[^#{name}]#{AnsiCode.reset}"
       end
 
       # ---- 定义列表（kramdown 独有） ----
@@ -338,7 +614,7 @@ module RubyRich
         title = el.attr['title']
         text = inline_content(el)
         if title && !title.empty?
-          "#{AnsiCode.underline}#{text}#{AnsiCode.reset}#{AnsiCode.color(:black, true)}(#{title})#{AnsiCode.reset}"
+          "#{AnsiCode.underline}#{text}#{AnsiCode.reset}#{tc(:abbreviation)}(#{title})#{AnsiCode.reset}"
         else
           text
         end
@@ -347,13 +623,308 @@ module RubyRich
       # ---- 数学公式（kramdown 独有，需 math engine） ----
 
       def convert_math(el)
-        # 在终端中显示原始 LaTeX 公式
         mode = el.options[:category] == :block ? 'block' : 'inline'
         formula = el.value.to_s.strip
+        rendered = LatexConverter.convert(formula)
+        color = tc(:math)
         if mode == 'block'
-          "#{AnsiCode.color(:magenta, true)}[Math]\n#{formula}\n[/Math]#{AnsiCode.reset}\n\n"
+          "#{color}#{rendered}#{AnsiCode.reset}\n\n"
         else
-          "#{AnsiCode.color(:magenta, true)}[Math: #{formula}]#{AnsiCode.reset}"
+          "#{color}#{rendered}#{AnsiCode.reset}"
+        end
+      end
+
+      # ---- LaTeX to Unicode converter ----
+      # Translates common LaTeX math commands to Unicode characters
+      # for terminal display. Handles Greek letters, big operators,
+      # frac, sqrt, super/subscript, cases, and ~150 common symbols.
+      module LatexConverter
+        # --- big lookup table ------------------------------------
+        # Format: "\\command" => "unicode_char"
+        SYMBOLS = {
+          # Greek lowercase
+          'alpha' => 'α', 'beta' => 'β', 'gamma' => 'γ',
+          'delta' => 'δ', 'epsilon' => 'ε', 'varepsilon' => 'ɛ',
+          'zeta' => 'ζ', 'eta' => 'η', 'theta' => 'θ',
+          'vartheta' => 'ϑ', 'iota' => 'ι', 'kappa' => 'κ',
+          'lambda' => 'λ', 'mu' => 'μ', 'nu' => 'ν',
+          'xi' => 'ξ', 'pi' => 'π', 'varpi' => 'ϖ',
+          'rho' => 'ρ', 'varrho' => 'ϱ', 'sigma' => 'σ',
+          'varsigma' => 'ς', 'tau' => 'τ', 'upsilon' => 'υ',
+          'phi' => 'φ', 'varphi' => 'ϕ', 'chi' => 'χ',
+          'psi' => 'ψ', 'omega' => 'ω',
+          # Greek uppercase
+          'Gamma' => 'Γ', 'Delta' => 'Δ', 'Theta' => 'Θ',
+          'Lambda' => 'Λ', 'Xi' => 'Ξ', 'Pi' => 'Π',
+          'Sigma' => 'Σ', 'Upsilon' => 'Υ', 'Phi' => 'Φ',
+          'Psi' => 'Ψ', 'Omega' => 'Ω',
+          # Relations
+          'leq' => '≤', 'geq' => '≥', 'neq' => '≠',
+          'equiv' => '≡', 'approx' => '≈', 'sim' => '∼',
+          'simeq' => '≃', 'propto' => '∝', 'll' => '≪',
+          'gg' => '≫', 'doteq' => '≐', 'prec' => '≺',
+          'succ' => '≻', 'preceq' => '≼', 'succeq' => '≽',
+          'subset' => '⊂', 'supset' => '⊃', 'subseteq' => '⊆',
+          'supseteq' => '⊇', 'in' => '∈', 'ni' => '∋',
+          'notin' => '∉', 'perp' => '⊥', 'parallel' => '∥',
+          # Binary operators
+          'times' => '×', 'div' => '÷', 'cdot' => '·',
+          'pm' => '±', 'mp' => '∓', 'oplus' => '⊕',
+          'ominus' => '⊖', 'otimes' => '⊗', 'oslash' => '⊘',
+          'odot' => '⊙', 'circ' => '∘', 'bullet' => '∙',
+          'cap' => '∩', 'cup' => '∪', 'setminus' => '∖',
+          'land' => '∧', 'lor' => '∨', 'wedge' => '∧',
+          'vee' => '∨', 'star' => '⋆',
+          # Arrows
+          'to' => '→', 'rightarrow' => '→', 'Rightarrow' => '⇒',
+          'leftarrow' => '←', 'Leftarrow' => '⇐',
+          'leftrightarrow' => '↔', 'Leftrightarrow' => '⇔',
+          'mapsto' => '↦', 'longmapsto' => '⟼',
+          'uparrow' => '↑', 'downarrow' => '↓',
+          'longrightarrow' => '⟶', 'Longrightarrow' => '⟹',
+          # Big operators
+          'sum' => '∑', 'prod' => '∏', 'coprod' => '∐',
+          'int' => '∫', 'iint' => '∬', 'iiint' => '∭',
+          'oint' => '∮', 'bigcup' => '⋃', 'bigcap' => '⋂',
+          'bigvee' => '⋁', 'bigwedge' => '⋀',
+          # Misc symbols
+          'infty' => '∞', 'partial' => '∂', 'nabla' => '∇',
+          'forall' => '∀', 'exists' => '∃', 'nexists' => '∄',
+          'emptyset' => '∅', 'varnothing' => '∅',
+          'Re' => 'ℜ', 'Im' => 'ℑ', 'aleph' => 'ℵ',
+          'ell' => 'ℓ', 'hbar' => 'ℏ', 'wp' => '℘',
+          'angle' => '∠', 'triangle' => '△', 'triangledown' => '▽',
+          'square' => '□', 'Box' => '□', 'diamond' => '◇',
+          'clubsuit' => '♣', 'diamondsuit' => '♢',
+          'heartsuit' => '♡', 'spadesuit' => '♠',
+          'ldots' => '…', 'cdots' => '⋯', 'vdots' => '⋮',
+          'ddots' => '⋱', 'dots' => '…',
+          'cong' => '≅', 'models' => '⊨', 'mid' => '∣',
+          'nmid' => '∤', 'therefore' => '∴', 'because' => '∵',
+          'neg' => '¬', 'lnot' => '¬', 'top' => '⊤', 'bot' => '⊥',
+          'degree' => '°', 'prime' => '′', 'dag' => '†',
+          'ddag' => '‡', 'S' => '§', 'P' => '¶',
+          'pound' => '£', 'euro' => '€', 'yen' => '¥',
+          'copyright' => '©', 'circledR' => '®',
+          # Delimiters – strip LaTeX wrapper
+          'left' => '', 'right' => '', 'bigl' => '', 'bigr' => '',
+          'Bigl' => '', 'Bigr' => '', 'biggl' => '', 'biggr' => '',
+          # Arrows special
+          'gets' => '←',
+          # Text sub/sup scripts
+          'text' => '',
+        }.freeze
+
+        # Commands whose argument should be preserved verbatim (e.g. \text{abc})
+        TEXT_LIKE = %w[text textrm textsf texttt textbf textit].freeze
+
+        SUPERSCRIPTS = {
+          '0' => '⁰', '1' => '¹', '2' => '²', '3' => '³', '4' => '⁴',
+          '5' => '⁵', '6' => '⁶', '7' => '⁷', '8' => '⁸', '9' => '⁹',
+          '+' => '⁺', '-' => '⁻', '=' => '⁼', '(' => '⁽', ')' => '⁾',
+          'i' => 'ⁱ', 'n' => 'ⁿ',
+        }.freeze
+
+        SUBSCRIPTS = {
+          '0' => '₀', '1' => '₁', '2' => '₂', '3' => '₃', '4' => '₄',
+          '5' => '₅', '6' => '₆', '7' => '₇', '8' => '₈', '9' => '₉',
+          '+' => '₊', '-' => '₋', '=' => '₌', '(' => '₍', ')' => '₎',
+          'a' => 'ₐ', 'e' => 'ₑ', 'i' => 'ᵢ', 'j' => 'ⱼ',
+          'n' => 'ₙ', 'x' => 'ₓ',
+        }.freeze
+
+        def self.convert(formula)
+          return formula if formula.nil? || formula.strip.empty?
+
+          result = formula.dup
+          result = process_frac(result)
+          result = process_sqrt(result)
+          result = process_cases(result)
+          result = process_scripts(result)
+          result = replace_symbols(result)
+          result = strip_delim_spacing(result)
+          result
+        end
+
+        # \frac{num}{den}  →  (num)/(den)   or  num/den  when single-char
+        def self.process_frac(text)
+          text.gsub(/\\frac\s*\{([^{}]*(?:\{[^}]*\}[^{}]*)*)\}\s*\{([^{}]*(?:\{[^}]*\}[^{}]*)*)\}/) do
+            num = Regexp.last_match(1)
+            den = Regexp.last_match(2)
+            num_wrap = num.length > 1 ? "(#{num})" : num
+            den_wrap = den.length > 1 ? "(#{den})" : den
+            "#{num_wrap}/#{den_wrap}"
+          end
+        end
+
+        # \sqrt{x} → √(x)   \sqrt[n]{x} → ⁿ√(x)
+        def self.process_sqrt(text)
+          text.gsub(/\\sqrt(?:\[([^\]]*)\])?\s*\{([^{}]*(?:\{[^}]*\}[^{}]*)*)\}/) do
+            degree = Regexp.last_match(1)
+            radicand = Regexp.last_match(2)
+            prefix = degree ? script_chars(degree, SUPERSCRIPTS) : ''
+            "#{prefix}√(#{radicand})"
+          end
+        end
+
+        # \begin{cases} ... \end{cases}  →  ⎧ … ⎨ … ⎩ …
+        def self.process_cases(text)
+          text.gsub(/\\begin\{cases\}(.*?)\\end\{cases\}/m) do
+            body = Regexp.last_match(1).strip
+            lines = body.split('\\\\').map(&:strip).reject(&:empty?)
+            return '{}' if lines.empty?
+            out = +""
+            lines.each_with_index do |line, i|
+              leader = case i
+                       when 0 then '⎧'
+                       when lines.length - 1 then '⎩'
+                       else '⎨'
+                       end
+              out << "#{leader} #{line.gsub('&', '')}\n"
+            end
+            out.strip
+          end
+        end
+
+        # ^{x} / _{x}  →  Unicode super/subscript
+        def self.process_scripts(text)
+          # ^{...}
+          text = text.gsub(/\^\{([^}]+)\}/) {
+            inner = Regexp.last_match(1)
+            inner.include?('\\') ? "^\{#{inner}\}" : script_chars(inner, SUPERSCRIPTS)
+          }
+          # _{...}
+          text = text.gsub(/_\{([^}]+)\}/) {
+            inner = Regexp.last_match(1)
+            inner.include?('\\') ? "_\{#{inner}\}" : script_chars(inner, SUBSCRIPTS)
+          }
+          # ^x  (single non-whitespace char, not \ or {)
+          text = text.gsub(/\^([^\s\\{])/) { SUPERSCRIPTS[Regexp.last_match(1)] || "^#{Regexp.last_match(1)}" }
+          # _x  (single non-whitespace char, not \ or {)
+          text = text.gsub(/_([^\s\\{])/) { SUBSCRIPTS[Regexp.last_match(1)] || "_#{Regexp.last_match(1)}" }
+          text
+        end
+
+        def self.script_chars(str, map)
+          str.each_char.map { |c| map[c] || c }.join
+        end
+
+        # Replace \command tokens with Unicode equivalents.
+        def self.replace_symbols(text)
+          # Handle \text{…} first – keep content, remove wrapper
+          text = text.gsub(/\\(text\w*)\s*\{(.*?)\}/) { Regexp.last_match(2) }
+          # Replace all other \commands
+          text.gsub(/\\([a-zA-Z]+)/) { |m|
+            SYMBOLS[Regexp.last_match(1)] || m
+          }
+        end
+
+        # Remove stray spaces inserted by \left / \right.
+        def self.strip_delim_spacing(text)
+          text.gsub(/\(\s+/, '(').gsub(/\s+\)/, ')')
+              .gsub(/\[\s+/, '[').gsub(/\s+\]/, ']')
+              .gsub(/\{\s+/, '{').gsub(/\s+\}/, '}')
+              .gsub(/\\s+/, ' ')
+        end
+      end
+
+      # ---- Mermaid diagram renderer ----
+      # Renders pie charts inline; other diagram types show source with a
+      # hint to install `mmdc` for full rendering.
+      module MermaidRenderer
+        BAR_MAX = 32
+
+        def self.render(source, width = 80)
+          trimmed = source.strip
+          return "" if trimmed.empty?
+
+          type = detect_type(trimmed)
+          case type
+          when :pie
+            render_pie(trimmed, width)
+          else
+            render_fallback(trimmed, type, width)
+          end
+        end
+
+        def self.detect_type(source)
+          first = source.lines.first&.strip&.downcase || ""
+          return :pie if first.start_with?("pie")
+          return :flowchart if first.start_with?("flowchart") || first.start_with?("graph")
+          return :sequence  if first.start_with?("sequencediagram")
+          return :class     if first.start_with?("classdiagram")
+          return :gantt     if first.start_with?("gantt")
+          return :state     if first.start_with?("statediagram")
+          :generic
+        end
+
+        # Pie chart → horizontal bar chart with percentage labels.
+        def self.render_pie(source, width)
+          title = ""
+          entries = []
+          source.each_line do |line|
+            line = line.strip
+            next if line.empty?
+            if line.downcase.start_with?("pie")
+              rest = line[3..].strip
+              if rest.downcase.start_with?("title")
+                title = rest[5..].strip
+              end
+              next
+            end
+            if line.downcase.start_with?("title")
+              title = line[5..].strip
+              next
+            end
+            # Parse "label" : value
+            label_part, value_part = line.split(":", 2).map(&:strip)
+            next unless label_part && value_part
+            label = label_part.delete_prefix('"').delete_suffix('"')
+            value = value_part.to_f
+            entries << [label, value] if value > 0
+          end
+
+          return "[Mermaid pie: no data]" if entries.empty?
+
+          total = entries.sum { |_l, v| v }
+          return "[Mermaid pie: total is zero]" if total <= 0
+
+          max_label = entries.map { |l, _| l.length }.max
+          out = +""
+          out << "#{tc(:heading_3)}#{title}#{AnsiCode.reset}\n" unless title.empty?
+
+          entries.each do |label, value|
+            pct = value / total * 100.0
+            filled = (pct / 100.0 * BAR_MAX).round
+            half = (pct / 100.0 * BAR_MAX * 2).round % 2 == 1
+            bar = "█" * filled + (half ? "▌" : "")
+            out << sprintf("%-#{BAR_MAX + 1}s %-#{max_label}s %5.1f%%\n", bar, label, pct)
+          end
+
+          out.strip
+        end
+
+        # Fallback: show diagram source with a labelled header.
+        def self.render_fallback(source, type, width)
+          label = type.to_s.capitalize
+          pad = (width - label.length - 2).clamp(2, 60)
+          lines = source.lines.map(&:chomp)
+          [
+            "#{tc(:code_border)}┌─ #{label} #{'─' * pad}┐#{AnsiCode.reset}",
+            *lines.map { |l| "#{tc(:code_border)}│#{AnsiCode.reset} #{l}" },
+            "#{tc(:code_border)}└#{'─' * (width - 2)}┘#{AnsiCode.reset}",
+            "#{tc(:muted || :heading_4_6)}Install mmdc (npm i -g @mermaid-js/mermaid-cli) for full diagram rendering.#{AnsiCode.reset}",
+          ].join("\n")
+        end
+
+        # Proxy theme colour access (same instance as TerminalConverter).
+        def self.tc(key)
+          color, bright = MarkdownTheme[key]
+          AnsiCode.color(color, bright)
+        end
+
+        def self.AnsiCode
+          ::RubyRich::AnsiCode
         end
       end
 
@@ -369,6 +940,77 @@ module RubyRich
       end
     end
 
+    # ---- Frontmatter extraction ----
+    # Extracts YAML-style frontmatter (delimited by ---) and returns
+    # [content_without_fm, parsed_pairs, is_vertical].
+    module Frontmatter
+      VERTICAL_THRESHOLD = 5
+
+      def self.extract(markdown_text)
+        return [markdown_text, nil, false] unless markdown_text.start_with?("---\n")
+
+        rest = markdown_text[4..]
+        offset = 4
+        rest.each_line do |line|
+          if line == "---\n" || line == "...\n" || line == "---" || line == "..."
+            fm_block = markdown_text[4...offset]
+            content = markdown_text[(offset + line.length)..] || ""
+            pairs = parse_pairs(fm_block)
+            return [markdown_text, nil, false] if pairs.empty?
+            vertical = pairs.length >= VERTICAL_THRESHOLD
+            return [content, pairs, vertical]
+          end
+          offset += line.length
+        end
+        [markdown_text, nil, false]
+      end
+
+      def self.parse_pairs(block)
+        pairs = []
+        lines = block.lines.map(&:chomp)
+        i = 0
+        while i < lines.length
+          trimmed = lines[i].strip
+          i += 1 and next if trimmed.empty? || trimmed.start_with?('#')
+
+          colon_pos = trimmed.index(':')
+          i += 1 and next unless colon_pos
+
+          key = trimmed[0...colon_pos].strip
+          raw_value = trimmed[(colon_pos + 1)..].strip
+          i += 1 and next if key.empty?
+
+          if ["", ">-", ">", "|", "|-"].include?(raw_value)
+            # Multiline value
+            parts = []
+            while i < lines.length && lines[i].start_with?(' ', "\t")
+              part = lines[i].strip
+              parts << part unless part.empty?
+              i += 1
+            end
+            pairs << [key, parts.join(" ")]
+          elsif raw_value.empty?
+            # List value (indented items)
+            items = []
+            while i < lines.length && lines[i].start_with?(' ', "\t")
+              item = lines[i].strip
+              items << (item.start_with?("- ") ? item[2..].strip : item)
+              i += 1
+            end
+            pairs << [key, items.empty? ? "" : items.join(", ")]
+          else
+            pairs << [key, unquote(raw_value)]
+            i += 1
+          end
+        end
+        pairs
+      end
+
+      def self.unquote(s)
+        (s.length >= 2 && ((s.start_with?('"') && s.end_with?('"')) || (s.start_with?("'") && s.end_with?("'")))) ? s[1...-1] : s
+      end
+    end
+
     # ---- 公开 API ----
 
     # 渲染 Markdown 文本为 ANSI 终端输出
@@ -388,6 +1030,26 @@ module RubyRich
         table_border_style: options[:table_border_style] || :simple
       }
 
+      # Pre-process frontmatter
+      content, fm_pairs, fm_vertical = Frontmatter.extract(markdown_text)
+
+      # Pre-process inline math $...$ (kramdown needs a math-engine gem for this)
+      math_color = AnsiCode.color(*MarkdownTheme[:math])
+      content = content.gsub(/(?<!\$)\$(?!\$)(.+?)(?<!\$)\$(?!\$)/) do
+        rendered = TerminalConverter::LatexConverter.convert(Regexp.last_match(1).strip)
+        "#{math_color}#{rendered}#{AnsiCode.reset}"
+      end
+
+      fm_output = ""
+      if fm_pairs && !fm_pairs.empty?
+        if fm_vertical
+          # Vertical frontmatter: one column per key-value pair
+          fm_output = render_frontmatter_vertical(fm_pairs, converter_options)
+        else
+          fm_output = render_frontmatter_horizontal(fm_pairs, converter_options)
+        end
+      end
+
       kramdown_opts = {
         input: 'GFM',                 # GitHub Flavored Markdown
         syntax_highlighter: nil,      # 自行处理语法高亮
@@ -396,9 +1058,31 @@ module RubyRich
         line_width: converter_options[:width]
       }.merge(options[:kramdown] || {})
 
-      doc = Kramdown::Document.new(markdown_text, kramdown_opts)
+      doc = Kramdown::Document.new(content, kramdown_opts)
       result, _warnings = TerminalConverter.convert(doc.root, converter_options)
-      result
+      "#{fm_output}#{result}"
+    end
+
+    # Render frontmatter as a vertical key-value table (many pairs).
+    def self.render_frontmatter_vertical(pairs, opts)
+      tbl = RubyRich::Table.new(
+        headers: %w[Key Value],
+        border_style: opts[:table_border_style] || :simple
+      )
+      pairs.each { |k, v| tbl.add_row([k, v]) }
+      "#{tbl.render}\n\n"
+    end
+
+    # Render frontmatter as a horizontal 2-row table (few pairs).
+    def self.render_frontmatter_horizontal(pairs, opts)
+      keys = pairs.map(&:first)
+      vals = pairs.map(&:last)
+      tbl = RubyRich::Table.new(
+        headers: keys,
+        border_style: opts[:table_border_style] || :simple
+      )
+      tbl.add_row(vals)
+      "#{tbl.render}\n\n"
     end
 
     def initialize(options = {})
@@ -409,4 +1093,4 @@ module RubyRich
       self.class.render(markdown_text, @options)
     end
   end
-end
+end

data/lib/ruby_rich/table.rb

@@ -126,13 +126,13 @@ module RubyRich
       border_chars = BORDER_STYLES[@border_style]
       
       row_content = row.map.with_index do |cell, i|
-        rendered = cell.render
+        rendered = cell.render.sub(/\e\[0m\z/, '')
         content = bold ? rendered : align_cell(rendered, column_widths[i])
-        aligned_content = align_cell(content, column_widths[i])
+        aligned_content = align_cell(content, column_widths[i]).sub(/\e\[0m\z/, '')
         " #{aligned_content} "
       end.join(border_chars[:vertical])
       
-      ["#{border_chars[:left]}#{row_content}#{border_chars[:right]}"]
+      ["#{border_chars[:left]}#{row_content}#{border_chars[:right]}\e[0m"]
     end
 
     def render_styled_multiline_row(row, column_widths)
@@ -213,10 +213,10 @@ module RubyRich
   
     def render_row(row, column_widths, bold: false)
       row.map.with_index do |cell, i|
-        rendered = cell.render
+        rendered = cell.render.sub(/\e\[0m\z/, '')
         content = bold ? rendered : align_cell(rendered, column_widths[i])
-        align_cell(content, column_widths[i])
-      end.join(" | ").prepend("| ").concat(" |")
+        align_cell(content, column_widths[i]).sub(/\e\[0m\z/, '')
+      end.join(" | ").prepend("| ").concat(" |\e[0m")
     end
   
     def render_multiline_row(row, column_widths)
@@ -254,7 +254,7 @@ module RubyRich
   
       # Render each line of the row
       (0...max_height).map do |line_index|
-        row_lines.map { |lines| lines[line_index] }.join(" | ").prepend("| ").concat(" |")
+        row_lines.map { |lines| lines[line_index].sub(/\e\[0m\z/, '') }.join(" | ").prepend("| ").concat(" |\e[0m")
       end
     end
 
@@ -263,7 +263,7 @@ module RubyRich
     end
   
     def align_cell(content, width)
-      style_sequences = content.scan(/\e\[[0-9;]*m/)
+      style_sequences = content.scan(/\e\[[0-9;]*m/).reject { |s| s == "\e[0m" }
       plain_content = content.gsub(/\e\[[0-9;]*m/, '')
       
       # 计算实际显示宽度
@@ -282,7 +282,7 @@ module RubyRich
       end
       
       if style_sequences.any?
-        style_sequences.first + padded_content + "\e[0m"
+        style_sequences.first + padded_content
       else
         padded_content
       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.8"
+  VERSION = "0.5.0"
 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rich
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.5.0
 platform: ruby
 authors:
 - zhuang biaowei