ruby_rich 0.4.0 → 0.4.2

data/lib/ruby_rich/markdown.rb

@@ -2,193 +2,171 @@ require 'redcarpet'
 
 module RubyRich
   class Markdown
-    # 简化的 Markdown 渲染器，将 Markdown 转换为带 ANSI 颜色的终端输出
+    # 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 = {
-          in_table: false,
-          headers: [],
-          current_row: [],
-          rows: []
-        }
+        @table_state = { current_row: [], all_rows: [] }
       end
 
-      # 段落
+      # ---- block-level callbacks ----
+
       def paragraph(text)
-        wrap_text(text) + "\n\n"
+        "#{process_inline(text)}\n\n"
       end
 
-      # 标题
       def header(text, level)
+        processed = process_inline(text)
         case level
-        when 1
-          "\e[1m\e[96m#{text}\e[0m\n" + "\e[96m#{'=' * text.length}\e[0m\n\n"
-        when 2
-          "\e[1m\e[94m#{text}\e[0m\n" + "\e[94m#{'-' * text.length}\e[0m\n\n"
-        when 3
-          "\e[1m\e[93m### #{text}\e[0m\n\n"
-        else
-          "\e[1m\e[90m#{'#' * level} #{text}\e[0m\n\n"
+        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"
         end
       end
 
-      # 代码块
       def block_code(code, language)
-        # 简单的代码格式，不使用语法高亮避免循环依赖
-        "\e[100m\e[37m" + indent_lines(code.strip) + "\e[0m\n\n"
+        lang = language&.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]
+        "#{bg}#{fg}#{indent_lines(highlighted)}#{AnsiCode.reset}\n\n"
       end
 
-      # 行内代码
       def codespan(code)
-        "\e[47m\e[30m #{code} \e[0m"
+        "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{code} #{AnsiCode.reset}"
       end
 
-      # 引用
       def block_quote(quote)
         lines = quote.strip.split("\n")
-        quoted_lines = lines.map { |line| "\e[90m│ \e[37m#{line.strip}" }
-        quoted_lines.join("\n") + "\e[0m\n\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"
       end
 
-      # 列表项
       def list_item(text, list_type)
         marker = list_type == :ordered ? '1.' : '•'
-        "\e[96m#{marker}\e[0m #{text.strip}\n"
+        "#{AnsiCode.color(:cyan, true)}#{marker}#{AnsiCode.reset} #{process_inline(text.strip)}\n"
       end
 
-      # 无序列表
       def list(contents, list_type)
-        contents + "\n"
+        "#{contents}\n"
       end
 
-      # 强调
-      def emphasis(text)
-        "\e[3m#{text}\e[23m"
-      end
-
-      # 加粗
-      def double_emphasis(text)
-        "\e[1m#{text}\e[22m"
-      end
+      def emphasis(text)      = "#{AnsiCode.italic}#{text}#{AnsiCode.reset}"
+      def double_emphasis(text) = "#{AnsiCode.bold}#{text}#{AnsiCode.reset}"
+      def strikethrough(text)   = "#{AnsiCode.strikethrough}#{text}#{AnsiCode.reset}"
 
-      # 删除线
-      def strikethrough(text)
-        "\e[9m#{text}\e[29m"
-      end
-
-      # 链接
       def link(link, title, content)
-        if title && !title.empty?
-          "\e[94m\e[4m#{content}\e[24m\e[0m \e[90m(#{link} - #{title})\e[0m"
-        else
-          "\e[94m\e[4m#{content}\e[24m\e[0m \e[90m(#{link})\e[0m"
-        end
+        title_part = title && !title.empty? ? " - #{title}" : ""
+        "#{AnsiCode.color(:blue, true)}#{AnsiCode.underline}#{content}#{AnsiCode.reset} #{AnsiCode.color(:black, true)}(#{link}#{title_part})#{AnsiCode.reset}"
       end
 
-      # 图片
       def image(link, title, alt_text)
-        if title && !title.empty?
-          "\e[95m[Image: #{alt_text}]\e[0m \e[90m(#{link} - #{title})\e[0m"
-        else
-          "\e[95m[Image: #{alt_text}]\e[0m \e[90m(#{link})\e[0m"
-        end
+        title_part = title && !title.empty? ? " - #{title}" : ""
+        "#{AnsiCode.color(:magenta, true)}[Image: #{alt_text}]#{AnsiCode.reset} #{AnsiCode.color(:black, true)}(#{link}#{title_part})#{AnsiCode.reset}"
       end
 
-      # 水平线
       def hrule
-        "\e[90m" + "─" * @options[:width] + "\e[0m\n\n"
+        "#{AnsiCode.color(:black, true)}#{"─" * @options[:width]}#{AnsiCode.reset}\n\n"
       end
 
-      # 表格渲染 - 智能分割方法
+      def linebreak = "\n"
+
+      # ---- table callbacks ----
+
       def table(header, body)
-        return "" if header.nil? && body.nil?
-        
+        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..] || []
+
+        return "" if header_rows.empty? || body_rows.empty?
+
+        headers = header_rows.last.map { |c| process_inline(c) }
         begin
-          # 尝试智能分割表格内容
-          headers = []
-          rows = []
-          
-          if header && !header.strip.empty?
-            # 从header中提取列标题
-            header_content = header.strip
-            # 尝试按常见模式分割（大写字母开头的单词）
-            headers = split_table_content_intelligently(header_content)
-          end
-          
-          if body && !body.strip.empty?
-            body_lines = body.strip.split("\n").reject(&:empty?)
-            body_lines.each do |line|
-              row_data = split_table_content_intelligently(line.strip)
-              rows << row_data unless row_data.all?(&:empty?)
-            end
-          end
-          
-          # 如果成功解析出了数据，使用RubyRich表格
-          if !headers.empty? && !rows.empty?
-            table = RubyRich::Table.new(
-              headers: headers,
-              border_style: @options[:table_border_style] || :simple
-            )
-            
-            rows.each do |row|
-              # 确保行长度与标题长度一致
-              padded_row = row + Array.new([0, headers.length - row.length].max, "")
-              table.add_row(padded_row[0...headers.length])
-            end
-            
-            return table.render + "\n\n"
+          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.add_row(padded[0...headers.length])
           end
-          
-        rescue => e
-          # 如果出错，继续使用fallback
+          return "#{tbl.render}\n\n"
+        rescue
+          # fallback
         end
-        
-        # Fallback: 简单显示
+
         result = "\n"
-        if header && !header.strip.empty?
-          result += "#{header.strip}\n"
-          result += "-" * [header.strip.length, 20].min + "\n"
-        end
-        if body && !body.strip.empty?
-          result += body.strip + "\n"
-        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"
       end
 
       def table_row(content)
-        content + "\n"
+        @table_state[:all_rows] << @table_state[:current_row].dup
+        @table_state[:current_row] = []
+        "#{content}\n"
       end
 
       def table_cell(content, alignment)
+        @table_state[:current_row] << content.strip
         content
       end
 
-      # 换行
-      def linebreak
-        "\n"
+      private
+
+      def process_inline(text)
+        return text if text.nil? || text.empty?
+
+        result = text.dup
+        INLINE_MARKERS.each do |regex, handler|
+          result.gsub!(regex, &handler)
+        end
+        result
       end
 
-      private
+      def self.codespan_compat(code)
+        "#{AnsiCode.background(:white)}#{AnsiCode.color(:black)} #{code} #{AnsiCode.reset}"
+      end
 
       def wrap_text(text, width = nil)
         width ||= @options[:width]
         return text if text.length <= width
-        
+
         words = text.split(' ')
         lines = []
         current_line = ''
-        
+
         words.each do |word|
           if (current_line + ' ' + word).length <= width
             current_line += current_line.empty? ? word : ' ' + word
@@ -197,125 +175,17 @@ module RubyRich
             current_line = word
           end
         end
-        
+
         lines << current_line unless current_line.empty?
         lines.join("\n")
       end
 
       def indent_lines(text)
-        text.split("\n").map { |line| @options[:indent] + line }.join("\n")
+        text.split("\n").map { |line| "#{@options[:indent]}#{line}" }.join("\n")
       end
 
-      def parse_table_content(content)
-        lines = content.strip.split("\n").map(&:strip).reject(&:empty?)
-        return [] if lines.empty?
-        
-        rows = []
-        lines.each do |line|
-          # 跳过分隔符行（如 |------|--------|）
-          next if line.match?(/^\|[\s\-\|:]+\|?$/)
-          
-          # 解析表格行
-          if line.start_with?('|') && line.end_with?('|')
-            cells = line[1..-2].split('|').map(&:strip)
-            rows << cells unless cells.empty?
-          elsif line.include?('|')
-            cells = line.split('|').map(&:strip)
-            rows << cells unless cells.empty?
-          end
-        end
-        
-        rows
-      end
-
-      def render_table_with_ruby_rich(rows)
-        return "" if rows.empty?
-        
-        # 使用第一行作为表头
-        headers = rows.first
-        data_rows = rows[1..-1] || []
-        
-        # 创建RubyRich表格，使用简单边框样式来匹配markdown风格
-        table = RubyRich::Table.new(
-          headers: headers,
-          border_style: @options[:table_border_style] || :simple
-        )
-        
-        # 添加数据行
-        data_rows.each do |row|
-          # 确保行长度与标题长度一致
-          padded_row = row + Array.new([0, headers.length - row.length].max, "")
-          table.add_row(padded_row)
-        end
-        
-        table.render + "\n\n"
-      rescue => e
-        # 如果表格渲染失败，使用简单的文字格式
-        fallback_table_render(rows)
-      end
-
-      def fallback_table_render(rows)
-        return "" if rows.empty?
-        
-        result = []
-        rows.each_with_index do |row, index|
-          result << "| " + row.join(" | ") + " |"
-          if index == 0 # 在标题下添加分隔线
-            result << "|" + ("-" * (row.join(" | ").length + 2)) + "|"
-          end
-        end
-        
-        result.join("\n") + "\n\n"
-      end
-
-      def split_table_content_intelligently(content)
-        return [] if content.nil? || content.strip.empty?
-        
-        # 策略1：更智能的分割 - 先尝试找到数字字母边界
-        split_points = []
-        content.each_char.with_index do |char, index|
-          if index > 0 && index < content.length - 1
-            prev_char = content[index - 1]
-            # 在字母后跟数字，或数字后跟字母的地方分割
-            if (prev_char =~ /[A-Za-z]/ && char =~ /\d/) ||
-               (prev_char =~ /\d/ && char =~ /[A-Za-z]/)
-              split_points << index
-            end
-          end
-        end
-        
-        if split_points.any?
-          parts = []
-          last_pos = 0
-          split_points.each do |pos|
-            parts << content[last_pos...pos] if pos > last_pos
-            last_pos = pos
-          end
-          parts << content[last_pos..-1] if last_pos < content.length
-          result = parts.reject(&:empty?)
-          return result if result.length >= 2
-        end
-        
-        # 策略2：如果没有数字字母边界，按大写字母分割（但要小心短词）
-        words = content.scan(/[A-Z][a-z]+|[A-Z]{2,}/)
-        if words.length >= 2 && words.all? { |w| w.length >= 2 }
-          return words
-        end
-        
-        # 策略3：按连续的字母和数字分组
-        parts = content.scan(/[A-Za-z]+|\d+/)
-        if parts.length >= 2
-          return parts
-        end
-        
-        # 策略4：按空格分割
-        space_parts = content.split(/\s+/).reject(&:empty?)
-        if space_parts.length >= 2
-          return space_parts
-        end
-        
-        # 最后的fallback：返回原始内容
-        [content]
+      def visible_width(text)
+        text.gsub(/\e\[[0-9;]*m/, '').length
       end
     end
 
@@ -328,7 +198,7 @@ module RubyRich
         strikethrough: true,
         space_after_headers: true
       })
-      
+
       markdown_processor.render(markdown_text)
     end
 
@@ -340,4 +210,4 @@ module RubyRich
       self.class.render(markdown_text, @options)
     end
   end
-end
+end

data/lib/ruby_rich/panel.rb

@@ -33,7 +33,7 @@ module RubyRich
           @line_pos = content_lines.size - @height + 2
         end
         @content_changed = false
-      end      
+      end
     end
 
     def home

data/lib/ruby_rich/print.rb

@@ -7,15 +7,15 @@ module RubyRich
     def print(*args)
       processed_args = args.map do |arg|
         next arg unless arg.is_a?(String)
-        
-        # 处理表情符号
+
+        # Handle emoji
         text = if arg.start_with?(':') && arg.end_with?(':')
           Emoji.find_by_alias(arg[1..-2])&.raw || arg
         else
           arg
         end
-        
-        # 处理样式标记
+
+        # Handle style markers
         while text.match?(@style_regex)
           text = text.gsub(@style_regex) do |_|
             style, content = $1, $2
@@ -52,9 +52,9 @@ module RubyRich
     end
   end
 
-  # 创建全局打印方法
+  # Create global print method
   $rich_print = RichPrint.new
   def print(*args)
     $rich_print.print(*args)
-  end 
+  end
 end

data/lib/ruby_rich/progress_manager.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RubyRich
+  class ProgressManager
+    FRAMES = %w[| / - \\].freeze
+
+    class Handle
+      attr_reader :id, :owner, :message, :state
+
+      def initialize(manager, id:, owner:, message:)
+        @manager = manager
+        @id = id
+        @owner = owner
+        @message = message
+        @state = :running
+      end
+
+      def update(message)
+        return false unless active?
+
+        @message = message.to_s
+        @manager.update(@id, @owner, @message)
+      end
+
+      def finish(message = "Done")
+        close(:done, message)
+      end
+
+      def fail(message = "Failed")
+        close(:error, message)
+      end
+
+      def cancel(message = "Cancelled")
+        close(:cancelled, message)
+      end
+
+      def active?
+        @state == :running
+      end
+
+      private
+
+      def close(state, message)
+        return false unless active?
+
+        @state = state
+        @message = message.to_s
+        @manager.finish(@id, @owner, state, @message)
+      end
+    end
+
+    def initialize(on_change: nil)
+      @stack = []
+      @mutex = Mutex.new
+      @on_change = on_change
+      @frame = 0
+      @ticker = nil
+      @running = false
+    end
+
+    def start(message, owner: Thread.current.object_id)
+      handle = Handle.new(self, id: SecureRandom.hex(6), owner: owner, message: message.to_s)
+      @mutex.synchronize { @stack << handle }
+      start_ticker
+      notify
+      handle
+    end
+
+    def update(id, owner, message)
+      ok = @mutex.synchronize do
+        handle = @stack.find { |item| item.id == id && item.owner == owner && item.active? }
+        next false unless handle
+
+        handle.instance_variable_set(:@message, message.to_s)
+        true
+      end
+      notify if ok
+      ok
+    end
+
+    def finish(id, owner, state, message)
+      ok = @mutex.synchronize do
+        handle = @stack.find { |item| item.id == id && item.owner == owner }
+        next false unless handle
+
+        handle.instance_variable_set(:@state, state)
+        handle.instance_variable_set(:@message, message.to_s)
+        @stack.delete(handle)
+        true
+      end
+      notify if ok
+      stop_ticker_if_idle
+      ok
+    end
+
+    def current
+      @mutex.synchronize { @stack.last }
+    end
+
+    def render
+      handle = current
+      return nil unless handle
+
+      frame = FRAMES[@frame % FRAMES.length]
+      "#{frame} #{handle.message}"
+    end
+
+    def with_progress(message)
+      handle = start(message)
+      begin
+        yield handle
+        handle.finish
+      rescue Exception => e
+        handle.fail(e.message)
+        raise
+      ensure
+        handle.cancel if handle.active?
+      end
+    end
+
+    private
+
+    def notify
+      @on_change&.call(render)
+    end
+
+    def start_ticker
+      return if @ticker&.alive?
+
+      @running = true
+      @ticker = Thread.new do
+        while @running
+          sleep 0.12
+          @frame += 1
+          notify
+        end
+      end
+    end
+
+    def stop_ticker_if_idle
+      return if current
+
+      @running = false
+      @ticker&.kill
+      @ticker = nil
+    end
+  end
+end