ruby_rich 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6db3483399e193c2a8feb97472df06341391d165f07aafde1af299a0892bb83c
-  data.tar.gz: 71ef2db35e2b369953c7201e13bc751001f02815dd2717ea3358964ff12b30b3
+  metadata.gz: 35642b63217134791fd7201a1b26488473164d74646bfa3b2492294611e92340
+  data.tar.gz: 3c9633c93770785e7b003b81fb8ff484c21114184ac2b0615fee1bd16380fbca
 SHA512:
-  metadata.gz: d4d3b29b2e73d8ebe31e883ba0001cb207f65b2683897d861601918e097823bce393302dd51b276fe15c71608959d28d61c6413e82c26fc0226245cf9b2c358b
-  data.tar.gz: 41274198774c77707e3d052a9b81b1d1e18d2ae293a63b0dadcdbf508b1d74c3892203433d2a4cd92759275ce44b31906f83bd4ee3e10a128fefe3e8b890bcd5
+  metadata.gz: 21e958777b0107f4a92b7de61aa725cca02951b5aff8874c3ab9149b1c8cb45c1998d39f93529e04d92e2e45c4ba67ad4f053568ea1dfe503bd6d9568c7f511d
+  data.tar.gz: b5abb3cf83b0f53100f13286dcb388a54b9238503ff276f2a591a71d873eaaef116a4dc599175b75023388f95f30d6934da36071fddb88cecff367b1e07c2910

data/lib/ruby_rich/markdown.rb

@@ -286,8 +286,9 @@ module RubyRich
       UNORDERED_MARKERS = { 1 => '•', 2 => '◦', 3 => '▸' }.freeze
 
       def convert_li(el)
-        depth = [@list_counters.length, 1].max
+        depth = [@list_types.length, 1].max
         list_type = @list_types.last
+        indent = "  " * (depth - 1)
         marker = if list_type == :ol
           @list_counters[-1] += 1
           "#{@list_counters[-1]}."
@@ -295,11 +296,11 @@ module RubyRich
           UNORDERED_MARKERS[depth.clamp(1, 3)] || '▸'
         end
         task = detect_task_marker(el)
-        text = inline_content(el)
+        text = inline_content(el).gsub(/\n{2,}/, "\n")
         if task
-          "#{tc(task ? :task_checked : :task_unchecked)}#{task}#{AnsiCode.reset} #{text.strip}\n"
+          "#{indent}#{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"
+          "#{indent}#{tc(list_type == :ol ? :ordered_list : :"list_level_#{depth.clamp(1, 3)}")}#{marker}#{AnsiCode.reset} #{text.strip}\n"
         end
       end
 
@@ -737,34 +738,119 @@ module RubyRich
           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 = process_scripts(result)
+          result = process_frac(result)
+          result = process_sqrt(result)
           result = strip_delim_spacing(result)
           result
         end
 
-        # \frac{num}{den}  →  (num)/(den)   or  num/den  when single-char
+        # Find the index of the } that matches the { at `open_pos`.
+        # Returns nil when braces are unbalanced.
+        def self.find_matching_brace(text, open_pos)
+          return nil unless text[open_pos] == '{'
+          depth = 1
+          i = open_pos + 1
+          while i < text.length && depth > 0
+            case text[i]
+            when '{' then depth += 1
+            when '}' then depth -= 1
+            when '\\' then i += 1
+            end
+            i += 1
+          end
+          depth == 0 ? i - 1 : nil
+        end
+
+        # \frac{num}{den} / \dfrac{num}{den} / \tfrac{num}{den}
+        # →  (num)/(den)  when num/den include operators, otherwise num/den
         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}"
+          result = +""
+          i = 0
+          while i < text.length
+            cmd_len = nil
+            if text[i..].start_with?('\\dfrac') || text[i..].start_with?('\\tfrac')
+              cmd_len = 6
+            elsif text[i..].start_with?('\\frac')
+              cmd_len = 5
+            end
+            if cmd_len
+              j = i + cmd_len
+              while j < text.length && text[j] =~ /\s/
+                j += 1
+              end
+              if j < text.length && text[j] == '{'
+                num_start = j
+                num_end = find_matching_brace(text, num_start)
+                if num_end
+                  k = num_end + 1
+                  while k < text.length && text[k] =~ /\s/
+                    k += 1
+                  end
+                  if k < text.length && text[k] == '{'
+                    den_start = k
+                    den_end = find_matching_brace(text, den_start)
+                    if den_end
+                      num = text[num_start + 1...num_end]
+                      den = text[den_start + 1...den_end]
+                      # Only wrap in parens when the expression includes
+                      # operators that would change precedence without them.
+                      op_rx = /[+\-±∓×÷=<>]/
+                      num_wrap = num =~ op_rx ? "(#{num})" : num
+                      den_wrap = den =~ op_rx ? "(#{den})" : den
+                      result << "#{num_wrap}/#{den_wrap}"
+                      i = den_end + 1
+                      next
+                    end
+                  end
+                end
+              end
+            end
+            result << text[i]
+            i += 1
           end
+          result
         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})"
+          result = +""
+          i = 0
+          while i < text.length
+            if text[i..].start_with?('\\sqrt')
+              j = i + 5
+              deg_text = nil
+              while j < text.length && text[j] =~ /\s/
+                j += 1
+              end
+              if j < text.length && text[j] == '['
+                close_br = text.index(']', j)
+                if close_br
+                  deg_text = text[j + 1...close_br]
+                  j = close_br + 1
+                end
+              end
+              while j < text.length && text[j] =~ /\s/
+                j += 1
+              end
+              if j < text.length && text[j] == '{'
+                rad_start = j
+                rad_end = find_matching_brace(text, rad_start)
+                if rad_end
+                  rad = text[rad_start + 1...rad_end]
+                  prefix = deg_text ? script_chars(deg_text, SUPERSCRIPTS) : ''
+                  result << "#{prefix}√(#{rad})"
+                  i = rad_end + 1
+                  next
+                end
+              end
+            end
+            result << text[i]
+            i += 1
           end
+          result
         end
 
         # \begin{cases} ... \end{cases}  →  ⎧ … ⎨ … ⎩ …
@@ -811,8 +897,15 @@ module RubyRich
 
         # 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) }
+          # Handle brace-wrapped font/formatting commands: \text{ab}, \mathbf{ab}, \mathbb{R}, etc.
+          # Strip the wrapper, keep the content.
+          text = text.gsub(/\\(?:text\w*|math[bif]|mathbf|mathrm|mathit|mathsf|mathtt|mathcal|mathfrak|mathbb|mathscr|boldsymbol|bm|emph)\s*\{(.*?)\}/) {
+            Regexp.last_match(1)
+          }
+          # Handle font commands with single-char arg (space-separated): \mathbf E
+          text = text.gsub(/\\(?:mathbf|mathrm|mathit|mathsf|mathtt|mathcal|mathfrak|mathbb|mathscr|boldsymbol|bm)\s+([a-zA-Z0-9])/) {
+            Regexp.last_match(1)
+          }
           # Replace all other \commands
           text.gsub(/\\([a-zA-Z]+)/) { |m|
             SYMBOLS[Regexp.last_match(1)] || m
@@ -825,6 +918,8 @@ module RubyRich
               .gsub(/\[\s+/, '[').gsub(/\s+\]/, ']')
               .gsub(/\{\s+/, '{').gsub(/\s+\}/, '}')
               .gsub(/\\s+/, ' ')
+              .gsub(/([·×÷]) +/, '\1')
+              .gsub(/ +([·×÷])/, '\1')
         end
       end
 
@@ -834,6 +929,23 @@ module RubyRich
       module MermaidRenderer
         BAR_MAX = 32
 
+        LEAF_BIN = "leaf"
+
+        def self.leaf_available?
+          @leaf_available ||= system("which #{LEAF_BIN} > /dev/null 2>&1")
+        end
+
+        def self.render_via_leaf(source, width)
+          return nil unless leaf_available?
+          IO.popen([LEAF_BIN, "--inline", "plain:#{width}"], "r+", err: "/dev/null") do |io|
+            io.write(source)
+            io.close_write
+            io.read.strip
+          end
+        rescue
+          nil
+        end
+
         def self.render(source, width = 80)
           trimmed = source.strip
           return "" if trimmed.empty?
@@ -842,6 +954,10 @@ module RubyRich
           case type
           when :pie
             render_pie(trimmed, width)
+          when :flowchart, :sequence, :class, :gantt, :state, :generic
+            # Prefer leaf for high-quality ASCII-art rendering
+            result = render_via_leaf("```mermaid\n#{trimmed}\n```\n", width)
+            result && !result.empty? ? result : render_fallback(trimmed, type, width)
           else
             render_fallback(trimmed, type, width)
           end
@@ -917,6 +1033,148 @@ module RubyRich
           ].join("\n")
         end
 
+        # Flowchart / graph → edge-list rendering with node labels.
+        def self.render_flowchart(source, width)
+          lines = source.lines.map(&:chomp)
+          # Build node registry: id => label
+          nodes = {}
+          edges = []
+
+          lines.each do |line|
+            stripped = line.strip
+            next if stripped.empty?
+            next if stripped.downcase.start_with?("flowchart", "graph")
+
+            # Parse edge:  src ---|label|---> tgt
+            m = stripped.match(
+              /\A(.+?)\s*(-+>|==+>|-\.+>|=+>)\s*(\|(.*?)\|)?\s*(.+)\z/
+            )
+            if m
+              src_raw = m[1].strip
+              tgt_raw = m[5].strip
+              arrow = m[2]
+              label = m[4]&.strip
+
+              src_id, src_lbl = parse_node(src_raw)
+              tgt_id, tgt_lbl = parse_node(tgt_raw)
+
+              # Only store shaped labels — don't let bare IDs overwrite them
+              nodes[src_id] = src_lbl if src_lbl && src_raw =~ /[\[\(\{]/
+              nodes[tgt_id] = tgt_lbl if tgt_lbl && tgt_raw =~ /[\[\(\{]/
+
+              edges << {
+                src: src_id, src_label: src_lbl || src_id,
+                tgt: tgt_id, tgt_label: tgt_lbl || tgt_id,
+                edge_label: label
+              }
+              next
+            end
+
+            # Standalone node definition:  id[text] / id{text} / id(text)
+            nm = stripped.match(/\A([A-Za-z0-9_]+)\s*[\[\(\{].+[\]\)\}]\z/)
+            if nm
+              nid, nlbl = parse_node(stripped)
+              nodes[nid] = nlbl if nlbl
+            end
+          end
+
+          return "[Mermaid flowchart: no edges found]" if edges.empty?
+
+          out = +""
+          edges.each do |e|
+            src = nodes[e[:src]] || e[:src_label]
+            tgt = nodes[e[:tgt]] || e[:tgt_label]
+            lbl = e[:edge_label] ? " ─#{e[:edge_label]}─▶ " : " ──▶ "
+            out << "#{src}#{lbl}#{tgt}\n"
+          end
+          out.strip
+        end
+
+        # Extract [id, label] from a node token like "A[开始]" or "B{是否通过?}"
+        def self.parse_node(raw)
+          raw = raw.strip
+          # Square brackets
+          if raw =~ /\A([A-Za-z0-9_]+)\s*\[(.+)\]\z/
+            [$1, $2]
+          # Curly braces (diamond)
+          elsif raw =~ /\A([A-Za-z0-9_]+)\s*\{(.+)\}\z/
+            [$1, $2]
+          # Round parens
+          elsif raw =~ /\A([A-Za-z0-9_]+)\s*\((.+)\)\z/
+            [$1, $2]
+          # Just an id
+          elsif raw =~ /\A([A-Za-z0-9_]+)\z/
+            [$1, $1]
+          else
+            [raw, raw]
+          end
+        end
+
+        # Sequence diagram → participant-message listing.
+        def self.render_sequence(source, width)
+          lines = source.lines.map(&:chomp)
+          participants = []
+          messages = []
+
+          lines.each do |line|
+            stripped = line.strip
+            next if stripped.empty? || stripped.downcase.start_with?("sequencediagram")
+
+            # participant / actor definition
+            if stripped =~ /\A(?:participant|actor)\s+(.+)\z/i
+              participants << $1.strip
+              next
+            end
+
+            # Note
+            if stripped =~ /\ANote\s+(?:over\s+)?(.+?):\s*(.+)\z/i
+              messages << { type: :note, target: $1.strip, text: $2.strip }
+              next
+            end
+
+            # Message:  A->>B: text  /  A-->>B: text  /  A-)B: text
+            if stripped =~ /\A(.+?)\s*(-+>>?|-->>|-\)|-[xX])\s*(.+?)\s*:\s*(.+)\z/
+              src  = $1.strip
+              arrow_type = $2.strip
+              tgt  = $3.strip
+              text = $4.strip
+              participants |= [src, tgt] unless participants.include?(src) && participants.include?(tgt)
+              dashed = arrow_type.start_with?("--")
+              messages << { type: :msg, src: src, tgt: tgt, text: text, dashed: dashed }
+            end
+          end
+
+          return "[Mermaid sequence: no messages found]" if messages.empty?
+
+          max_participant = participants.map(&:length).max
+          max_participant = 8 if max_participant < 8
+
+          out = +""
+          participants.each do |p|
+            out << sprintf("%-#{max_participant + 4}s", "[#{p}]")
+          end
+          out << "\n#{'─' * ((max_participant + 4) * participants.size)}\n"
+
+          messages.each do |m|
+            case m[:type]
+            when :note
+              out << "  📝 #{m[:target]}: #{m[:text]}\n"
+            when :msg
+              src_idx = participants.index(m[:src]) || 0
+              tgt_idx = participants.index(m[:tgt]) || participants.size - 1
+              rightward = src_idx <= tgt_idx
+              if m[:dashed]
+                arrow = rightward ? "╌╌▶" : "◀╌╌"
+              else
+                arrow = rightward ? "──▶" : "◀──"
+              end
+              out << sprintf("  %-#{max_participant}s #{arrow} %s: %s\n",
+                             m[:src], m[:tgt], m[:text])
+            end
+          end
+          out.strip
+        end
+
         # Proxy theme colour access (same instance as TerminalConverter).
         def self.tc(key)
           color, bright = MarkdownTheme[key]
@@ -947,14 +1205,18 @@ module RubyRich
       VERTICAL_THRESHOLD = 5
 
       def self.extract(markdown_text)
-        return [markdown_text, nil, false] unless markdown_text.start_with?("---\n")
+        # Strip leading blank lines so that a heredoc like <<~'MD'\n\n---\n
+        # is still recognised as having frontmatter.
+        stripped = markdown_text.lstrip
+        return [markdown_text, nil, false] unless stripped.start_with?("---")
 
-        rest = markdown_text[4..]
-        offset = 4
+        rest = stripped[3..]
+        offset = 3
         rest.each_line do |line|
-          if line == "---\n" || line == "...\n" || line == "---" || line == "..."
-            fm_block = markdown_text[4...offset]
-            content = markdown_text[(offset + line.length)..] || ""
+          trimmed = line.strip
+          if trimmed == "---" || trimmed == "..."
+            fm_block = stripped[3...offset]
+            content = stripped[(offset + line.length)..] || ""
             pairs = parse_pairs(fm_block)
             return [markdown_text, nil, false] if pairs.empty?
             vertical = pairs.length >= VERTICAL_THRESHOLD
@@ -980,8 +1242,9 @@ module RubyRich
           raw_value = trimmed[(colon_pos + 1)..].strip
           i += 1 and next if key.empty?
 
-          if ["", ">-", ">", "|", "|-"].include?(raw_value)
-            # Multiline value
+          if [">-", ">", "|", "|-"].include?(raw_value)
+            # Multiline value with explicit indicator
+            i += 1
             parts = []
             while i < lines.length && lines[i].start_with?(' ', "\t")
               part = lines[i].strip
@@ -990,7 +1253,8 @@ module RubyRich
             end
             pairs << [key, parts.join(" ")]
           elsif raw_value.empty?
-            # List value (indented items)
+            # Empty value: could be a list or an implicit multiline string.
+            i += 1
             items = []
             while i < lines.length && lines[i].start_with?(' ', "\t")
               item = lines[i].strip

data/lib/ruby_rich/table.rb

@@ -127,7 +127,7 @@ module RubyRich
       
       row_content = row.map.with_index do |cell, i|
         rendered = cell.render.sub(/\e\[0m\z/, '')
-        content = bold ? rendered : align_cell(rendered, column_widths[i])
+        content = bold ? "\e[1m#{rendered}" : rendered
         aligned_content = align_cell(content, column_widths[i]).sub(/\e\[0m\z/, '')
         " #{aligned_content} "
       end.join(border_chars[:vertical])
@@ -214,7 +214,7 @@ module RubyRich
     def render_row(row, column_widths, bold: false)
       row.map.with_index do |cell, i|
         rendered = cell.render.sub(/\e\[0m\z/, '')
-        content = bold ? rendered : align_cell(rendered, column_widths[i])
+        content = bold ? "\e[1m#{rendered}" : rendered
         align_cell(content, column_widths[i]).sub(/\e\[0m\z/, '')
       end.join(" | ").prepend("| ").concat(" |\e[0m")
     end

data/lib/ruby_rich/version.rb

@@ -1,3 +1,3 @@
 module RubyRich
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

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