grmenu 4.1.0 → 5.0.0

data/grmenu/set_style.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Gestiona los colores, bordes y estilos visuales del menu.
+  # Soporta encadenamiento de metodos (method chaining) y priorizacion estricta:
+  # Cualquier valor configurado explicitamente por codigo tendra prioridad
+  # absoluta sobre hojas de estilo CSS .gr o bloques <<-GR.
+  class SetStyle
+    # Inicializa la configuracion de estilo con valores predeterminados
+    def initialize(
+      border:   { color: "cyan",    level: 1 },
+      options:  { color: "white",   level: 1 },
+      focus:    { color: "green",   level: 2 },
+      title:    { color: "yellow",  level: 2 },
+      banner:   { color: "magenta", level: 2 },
+      subtitle: { color: "cyan",    level: 2 },
+      divider:  { color: "blue",    level: 1 },
+      font:     1,
+      desc_prefix: "[i]"
+    )
+      @border      = border.dup
+      @options     = options.dup
+      @focus       = focus.dup
+      @title       = title.dup
+      @banner      = banner.dup
+      @subtitle    = subtitle.dup
+      @divider     = divider.dup
+      @font        = font.to_i
+      @desc_prefix = desc_prefix.to_s
+
+      # Hash para registrar que atributos fueron fijados por el desarrollador en codigo.
+      # Evita que temas CSS posteriores sobreescriban decisiones explicitas del programador.
+      @explicitly_set = {}
+    end
+
+    # Comprueba si un atributo fue fijado explicitamente a nivel de instancia o de clase
+    def explicitly_set?(key)
+      @explicitly_set ||= {}
+      @explicitly_set[key.to_sym] == true || self.class.explicitly_set?(key)
+    end
+
+    # Marca un atributo como fijado explicitamente por el usuario
+    def mark_explicit(key)
+      @explicitly_set ||= {}
+      @explicitly_set[key.to_sym] = true
+    end
+
+    # Configura o consulta el prefijo usado en las descripciones de opciones (ej. "[i]")
+    def desc_prefix(prefix_str = nil, from_css: false)
+      return @desc_prefix if prefix_str.nil?
+      return self if from_css && explicitly_set?(:desc_prefix)
+      @explicitly_set ||= {}
+      @explicitly_set[:desc_prefix] = true unless from_css
+      @desc_prefix = prefix_str.to_s
+      self
+    end
+    alias_method :description_prefix, :desc_prefix
+    alias_method :desc_prefix=, :desc_prefix
+    alias_method :description_prefix=, :desc_prefix
+
+    # Configura o consulta el color del borde del menu principal
+    def border(color_name = nil, brightness_level = 1, from_css: false)
+      return @border if color_name.nil?
+      return self if from_css && explicitly_set?(:border)
+      @explicitly_set ||= {}
+      @explicitly_set[:border] = true unless from_css
+      @border = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Border, :border
+    alias_method :set_border, :border
+    alias_method :border=, :border
+
+    # Configura o consulta el color de las opciones inactivas
+    def options(color_name = nil, brightness_level = 1, from_css: false)
+      return @options if color_name.nil?
+      return self if from_css && explicitly_set?(:options)
+      @explicitly_set ||= {}
+      @explicitly_set[:options] = true unless from_css
+      @options = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Options, :options
+    alias_method :set_options, :options
+    alias_method :options=, :options
+
+    # Configura o consulta el color de la opcion seleccionada (foco)
+    def focus(color_name = nil, brightness_level = 2, from_css: false)
+      return @focus if color_name.nil?
+      return self if from_css && explicitly_set?(:focus)
+      @explicitly_set ||= {}
+      @explicitly_set[:focus] = true unless from_css
+      @focus = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Focus, :focus
+    alias_method :set_focus, :focus
+    alias_method :focus=, :focus
+
+    # Configura o consulta el color del titulo del menu
+    def title(color_name = nil, brightness_level = 2, from_css: false)
+      return @title if color_name.nil?
+      return self if from_css && explicitly_set?(:title)
+      @explicitly_set ||= {}
+      @explicitly_set[:title] = true unless from_css
+      @title = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Title, :title
+    alias_method :set_title, :title
+    alias_method :title=, :title
+
+    # Configura o consulta el color del banner ASCII superior
+    def banner(color_name = nil, brightness_level = 2, from_css: false)
+      return @banner if color_name.nil?
+      return self if from_css && explicitly_set?(:banner)
+      @explicitly_set ||= {}
+      @explicitly_set[:banner] = true unless from_css
+      @banner = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Banner, :banner
+    alias_method :set_banner, :banner
+    alias_method :banner=, :banner
+
+    # Configura o consulta el color del subtitulo o descripcion superior
+    def subtitle(color_name = nil, brightness_level = 2, from_css: false)
+      return @subtitle if color_name.nil?
+      return self if from_css && explicitly_set?(:subtitle)
+      @explicitly_set ||= {}
+      @explicitly_set[:subtitle] = true unless from_css
+      @subtitle = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Subtitle, :subtitle
+    alias_method :set_subtitle, :subtitle
+    alias_method :subtitle=, :subtitle
+
+    # Configura o consulta el color de las lineas divisorias
+    def divider(color_name = nil, brightness_level = 1, from_css: false)
+      return @divider if color_name.nil?
+      return self if from_css && explicitly_set?(:divider)
+      @explicitly_set ||= {}
+      @explicitly_set[:divider] = true unless from_css
+      @divider = parse_color(color_name, brightness_level)
+      self
+    end
+    alias_method :Divider, :divider
+    alias_method :set_divider, :divider
+    alias_method :divider=, :divider
+
+    # Configura o consulta la fuente numerica para el banner ASCII (1..10)
+    def font(font_id = nil, from_css: false)
+      return @font if font_id.nil?
+      return self if from_css && explicitly_set?(:font)
+      @explicitly_set ||= {}
+      @explicitly_set[:font] = true unless from_css
+      @font = font_id.to_i
+      self
+    end
+    alias_method :Font, :font
+    alias_method :set_font, :font
+    alias_method :font=, :font
+
+    private
+
+    # Convierte un valor de color (string o hash) a la estructura interna { color: ..., level: ... }
+    def parse_color(color_val, default_level = 1)
+      if color_val.is_a?(Hash)
+        {
+          color: (color_val[:color] || color_val["color"]).to_s,
+          level: (color_val[:level] || color_val["level"] || default_level).to_i
+        }
+      else
+        { color: color_val.to_s, level: default_level.to_i }
+      end
+    end
+
+    class << self
+      # Comprueba si un atributo fue marcado explicitamente a nivel global de clase
+      def explicitly_set?(key)
+        @explicitly_set ||= {}
+        @explicitly_set[key.to_sym] == true
+      end
+
+      # Marca un atributo global como fijado explicitamente
+      def mark_explicit(key)
+        @explicitly_set ||= {}
+        @explicitly_set[key.to_sym] = true
+      end
+
+      # Color de borde predeterminado para nuevas instancias
+      def border(color_name = nil, brightness_level = 1, from_css: false)
+        @default_border ||= { color: "cyan", level: 1 }
+        return @default_border if color_name.nil?
+        return @default_border if from_css && explicitly_set?(:border)
+        @explicitly_set ||= {}
+        @explicitly_set[:border] = true unless from_css
+        @default_border = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Border, :border
+      alias_method :border=, :border
+
+      # Color de opciones predeterminado para nuevas instancias
+      def options(color_name = nil, brightness_level = 1, from_css: false)
+        @default_options ||= { color: "white", level: 1 }
+        return @default_options if color_name.nil?
+        return @default_options if from_css && explicitly_set?(:options)
+        @explicitly_set ||= {}
+        @explicitly_set[:options] = true unless from_css
+        @default_options = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Options, :options
+      alias_method :options=, :options
+
+      # Color de foco predeterminado para nuevas instancias
+      def focus(color_name = nil, brightness_level = 2, from_css: false)
+        @default_focus ||= { color: "green", level: 2 }
+        return @default_focus if color_name.nil?
+        return @default_focus if from_css && explicitly_set?(:focus)
+        @explicitly_set ||= {}
+        @explicitly_set[:focus] = true unless from_css
+        @default_focus = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Focus, :focus
+      alias_method :focus=, :focus
+
+      # Color de titulo predeterminado para nuevas instancias
+      def title(color_name = nil, brightness_level = 2, from_css: false)
+        @default_title ||= { color: "yellow", level: 2 }
+        return @default_title if color_name.nil?
+        return @default_title if from_css && explicitly_set?(:title)
+        @explicitly_set ||= {}
+        @explicitly_set[:title] = true unless from_css
+        @default_title = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Title, :title
+      alias_method :title=, :title
+
+      # Color de banner predeterminado para nuevas instancias
+      def banner(color_name = nil, brightness_level = 2, from_css: false)
+        @default_banner ||= { color: "magenta", level: 2 }
+        return @default_banner if color_name.nil?
+        return @default_banner if from_css && explicitly_set?(:banner)
+        @explicitly_set ||= {}
+        @explicitly_set[:banner] = true unless from_css
+        @default_banner = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Banner, :banner
+      alias_method :banner=, :banner
+
+      # Color de subtitulo predeterminado para nuevas instancias
+      def subtitle(color_name = nil, brightness_level = 2, from_css: false)
+        @default_subtitle ||= { color: "cyan", level: 2 }
+        return @default_subtitle if color_name.nil?
+        return @default_subtitle if from_css && explicitly_set?(:subtitle)
+        @explicitly_set ||= {}
+        @explicitly_set[:subtitle] = true unless from_css
+        @default_subtitle = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Subtitle, :subtitle
+      alias_method :subtitle=, :subtitle
+
+      # Color de divisor predeterminado para nuevas instancias
+      def divider(color_name = nil, brightness_level = 1, from_css: false)
+        @default_divider ||= { color: "blue", level: 1 }
+        return @default_divider if color_name.nil?
+        return @default_divider if from_css && explicitly_set?(:divider)
+        @explicitly_set ||= {}
+        @explicitly_set[:divider] = true unless from_css
+        @default_divider = { color: color_name.to_s, level: brightness_level.to_i }
+      end
+      alias_method :Divider, :divider
+      alias_method :divider=, :divider
+
+      # Fuente tipografica predeterminada para nuevas instancias
+      def font(font_id = nil, from_css: false)
+        @default_font ||= 1
+        return @default_font if font_id.nil?
+        return @default_font if from_css && explicitly_set?(:font)
+        @explicitly_set ||= {}
+        @explicitly_set[:font] = true unless from_css
+        @default_font = font_id.to_i
+      end
+      alias_method :Font, :font
+      alias_method :set_font, :font
+      alias_method :font=, :font
+
+      # Prefijo de descripcion predeterminado para nuevas instancias
+      def desc_prefix(prefix_str = nil, from_css: false)
+        @default_desc_prefix ||= "[i]"
+        return @default_desc_prefix if prefix_str.nil?
+        return @default_desc_prefix if from_css && explicitly_set?(:desc_prefix)
+        @explicitly_set ||= {}
+        @explicitly_set[:desc_prefix] = true unless from_css
+        @default_desc_prefix = prefix_str.to_s
+      end
+      alias_method :description_prefix, :desc_prefix
+      alias_method :desc_prefix=, :desc_prefix
+      alias_method :description_prefix=, :desc_prefix
+    end
+  end
+
+  # Utilidad de impresion directa con retorno de carro para terminales crudas
+  module GRprint
+    module_function
+
+    def p(text = "", ending = "\r\n")
+      Kernel.print("#{text}#{ending}")
+    end
+  end
+end

data/grmenu/terminal.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+class GRmenu
+  # Secuencias de control ANSI para la terminal
+  CLEAR_SCREEN_SEQUENCE = "\e[H\e[2J\e[3J"
+  HIDE_CURSOR           = "\e[?25l"
+  SHOW_CURSOR           = "\e[?25h"
+  CURSOR_HOME           = "\e[H"
+  CLEAR_TO_EOL          = "\e[K"
+  CLEAR_TO_EOS          = "\e[J"
+
+  # Protocolo de raton ANSI:
+  # 1000h: Reporta clics del raton (MouseDown / MouseUp)
+  # 1002h: Reporta eventos de arrastre o movimiento con boton presionado
+  # 1006h: Formato extendido SGR (permite coordenadas mas alla de la columna 223)
+  ENABLE_MOUSE          = "\e[?1000h\e[?1002h\e[?1006h"
+  DISABLE_MOUSE         = "\e[?1006l\e[?1002l\e[?1000l"
+
+  # Habilita el modo de procesamiento virtual (VT) en la consola de Windows.
+  # En Windows clasico (cmd.exe antiguo), las secuencias ANSI no se interpretan por defecto;
+  # usamos Fiddle para interactuar directamente con kernel32 y activar los flags correspondientes.
+  def self.enable_windows_vt
+    return unless Gem.win_platform? || RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+    require 'fiddle'
+
+    kernel32 = Fiddle.dlopen('kernel32')
+    get_std_handle   = Fiddle::Function.new(kernel32['GetStdHandle'], [Fiddle::TYPE_INT], Fiddle::TYPE_VOIDP)
+    get_console_mode = Fiddle::Function.new(kernel32['GetConsoleMode'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
+    set_console_mode = Fiddle::Function.new(kernel32['SetConsoleMode'], [Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT], Fiddle::TYPE_INT)
+
+    # STD_OUTPUT_HANDLE = -11 -> Activa ENABLE_VIRTUAL_TERMINAL_PROCESSING (0x0004)
+    handle_out = get_std_handle.call(-11)
+    out_mode_buffer = ' ' * 4
+    if get_console_mode.call(handle_out, out_mode_buffer) != 0
+      current_mode = out_mode_buffer.unpack1('L')
+      set_console_mode.call(handle_out, current_mode | 0x0004)
+    end
+
+    # STD_INPUT_HANDLE = -10 -> Activa ENABLE_VIRTUAL_TERMINAL_INPUT (0x0200)
+    handle_in = get_std_handle.call(-10)
+    in_mode_buffer = ' ' * 4
+    if get_console_mode.call(handle_in, in_mode_buffer) != 0
+      current_mode = in_mode_buffer.unpack1('L')
+      set_console_mode.call(handle_in, current_mode | 0x0200)
+    end
+  rescue StandardError
+    # Si falla por permisos o entorno no estandar, dejamos que continue normalmente
+  end
+
+  # Devuelve el ancho visual de un unico caracter en terminal (0, 1 o 2 columnas).
+  # Toma en cuenta caracteres de ancho cero (selectores de variacion emoji, marcas diacriticas)
+  # y caracteres de doble ancho (ideogramas CJK, hangul y la mayoria de emojis modernos).
+  def self.char_width(char)
+    code = char.ord
+
+    # Caracteres nulos, selectores de variacion de emoji y diacriticos combinables (ancho 0)
+    return 0 if code == 0 || code == 0xFE0F || code == 0xFE0E || (code >= 0x0300 && code <= 0x036F) || (code >= 0x200B && code <= 0x200F)
+    return 0 if code < 32 || (code >= 0x7F && code < 0xA0)
+
+    # Simbolos especificos que en fuentes modernas ocupan 1 celda
+    return 1 if code == 0x1F5BC || code == 0x1F5B4 || code == 0x1F5B5 || code == 0x1F5C2
+
+    # Rangos CJK y emojis que ocupan 2 columnas en terminales compatibles con Unicode
+    if (code >= 0x1100 && code <= 0x115F) ||
+       (code >= 0x2329 && code <= 0x232A) ||
+       (code >= 0x2E80 && code <= 0xA4CF && code != 0x303F) ||
+       (code >= 0xAC00 && code <= 0xD7A3) ||
+       (code >= 0xF900 && code <= 0xFAFF) ||
+       (code >= 0xFE10 && code <= 0xFE19) ||
+       (code >= 0xFE30 && code <= 0xFE6F) ||
+       (code >= 0xFF01 && code <= 0xFF60) ||
+       (code >= 0xFFE0 && code <= 0xFFE6) ||
+       (code >= 0x1F300 && code <= 0x1F6FF) ||
+       (code >= 0x1F900 && code <= 0x1FAFF)
+      2
+    else
+      1
+    end
+  end
+
+  # Calcula el ancho visual de una cadena ignorando los codigos de escape ANSI.
+  def self.display_width(str)
+    # Limpiamos secuencias de escape ANSI tipo \e[...m antes de contar
+    clean = str.to_s.gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
+    clean.chars.map { |c| char_width(c) }.sum
+  end
+
+  # Ajusta el texto al ancho objetivo con espacios segun la alineacion deseada.
+  def self.pad_to_width(str, target_width, align = :left)
+    current_w = display_width(str)
+    pad_needed = [target_width - current_w, 0].max
+    case align
+    when :right
+      (" " * pad_needed) + str.to_s
+    when :center
+      left_pad  = " " * (pad_needed / 2)
+      right_pad = " " * (pad_needed - (pad_needed / 2))
+      left_pad + str.to_s + right_pad
+    else
+      str.to_s + (" " * pad_needed)
+    end
+  end
+
+  # Detecta el numero de columnas disponibles en la terminal actual.
+  def self.terminal_width
+    cols = $stdout.winsize[1] rescue nil
+    cols = $stdin.winsize[1] rescue nil if cols.nil? || cols <= 0
+    (cols && cols > 0) ? cols : (ENV['COLUMNS'] ? ENV['COLUMNS'].to_i : 80)
+  rescue StandardError
+    80
+  end
+
+  # Detecta el numero de filas disponibles en la terminal actual.
+  def self.terminal_height
+    rows = $stdout.winsize[0] rescue nil
+    rows = $stdin.winsize[0] rescue nil if rows.nil? || rows <= 0
+    (rows && rows > 0) ? rows : (ENV['LINES'] ? ENV['LINES'].to_i : 24)
+  rescue StandardError
+    24
+  end
+
+  # Limpia la pantalla completa de la terminal y posiciona el cursor al inicio.
+  def self.clear_screen
+    Kernel.print(CLEAR_SCREEN_SEQUENCE)
+  end
+
+  class << self
+    alias_method :clr, :clear_screen
+  end
+
+  # Lee una tecla o secuencia de escape de la terminal en modo crudo.
+  # Soporta teclas comunes, flechas, teclas de funcion, eventos de raton SGR y teclas extendidas de Windows.
+  def self.read_key_raw(input_stream)
+    is_tty = input_stream.respond_to?(:tty?) && input_stream.tty?
+    first_char = nil
+    begin
+      first_char = is_tty ? input_stream.getch : input_stream.read(1)
+    rescue EOFError, Errno::EPIPE
+      return nil
+    end
+    return nil if first_char.nil?
+
+    if first_char == "\e"
+      seq = first_char.dup
+      # Acumula caracteres adicionales si forman parte de una secuencia de escape
+      if is_tty
+        while (ch = (input_stream.getch(min: 0, time: 0.1) rescue nil))
+          seq << ch
+          break if seq =~ /[a-zA-Z~]\z/
+        end
+      else
+        while (IO.select([input_stream], nil, nil, 0.05) rescue nil)
+          ch = (input_stream.read(1) rescue nil)
+          break if ch.nil?
+          seq << ch
+          break if seq =~ /[a-zA-Z~]\z/
+        end
+      end
+
+      # Si es el protocolo clasico X10 (\e[M + 3 bytes), lo convertimos al estandar SGR 1006
+      if seq == "\e[M"
+        cb = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        cx = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        cy = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+        if cb && cx && cy
+          btn_c = cb.ord - 32
+          col_c = cx.ord - 32
+          row_c = cy.ord - 32
+          return "\e[<#{btn_c};#{col_c};#{row_c}M"
+        end
+      end
+
+      return seq
+    elsif first_char == "\x00" || first_char == "\xe0"
+      # Teclas de dos bytes en consolas Windows clásicas
+      second_char = is_tty ? (input_stream.getch(min: 0, time: 0.1) rescue nil) : (input_stream.read(1) rescue nil)
+      return first_char + second_char if second_char
+    end
+
+    first_char
+  rescue EOFError, Errno::EPIPE, Errno::ENOTTY
+    nil
+  end
+
+  # Delegador de instancia para lectura de una sola tecla
+  def read_single_key(input_stream)
+    self.class.read_key_raw(input_stream)
+  end
+end