ruby_rich 0.3.1 → 0.4.1

data/lib/ruby_rich/terminal.rb

@@ -0,0 +1,510 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+require 'tty-cursor'
+require_relative 'event'
+
+module RubyRich
+  class Terminal
+    MOUSE_ENABLE = "\e[?1000h\e[?1002h\e[?1006h"
+    MOUSE_DISABLE = "\e[?1006l\e[?1002l\e[?1000l"
+    AUTOWRAP_ENABLE = "\e[?7h"
+    AUTOWRAP_DISABLE = "\e[?7l"
+    ALT_SCREEN_ENABLE = "\e[?1049h"
+    ALT_SCREEN_DISABLE = "\e[?1049l"
+    BRACKETED_PASTE_ENABLE = "\e[?2004h"
+    BRACKETED_PASTE_DISABLE = "\e[?2004l"
+    STD_INPUT_HANDLE = -10
+    STD_OUTPUT_HANDLE = -11
+    ENABLE_MOUSE_INPUT = 0x0010
+    ENABLE_WINDOW_INPUT = 0x0008
+    ENABLE_QUICK_EDIT_MODE = 0x0040
+    ENABLE_EXTENDED_FLAGS = 0x0080
+    ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    ENABLE_PROCESSED_OUTPUT = 0x0001
+    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    INPUT_RECORD_SIZE = 20
+    KEY_EVENT = 0x0001
+    MOUSE_EVENT = 0x0002
+    FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001
+    RIGHTMOST_BUTTON_PRESSED = 0x0002
+    FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004
+    MOUSE_MOVED = 0x0001
+    DOUBLE_CLICK = 0x0002
+    MOUSE_WHEELED = 0x0004
+    MOUSE_HWHEELED = 0x0008
+    RIGHT_ALT_PRESSED = 0x0001
+    LEFT_ALT_PRESSED = 0x0002
+    RIGHT_CTRL_PRESSED = 0x0004
+    LEFT_CTRL_PRESSED = 0x0008
+    SHIFT_PRESSED = 0x0010
+
+    class << self
+      attr_accessor :debug_input
+
+      def setup(mouse: false, hide_cursor: true, autowrap: true, alt_screen: false)
+        capture_state
+        enable_virtual_terminal_on_windows
+        system('stty -echo') unless windows?
+        enter_alt_screen if alt_screen
+        enable_bracketed_paste
+        set_autowrap(autowrap)
+        print TTY::Cursor.hide if hide_cursor
+        enable_mouse if mouse
+      end
+
+      def restore(mouse: false, show_cursor: true, autowrap: true, alt_screen: false)
+        disable_mouse if mouse
+        disable_bracketed_paste
+        set_autowrap(autowrap)
+        leave_alt_screen if alt_screen
+        restore_virtual_terminal_on_windows
+        system("stty #{@original_state}") if @original_state && !windows?
+        print TTY::Cursor.show if show_cursor
+      end
+
+      def enable_mouse
+        @mouse_reporting_enabled = true
+        enable_windows_input_mode if windows?
+        print MOUSE_ENABLE
+        $stdout.flush
+      end
+
+      def disable_mouse
+        @mouse_reporting_enabled = false
+        print MOUSE_DISABLE
+        $stdout.flush
+      end
+
+      def set_autowrap(enabled)
+        print(enabled ? AUTOWRAP_ENABLE : AUTOWRAP_DISABLE)
+        $stdout.flush
+      end
+
+      def enter_alt_screen
+        print ALT_SCREEN_ENABLE
+        $stdout.flush
+      end
+
+      def leave_alt_screen
+        print ALT_SCREEN_DISABLE
+        $stdout.flush
+      end
+
+      def enable_bracketed_paste
+        print BRACKETED_PASTE_ENABLE
+        $stdout.flush
+      end
+
+      def disable_bracketed_paste
+        print BRACKETED_PASTE_DISABLE
+        $stdout.flush
+      end
+
+      def clear
+        print "\e[2J\e[H"
+        $stdout.flush
+      end
+
+      def with_cooked(mouse: false, alt_screen: false)
+        restore(mouse: mouse, alt_screen: alt_screen)
+        yield
+      ensure
+        setup(mouse: mouse, alt_screen: alt_screen, autowrap: false)
+      end
+
+      def prepare_input
+        return unless windows?
+
+        enable_windows_input_mode
+      end
+
+      def windows_input_mode
+        return nil unless windows?
+
+        console_mode(get_std_handle.call(STD_INPUT_HANDLE))
+      rescue
+        nil
+      end
+
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      end
+
+      def windows_mouse_reporting?
+        windows? && @mouse_reporting_enabled
+      end
+
+      def read_windows_input_event
+        return nil unless windows?
+        pending = next_windows_pending_event
+        return pending if pending
+
+        enable_windows_input_mode
+        handle = get_std_handle.call(STD_INPUT_HANDLE)
+        record = Fiddle::Pointer.malloc(INPUT_RECORD_SIZE)
+        read_count = Fiddle::Pointer.malloc(4)
+
+        loop do
+          return nil unless read_console_input.call(handle, record, 1, read_count) != 0
+          next unless read_count[0, 4].unpack1('L') == 1
+
+          event = parse_windows_input_record(record)
+          event = coalesce_windows_paste(handle, event) if paste_seed_event?(event)
+          return event if event
+        end
+      rescue
+        nil
+      end
+
+      private
+
+      def capture_state
+        @original_state = windows? ? nil : `stty -g`.strip
+      rescue
+        @original_state = nil
+      end
+
+      def enable_virtual_terminal_on_windows
+        return unless windows?
+
+        @windows_console_modes ||= {}
+
+        enable_windows_output_mode
+        enable_windows_input_mode
+      rescue
+        nil
+      end
+
+      def enable_windows_output_mode
+        handle = get_std_handle.call(STD_OUTPUT_HANDLE)
+        mode = console_mode(handle)
+        return unless mode
+
+        @windows_console_modes ||= {}
+        @windows_console_modes[handle.to_i] ||= { handle: handle, mode: mode }
+        set_console_mode.call(handle, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+      end
+
+      def enable_windows_input_mode
+        handle = get_std_handle.call(STD_INPUT_HANDLE)
+        mode = console_mode(handle)
+        return unless mode
+
+        @windows_console_modes ||= {}
+        @windows_console_modes[handle.to_i] ||= { handle: handle, mode: mode }
+        next_mode = mode
+        next_mode |= ENABLE_EXTENDED_FLAGS
+        next_mode |= ENABLE_MOUSE_INPUT
+        next_mode |= ENABLE_WINDOW_INPUT
+        next_mode &= ~ENABLE_QUICK_EDIT_MODE
+        set_console_mode.call(handle, next_mode)
+      end
+
+      def restore_virtual_terminal_on_windows
+        return unless windows?
+        return unless @windows_console_modes && !@windows_console_modes.empty?
+
+        require 'fiddle'
+        kernel32 = Fiddle.dlopen('kernel32')
+        set_console_mode = Fiddle::Function.new(
+          kernel32['SetConsoleMode'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG],
+          Fiddle::TYPE_INT
+        )
+
+        @windows_console_modes.each_value do |entry|
+          set_console_mode.call(entry[:handle], entry[:mode])
+        end
+        @windows_console_modes.clear
+      rescue
+        nil
+      end
+
+      def console_mode(handle)
+        mode_ptr = Fiddle::Pointer.malloc(4)
+        return nil unless get_console_mode.call(handle, mode_ptr) != 0
+
+        mode_ptr[0, 4].unpack1('L')
+      end
+
+      def kernel32
+        @kernel32 ||= begin
+          ensure_fiddle
+          Fiddle.dlopen('kernel32')
+        end
+      end
+
+      def get_std_handle
+        ensure_fiddle
+        @get_std_handle ||= Fiddle::Function.new(
+          kernel32['GetStdHandle'],
+          [Fiddle::TYPE_LONG],
+          Fiddle::TYPE_VOIDP
+        )
+      end
+
+      def get_console_mode
+        ensure_fiddle
+        @get_console_mode ||= Fiddle::Function.new(
+          kernel32['GetConsoleMode'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT
+        )
+      end
+
+      def set_console_mode
+        ensure_fiddle
+        @set_console_mode ||= Fiddle::Function.new(
+          kernel32['SetConsoleMode'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG],
+          Fiddle::TYPE_INT
+        )
+      end
+
+      def read_console_input
+        ensure_fiddle
+        @read_console_input ||= Fiddle::Function.new(
+          kernel32['ReadConsoleInputW'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT
+        )
+      end
+
+      def get_number_of_console_input_events
+        ensure_fiddle
+        @get_number_of_console_input_events ||= Fiddle::Function.new(
+          kernel32['GetNumberOfConsoleInputEvents'],
+          [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP],
+          Fiddle::TYPE_INT
+        )
+      end
+
+      def parse_windows_input_record(record)
+        event_type = record[0, 2].unpack1('S')
+
+        case event_type
+        when KEY_EVENT
+          parse_windows_key_record(record)
+        when MOUSE_EVENT
+          parse_windows_mouse_record(record)
+        end
+      end
+
+      def next_windows_pending_event
+        return nil unless @windows_pending_events && !@windows_pending_events.empty?
+
+        @windows_pending_events.shift
+      end
+
+      def paste_seed_event?(event)
+        event && event[:type] == :key && [:string, :enter, :tab].include?(event[:name])
+      end
+
+      def coalesce_windows_paste(handle, first_event)
+        events = [first_event]
+        sleep 0.002
+        available = windows_input_event_count(handle)
+
+        while available && available.positive?
+          record = Fiddle::Pointer.malloc(INPUT_RECORD_SIZE)
+          read_count = Fiddle::Pointer.malloc(4)
+          break unless read_console_input.call(handle, record, 1, read_count) != 0
+          break unless read_count[0, 4].unpack1('L') == 1
+
+          event = parse_windows_input_record(record)
+          if paste_seed_event?(event)
+            events << event
+          elsif event
+            (@windows_pending_events ||= []) << event
+          end
+          available = windows_input_event_count(handle)
+        end
+
+        finish_windows_coalesced_events(events, first_event)
+      rescue
+        first_event
+      end
+
+      def finish_windows_coalesced_events(events, first_event)
+        if windows_enter_burst?(events)
+          first_event
+        elsif windows_paste_burst?(events)
+          Event.key(:paste, value: events.map { |event| windows_paste_text(event) }.join)
+        else
+          (@windows_pending_events ||= []).concat(events[1..] || [])
+          first_event
+        end
+      end
+
+      def windows_enter_burst?(events)
+        events.length <= 2 && events.all? { |event| event[:name] == :enter }
+      end
+
+      def windows_paste_burst?(events)
+        return false if events.length <= 1
+
+        events.any? { |event| event[:name] == :enter } || events.length >= 4
+      end
+
+      def windows_paste_text(event)
+        case event[:name]
+        when :string
+          event[:value].to_s
+        when :enter
+          "\n"
+        when :tab
+          "\t"
+        else
+          ""
+        end
+      end
+
+      def windows_input_event_count(handle)
+        count_ptr = Fiddle::Pointer.malloc(4)
+        return nil unless get_number_of_console_input_events.call(handle, count_ptr) != 0
+
+        count_ptr[0, 4].unpack1('L')
+      end
+
+      def parse_windows_key_record(record)
+        key_down = record[4, 4].unpack1('L') != 0
+        return nil unless key_down
+
+        virtual_key = record[10, 2].unpack1('S')
+        control_state = record[12, 4].unpack1('L')
+        char_code = record[14, 2].unpack1('S')
+        char = char_code.zero? ? nil : char_code.chr(Encoding::UTF_8)
+        modifiers = windows_key_modifiers(control_state)
+
+        case virtual_key
+        when 13
+          return annotate_windows_key_event(Event.key(:alt_enter), virtual_key, char_code, control_state, modifiers) if modifiers.include?(:alt)
+          return annotate_windows_key_event(Event.key(:ctrl_enter), virtual_key, char_code, control_state, modifiers) if char_code == 10 && modifiers.include?(:ctrl)
+          return annotate_windows_key_event(Event.key(:shift_enter), virtual_key, char_code, control_state, modifiers) if char_code == 10
+
+          annotate_windows_key_event(Event.key(:enter), virtual_key, char_code, control_state, modifiers)
+        when 9
+          modifiers.include?(:shift) ? Event.key(:shift_tab) : Event.key(:tab)
+        when 8 then Event.key(:backspace)
+        when 27 then Event.key(:escape)
+        when 37 then Event.key(:left)
+        when 38 then Event.key(:up)
+        when 39 then Event.key(:right)
+        when 40 then Event.key(:down)
+        when 33 then Event.key(:page_up)
+        when 34 then Event.key(:page_down)
+        when 35 then Event.key(:end)
+        when 36 then Event.key(:home)
+        when 46 then Event.key(:delete)
+        else
+          ctrl_event = windows_ctrl_key_event(char_code)
+          return ctrl_event if ctrl_event
+          return Event.key(:ctrl_c) if char_code == 3
+          return nil unless char && !char.empty?
+
+          Event.key(:string, value: char)
+        end
+      rescue RangeError
+        nil
+      end
+
+      def parse_windows_mouse_record(record)
+        raw_x = record[4, 2].unpack1('s')
+        raw_y = record[6, 2].unpack1('s')
+        button_state = record[8, 4].unpack1('L')
+        control_state = record[12, 4].unpack1('L')
+        event_flags = record[16, 4].unpack1('L')
+
+        if (event_flags & MOUSE_WHEELED) == MOUSE_WHEELED
+          delta = signed_high_word(button_state)
+          return Event.mouse(
+            :mouse_wheel,
+            button: :wheel,
+            x: raw_x,
+            y: raw_y,
+            raw_x: raw_x + 1,
+            raw_y: raw_y + 1,
+            code: button_state,
+            modifiers: windows_mouse_modifiers(control_state),
+            direction: delta.negative? ? :down : :up
+          )
+        end
+
+        if (event_flags & MOUSE_MOVED) == MOUSE_MOVED
+          return nil if button_state.zero?
+
+          return windows_mouse_event(:mouse_drag, raw_x, raw_y, button_state, control_state)
+        end
+
+        if button_state.zero?
+          return windows_mouse_event(:mouse_up, raw_x, raw_y, button_state, control_state)
+        end
+
+        windows_mouse_event(:mouse_down, raw_x, raw_y, button_state, control_state)
+      end
+
+      def windows_mouse_event(name, raw_x, raw_y, button_state, control_state)
+        Event.mouse(
+          name,
+          button: windows_mouse_button(button_state),
+          x: raw_x,
+          y: raw_y,
+          raw_x: raw_x + 1,
+          raw_y: raw_y + 1,
+          code: button_state,
+          modifiers: windows_mouse_modifiers(control_state)
+        )
+      end
+
+      def windows_mouse_button(button_state)
+        return :left if (button_state & FROM_LEFT_1ST_BUTTON_PRESSED) != 0
+        return :right if (button_state & RIGHTMOST_BUTTON_PRESSED) != 0
+        return :middle if (button_state & FROM_LEFT_2ND_BUTTON_PRESSED) != 0
+
+        :unknown
+      end
+
+      def windows_mouse_modifiers(control_state)
+        windows_key_modifiers(control_state)
+      end
+
+      def windows_key_modifiers(control_state)
+        modifiers = []
+        modifiers << :shift if (control_state & SHIFT_PRESSED) != 0
+        modifiers << :ctrl if (control_state & LEFT_CTRL_PRESSED) != 0 || (control_state & RIGHT_CTRL_PRESSED) != 0
+        modifiers << :alt if (control_state & LEFT_ALT_PRESSED) != 0 || (control_state & RIGHT_ALT_PRESSED) != 0
+        modifiers
+      end
+
+      def windows_ctrl_key_event(char_code)
+        return nil unless char_code.between?(1, 26)
+
+        ctrl_char = (char_code + 64).chr.downcase
+        Event.key("ctrl_#{ctrl_char}".to_sym)
+      end
+
+      def annotate_windows_key_event(event, virtual_key, char_code, control_state, modifiers)
+        return event unless @debug_input
+
+        event.merge(
+          raw: {
+            virtual_key: virtual_key,
+            char_code: char_code,
+            control_state: control_state,
+            modifiers: modifiers
+          }
+        )
+      end
+
+      def signed_high_word(value)
+        high = (value >> 16) & 0xffff
+        high >= 0x8000 ? high - 0x10000 : high
+      end
+
+      def ensure_fiddle
+        require 'fiddle'
+      end
+    end
+  end
+end

data/lib/ruby_rich/text.rb

@@ -1,6 +1,6 @@
 module RubyRich
   class RichText
-    # 默认主题
+    # Default theme
     @@theme = {
       error: { color: :red, bold: true },
       success: { color: :green, bold: true },
@@ -8,6 +8,43 @@ module RubyRich
       warning: { color: :yellow, bold: true }
     }
 
+    # Rich markup 标记映射
+    MARKUP_PATTERNS = {
+      # Basic colors
+      /\[red\](.*?)\[\/red\]/m => proc { |text| "\e[31m#{text}\e[0m" },
+      /\[green\](.*?)\[\/green\]/m => proc { |text| "\e[32m#{text}\e[0m" },
+      /\[yellow\](.*?)\[\/yellow\]/m => proc { |text| "\e[33m#{text}\e[0m" },
+      /\[blue\](.*?)\[\/blue\]/m => proc { |text| "\e[34m#{text}\e[0m" },
+      /\[magenta\](.*?)\[\/magenta\]/m => proc { |text| "\e[35m#{text}\e[0m" },
+      /\[cyan\](.*?)\[\/cyan\]/m => proc { |text| "\e[36m#{text}\e[0m" },
+      /\[white\](.*?)\[\/white\]/m => proc { |text| "\e[37m#{text}\e[0m" },
+      /\[black\](.*?)\[\/black\]/m => proc { |text| "\e[30m#{text}\e[0m" },
+      
+      # Bright colors
+      /\[bright_red\](.*?)\[\/bright_red\]/m => proc { |text| "\e[91m#{text}\e[0m" },
+      /\[bright_green\](.*?)\[\/bright_green\]/m => proc { |text| "\e[92m#{text}\e[0m" },
+      /\[bright_yellow\](.*?)\[\/bright_yellow\]/m => proc { |text| "\e[93m#{text}\e[0m" },
+      /\[bright_blue\](.*?)\[\/bright_blue\]/m => proc { |text| "\e[94m#{text}\e[0m" },
+      /\[bright_magenta\](.*?)\[\/bright_magenta\]/m => proc { |text| "\e[95m#{text}\e[0m" },
+      /\[bright_cyan\](.*?)\[\/bright_cyan\]/m => proc { |text| "\e[96m#{text}\e[0m" },
+      /\[bright_white\](.*?)\[\/bright_white\]/m => proc { |text| "\e[97m#{text}\e[0m" },
+      
+      # Text styles
+      /\[bold\](.*?)\[\/bold\]/m => proc { |text| "\e[1m#{text}\e[22m" },
+      /\[dim\](.*?)\[\/dim\]/m => proc { |text| "\e[2m#{text}\e[22m" },
+      /\[italic\](.*?)\[\/italic\]/m => proc { |text| "\e[3m#{text}\e[23m" },
+      /\[underline\](.*?)\[\/underline\]/m => proc { |text| "\e[4m#{text}\e[24m" },
+      /\[blink\](.*?)\[\/blink\]/m => proc { |text| "\e[5m#{text}\e[25m" },
+      /\[reverse\](.*?)\[\/reverse\]/m => proc { |text| "\e[7m#{text}\e[27m" },
+      /\[strikethrough\](.*?)\[\/strikethrough\]/m => proc { |text| "\e[9m#{text}\e[29m" },
+      
+      # Combined styles
+      /\[bold\s+(\w+)\](.*?)\[\/bold\s+\1\]/m => proc do |text, color_match|
+        color_code = color_to_ansi(color_match)
+        "\e[1m#{color_code}#{text}\e[0m"
+      end
+    }.freeze
+
     def self.set_theme(new_theme)
       @@theme.merge!(new_theme)
     end
@@ -34,11 +71,84 @@ module RubyRich
     end
 
     def render
-      "#{@styles.join}#{@text}#{AnsiCode.reset}"
+      processed_text = process_markup(@text)
+      "#{@styles.join}#{processed_text}#{AnsiCode.reset}"
+    end
+
+    # 处理 Rich markup 标记语言
+    def self.markup(text)
+      new(text).render_markup
+    end
+
+    def render_markup
+      process_markup(@text)
     end
 
     private
 
+    def process_markup(text)
+      result = text.dup
+      
+      # 处理组合样式 (如 [bold red])
+      result.gsub!(/\[(\w+)\s+(\w+)\](.*?)\[\/\1\s+\2\]/m) do |match|
+        style1, style2, content = $1, $2, $3
+        
+        # 确定哪个是样式，哪个是颜色
+        if is_color?(style2)
+          apply_combined_style(content, style1, style2)
+        elsif is_color?(style1)
+          apply_combined_style(content, style2, style1)
+        else
+          match # 无法处理的组合，返回原文
+        end
+      end
+      
+      # 处理基本样式和颜色
+      MARKUP_PATTERNS.each do |pattern, processor|
+        result.gsub!(pattern) do |match|
+          if pattern.source.include?('\\s+')
+            # 这是组合样式，已经在上面处理过了
+            match
+          else
+            processor.call($1)
+          end
+        end
+      end
+      
+      result
+    end
+
+    def apply_combined_style(content, style, color)
+      color_code = color_to_ansi(color)
+      style_code = style_to_ansi(style)
+      "#{style_code}#{color_code}#{content}\e[0m"
+    end
+
+    def is_color?(word)
+      %w[red green yellow blue magenta cyan white black bright_red bright_green bright_yellow bright_blue bright_magenta bright_cyan bright_white].include?(word)
+    end
+
+    def color_to_ansi(color)
+      color_map = {
+        'red' => "\e[31m", 'green' => "\e[32m", 'yellow' => "\e[33m",
+        'blue' => "\e[34m", 'magenta' => "\e[35m", 'cyan' => "\e[36m",
+        'white' => "\e[37m", 'black' => "\e[30m",
+        'bright_red' => "\e[91m", 'bright_green' => "\e[92m", 'bright_yellow' => "\e[93m",
+        'bright_blue' => "\e[94m", 'bright_magenta' => "\e[95m", 'bright_cyan' => "\e[96m",
+        'bright_white' => "\e[97m"
+      }
+      color_map[color] || ""
+    end
+
+    def style_to_ansi(style)
+      style_map = {
+        'bold' => "\e[1m", 'dim' => "\e[2m", 'italic' => "\e[3m",
+        'underline' => "\e[4m", 'blink' => "\e[5m", 'reverse' => "\e[7m",
+        'strikethrough' => "\e[9m"
+      }
+      style_map[style] || ""
+    end
+
     def add_style(code, error_message)
       if code
         @styles << code