ruby_rich 0.3.1 → 0.4.1

data/lib/ruby_rich/markdown.rb

@@ -0,0 +1,213 @@
+require 'redcarpet'
+
+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)
+        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"
+        end
+      end
+
+      def block_code(code, language)
+        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)
+        "#{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"
+      end
+
+      def list_item(text, list_type)
+        marker = list_type == :ordered ? '1.' : '•'
+        "#{AnsiCode.color(:cyan, true)}#{marker}#{AnsiCode.reset} #{process_inline(text.strip)}\n"
+      end
+
+      def list(contents, list_type)
+        "#{contents}\n"
+      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 link(link, title, content)
+        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)
+        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
+        "#{AnsiCode.color(:black, true)}#{"─" * @options[:width]}#{AnsiCode.reset}\n\n"
+      end
+
+      def linebreak = "\n"
+
+      # ---- 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..] || []
+
+        return "" if header_rows.empty? || body_rows.empty?
+
+        headers = header_rows.last.map { |c| process_inline(c) }
+        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.add_row(padded[0...headers.length])
+          end
+          return "#{tbl.render}\n\n"
+        rescue
+          # fallback
+        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)
+        @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
+
+      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
+
+      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
+          else
+            lines << current_line unless current_line.empty?
+            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")
+      end
+
+      def visible_width(text)
+        text.gsub(/\e\[[0-9;]*m/, '').length
+      end
+    end
+
+    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)
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def render(markdown_text)
+      self.class.render(markdown_text, @options)
+    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_bar.rb

@@ -1,29 +1,247 @@
 module RubyRich
   class ProgressBar
     
-    attr_reader :progress
+    attr_reader :progress, :total, :start_time
 
-    def initialize(total, width: 50, style: :default)
+    # 进度条样式
+    STYLES = {
+      default: { filled: '=', empty: ' ', prefix: '[', suffix: ']' },
+      blocks: { filled: '█', empty: '░', prefix: '[', suffix: ']' },
+      arrows: { filled: '>', empty: '-', prefix: '[', suffix: ']' },
+      dots: { filled: '●', empty: '○', prefix: '(', suffix: ')' },
+      line: { filled: '━', empty: '─', prefix: '│', suffix: '│' },
+      gradient: { filled: ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'], empty: ' ', prefix: '[', suffix: ']' }
+    }.freeze
+
+    def initialize(total, width: 50, style: :default, title: nil, show_percentage: true, show_rate: false, show_eta: false)
       @total = total
       @progress = 0
       @width = width
       @style = style
+      @title = title
+      @show_percentage = show_percentage
+      @show_rate = show_rate
+      @show_eta = show_eta
+      @start_time = nil
+      @last_update_time = nil
+      @update_history = []
     end
 
-    def advance(amount)
+    def start
+      @start_time = Time.now
+      @last_update_time = @start_time
+      render
+    end
+
+    def advance(amount = 1)
+      @start_time ||= Time.now
       @progress += amount
-      @progress = @total if @progress > @total
+      @progress = [@progress, @total].min
+      
+      current_time = Time.now
+      @update_history << { time: current_time, progress: @progress }
+      
+      # 保留最近的几个更新用于计算速率
+      @update_history = @update_history.last(10)
+      @last_update_time = current_time
+      
       render
+      puts if completed?
+    end
+
+    def set_progress(value)
+      @start_time ||= Time.now
+      @progress = [[value, 0].max, @total].min
+      
+      current_time = Time.now
+      @update_history << { time: current_time, progress: @progress }
+      @update_history = @update_history.last(10)
+      @last_update_time = current_time
+      
+      render
+      puts if completed?
+    end
+
+    def completed?
+      @progress >= @total
+    end
+
+    def percentage
+      return 0 if @total == 0
+      (@progress.to_f / @total * 100).round(1)
+    end
+
+    def elapsed_time
+      return 0 unless @start_time
+      Time.now - @start_time
+    end
+
+    def rate
+      return 0 if @update_history.length < 2
+      
+      first_update = @update_history.first
+      last_update = @update_history.last
+      
+      time_diff = last_update[:time] - first_update[:time]
+      progress_diff = last_update[:progress] - first_update[:progress]
+      
+      return 0 if time_diff == 0
+      progress_diff / time_diff
+    end
+
+    def eta
+      return 0 if rate == 0 || completed?
+      remaining = @total - @progress
+      remaining / rate
     end
 
     def render
-      percentage = (@progress.to_f / @total * 100).to_i
-      completed_width = (@progress.to_f / @total * @width).to_i
-      incomplete_width = @width - completed_width
+      bar_content = render_bar
+      status_text = render_status
+      
+      output = ""
+      output << "\e[94m#{@title}: \e[0m" if @title
+      output << bar_content
+      output << " #{status_text}" unless status_text.empty?
+      
+      print "\r\e[K#{output}"
+      $stdout.flush
+    end
+
+    def finish(message: nil)
+      if message
+        puts "\r\e[K#{message}"
+      else
+        puts
+      end
+    end
+
+    # 静态方法：创建带回调的进度条
+    def self.with_progress(total, **options)
+      bar = new(total, **options)
+      bar.start
+      
+      begin
+        yield(bar) if block_given?
+      ensure
+        bar.finish
+      end
+      
+      bar
+    end
+
+    # 多进度条管理器
+    class MultiProgress
+      def initialize
+        @bars = []
+        @active = false
+      end
+
+      def add(title, total, **options)
+        bar = ProgressBar.new(total, title: title, **options)
+        @bars << bar
+        bar
+      end
+
+      def start
+        @active = true
+        render_all
+      end
+
+      def render_all
+        return unless @active
+        
+        print "\e[#{@bars.length}A" unless @bars.empty? # 移动光标到顶部
+        
+        @bars.each_with_index do |bar, index|
+          bar_output = render_bar_line(bar)
+          puts "\e[K#{bar_output}"
+        end
+        
+        $stdout.flush
+      end
+
+      def finish_all
+        @active = false
+        puts
+      end
+
+      private
+
+      def render_bar_line(bar)
+        bar_content = bar.send(:render_bar)
+        status_text = bar.send(:render_status)
+        
+        output = ""
+        output << "\e[94m#{bar.instance_variable_get(:@title)}: \e[0m" if bar.instance_variable_get(:@title)
+        output << bar_content
+        output << " #{status_text}" unless status_text.empty?
+        output
+      end
+    end
+
+    private
+
+    def render_bar
+      style_config = STYLES[@style] || STYLES[:default]
+      
+      completed_width = (@progress.to_f / @total * @width).round
+      
+      if @style == :gradient
+        filled_chars = style_config[:filled]
+        filled_full = filled_chars.last * (completed_width / filled_chars.length)
+        filled_partial = filled_chars[completed_width % filled_chars.length] if completed_width % filled_chars.length > 0
+        filled = filled_full + (filled_partial || '')
+        empty = style_config[:empty] * (@width - filled.length)
+      else
+        filled = style_config[:filled] * completed_width
+        empty = style_config[:empty] * (@width - completed_width)
+      end
+      
+      # 添加颜色
+      color_filled = completed? ? "\e[92m" : "\e[96m"  # 完成时绿色，进行中蓝色
+      color_empty = "\e[90m"  # 空白部分灰色
+      color_reset = "\e[0m"
+      
+      "#{style_config[:prefix]}#{color_filled}#{filled}#{color_empty}#{empty}#{color_reset}#{style_config[:suffix]}"
+    end
+
+    def render_status
+      parts = []
+      
+      if @show_percentage
+        parts << "#{percentage}%"
+      end
+      
+      parts << "(#{@progress}/#{@total})"
+      
+      if @show_rate && rate > 0
+        parts << sprintf("%.1f/s", rate)
+      end
+      
+      if @show_eta && eta > 0 && !completed?
+        eta_formatted = format_time(eta)
+        parts << "ETA: #{eta_formatted}"
+      end
+      
+      if @start_time
+        elapsed_formatted = format_time(elapsed_time)
+        parts << "#{elapsed_formatted}"
+      end
+      
+      parts.join(" ")
+    end
 
-      bar = "[#{"=" * completed_width}#{" " * incomplete_width}]"
-      print "\r#{bar} #{percentage}%"
-      puts if @progress == @total
+    def format_time(seconds)
+      if seconds < 60
+        sprintf("%.1fs", seconds)
+      elsif seconds < 3600
+        minutes = seconds / 60
+        sprintf("%.1fm", minutes)
+      else
+        hours = seconds / 3600
+        sprintf("%.1fh", hours)
+      end
     end
   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