grmenu 0.1.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f46b9abdef35e533292871a7a45455814d6d5ad1251e344f18f0cf76361b02f
-  data.tar.gz: 562005a4a30a236ff2dfa139deb44ad7402838d31623acfc9a5862f1fbf322c8
+  metadata.gz: 9321761865c19b47e92b7fb2ed1808a23184d65a65cfef033b6f2129537512f9
+  data.tar.gz: f6ff6e9057c2dee31a7af652b74b9dd88eac8b8b13b05638956516ecafdfb2af
 SHA512:
-  metadata.gz: a597007a74ea9bb27e1f290c0ba01e0ba081783f8caa9656b1a084511ce5bc3aebc890e0d410e5a2afe78a751e550638064648a5022e6678d4bc51ff10ea0ab9
-  data.tar.gz: 27337525d19288c49cd5c2061768338d07352c4e228525d9c696164b85039c1a527373e6c848ce5be3c103ee84e7e2768f89970cf9ec4e61bfdc35d409cdb879
+  metadata.gz: 27cbe736aba023bf6f5cda2063c5dae971127a485b0b441d6600aa211f2d6734a04917d638e9795bb4106e8a52acdf1f9a3f0f1eebea155949e1999f4ad06b2d
+  data.tar.gz: 86c3b3d6de6c6fff5dc4959743c87089173701d52edaaf6613de8381574c954c02ae6a8caab517d24a19f8e78e1882ba35189020b67cd32dca96eefa933ede60

data/GRmenu.rb

@@ -39,55 +39,55 @@ class GRmenu
       "#{code}#{text}#{RESET}"
     end
 
-    def red(s)            = paint(s, :red, 1)
-    def bright_red(s)     = paint(s, :red, 2)
-    def dark_red(s)       = paint(s, :red, 1)
+    def red(s);            paint(s, :red, 1);     end
+    def bright_red(s);     paint(s, :red, 2);     end
+    def dark_red(s);       paint(s, :red, 1);     end
 
-    def green(s)          = paint(s, :green, 1)
-    def bright_green(s)   = paint(s, :green, 2)
-    def dark_green(s)     = paint(s, :green, 1)
+    def green(s);          paint(s, :green, 1);   end
+    def bright_green(s);   paint(s, :green, 2);   end
+    def dark_green(s);     paint(s, :green, 1);   end
 
-    def yellow(s)         = paint(s, :yellow, 1)
-    def bright_yellow(s)  = paint(s, :yellow, 2)
+    def yellow(s);         paint(s, :yellow, 1);  end
+    def bright_yellow(s);  paint(s, :yellow, 2);  end
 
-    def blue(s)           = paint(s, :blue, 1)
-    def bright_blue(s)    = paint(s, :blue, 2)
+    def blue(s);           paint(s, :blue, 1);    end
+    def bright_blue(s);    paint(s, :blue, 2);    end
 
-    def magenta(s)        = paint(s, :magenta, 1)
-    def bright_magenta(s) = paint(s, :magenta, 2)
+    def magenta(s);        paint(s, :magenta, 1); end
+    def bright_magenta(s); paint(s, :magenta, 2); end
 
-    def purple(s)         = paint(s, :purple, 1)
-    def bright_purple(s)  = paint(s, :purple, 2)
+    def purple(s);         paint(s, :purple, 1);  end
+    def bright_purple(s);  paint(s, :purple, 2);  end
 
-    def pink(s)           = paint(s, :pink, 1)
-    def bright_pink(s)    = paint(s, :pink, 2)
+    def pink(s);           paint(s, :pink, 1);    end
+    def bright_pink(s);    paint(s, :pink, 2);    end
 
-    def cyan(s)           = paint(s, :cyan, 1)
-    def bright_cyan(s)    = paint(s, :cyan, 2)
+    def cyan(s);           paint(s, :cyan, 1);    end
+    def bright_cyan(s);    paint(s, :cyan, 2);    end
 
-    def aqua(s)           = paint(s, :aqua, 1)
-    def bright_aqua(s)    = paint(s, :aqua, 2)
+    def aqua(s);           paint(s, :aqua, 1);    end
+    def bright_aqua(s);    paint(s, :aqua, 2);    end
 
-    def orange(s)         = paint(s, :orange, 1)
-    def bright_orange(s)  = paint(s, :orange, 2)
+    def orange(s);         paint(s, :orange, 1);  end
+    def bright_orange(s);  paint(s, :orange, 2);  end
 
-    def white(s)          = paint(s, :white, 1)
-    def bright_white(s)   = paint(s, :white, 2)
+    def white(s);          paint(s, :white, 1);   end
+    def bright_white(s);   paint(s, :white, 2);   end
 
-    def black(s)          = paint(s, :black, 1)
-    def gray(s)           = paint(s, :gray, 1)
-    def bright_gray(s)    = paint(s, :gray, 2)
-    def grey(s)           = gray(s)
+    def black(s);          paint(s, :black, 1);   end
+    def gray(s);           paint(s, :gray, 1);    end
+    def bright_gray(s);    paint(s, :gray, 2);    end
+    def grey(s);           gray(s);               end
 
-    def r(s)  = bright_red(s)
-    def dr(s) = dark_red(s)
-    def g(s)  = bright_green(s)
-    def y(s)  = bright_yellow(s)
-    def w(s)  = bright_white(s)
-    def gr(s) = gray(s)
-    def cy(s) = bright_cyan(s)
-    def mg(s) = bright_magenta(s)
-    def bl(s) = bright_blue(s)
+    def r(s);  bright_red(s);     end
+    def dr(s); dark_red(s);       end
+    def g(s);  bright_green(s);   end
+    def y(s);  bright_yellow(s);  end
+    def w(s);  bright_white(s);   end
+    def gr(s); gray(s);           end
+    def cy(s); bright_cyan(s);    end
+    def mg(s); bright_magenta(s); end
+    def bl(s); bright_blue(s);    end
   end
   C = Color
 
@@ -162,6 +162,148 @@ class GRmenu
   FONTS.each { |id, data| const_set("FONT_#{id}", data) }
   FONT = FONTS[1] || {}.freeze
 
+  class ProgressBar
+    attr_reader :total, :current, :title, :status
+
+    def initialize(total = 100, title: nil, color: "cyan", level: 2, style: 3, width: nil)
+      @total   = [total.to_i, 1].max
+      @current = 0
+      @title   = title
+      @status  = ""
+      @color   = color.to_s.downcase
+      @level   = level.to_i
+      @style   = style.to_i
+      @width   = width
+      @closed  = false
+      @drawn_lines_count = 0
+    end
+
+    def advance(step = 1, status: nil)
+      return if @closed
+      @current = [(@current + step), @total].min
+      @status = status.to_s if status
+      render
+    end
+    alias_method :increment, :advance
+    alias_method :step, :advance
+
+    def set(value, status: nil)
+      return if @closed
+      @current = [[value.to_i, 0].max, @total].min
+      @status = status.to_s if status
+      render
+    end
+
+    def render
+      term_w = GRmenu.terminal_width
+      box_w = @width || [term_w - 4, 60].min
+      box_w = [box_w, 36].max
+
+      color_code = GRmenu::COLORS.dig(@color, @level) || "\e[1;96m"
+      reset_code = GRmenu::COLORS["reset"]
+      border_cfg = GRmenu::BORDERS[@style] || GRmenu::BORDERS[3]
+
+      v_l = border_cfg[:vl] || border_cfg[:v]
+      v_r = border_cfg[:vr] || border_cfg[:v]
+      h_t = border_cfg[:ht] || border_cfg[:h]
+      h_b = border_cfg[:hb] || border_cfg[:h]
+
+      top_fill = (h_t * ((box_w - 2).to_f / h_t.length).ceil)[0...(box_w - 2)]
+      bot_fill = (h_b * ((box_w - 2).to_f / h_b.length).ceil)[0...(box_w - 2)]
+
+      pct = ((@current.to_f / @total) * 100).round
+      pct_str = "#{pct}% (#{@current}/#{@total})"
+
+      inner_w = box_w - 4
+      bar_w = [inner_w - pct_str.length - 3, 10].max
+      filled_len = ((@current.to_f / @total) * bar_w).round
+      empty_len  = bar_w - filled_len
+
+      bar_str = "[#{"█" * filled_len}#{"░" * empty_len}] #{pct_str}"
+      bar_line = bar_str.ljust(inner_w)[0...inner_w]
+
+      lines = []
+      lines << "#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}"
+      if @title && !@title.empty?
+        lines << "#{color_code}#{v_l}#{reset_code} #{@title.center(inner_w)} #{color_code}#{v_r}#{reset_code}"
+        lines << "#{color_code}#{v_l}#{top_fill}#{v_r}#{reset_code}"
+      end
+      lines << "#{color_code}#{v_l}#{reset_code} #{color_code}#{bar_line}#{reset_code} #{color_code}#{v_r}#{reset_code}"
+      if @status && !@status.empty?
+        stat_line = @status.ljust(inner_w)[0...inner_w]
+        lines << "#{color_code}#{v_l}#{reset_code} #{Color.gray(stat_line)} #{color_code}#{v_r}#{reset_code}"
+      end
+      lines << "#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}"
+
+      frame = lines.join("\r\n") + "\r\n"
+
+      if @drawn_lines_count && @drawn_lines_count > 0
+        Kernel.print("\e[#{@drawn_lines_count}A\e[J")
+      end
+      Kernel.print(frame)
+      $stdout.flush
+      @drawn_lines_count = lines.length
+    end
+
+    def finish(status: "¡Completado!")
+      return if @closed
+      set(@total, status: status)
+      @closed = true
+      Kernel.print(GRmenu::SHOW_CURSOR)
+    end
+  end
+
+  def self.spinner(message = "Cargando...", color: "cyan", level: 2, delay: 0.08, &block)
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    color_name = color.to_s.downcase
+    color_code = COLORS.dig(color_name, level) || "\e[1;96m"
+    reset_code = COLORS["reset"]
+
+    stop_spinner = false
+    spinner_thread = Thread.new do
+      frame_idx = 0
+      while !stop_spinner
+        f = frames[frame_idx % frames.length]
+        Kernel.print("\r\e[K#{color_code}#{f}#{reset_code} #{message}")
+        $stdout.flush
+        frame_idx += 1
+        sleep(delay)
+      end
+    end
+
+    begin
+      Kernel.print(HIDE_CURSOR)
+      result = block ? block.call : nil
+      stop_spinner = true
+      spinner_thread.join
+      success_color = COLORS.dig("green", 2) || "\e[1;92m"
+      Kernel.print("\r\e[K#{success_color}✔#{reset_code} #{message} #{Color.gray("¡Listo!")}\r\n")
+      result
+    rescue Exception => e
+      stop_spinner = true
+      spinner_thread.join rescue nil
+      error_color = COLORS.dig("red", 2) || "\e[1;91m"
+      Kernel.print("\r\e[K#{error_color}✖#{reset_code} #{message} #{Color.bright_red("(Error: #{e.message})")}\r\n")
+      raise e
+    ensure
+      stop_spinner = true
+      Kernel.print(SHOW_CURSOR)
+    end
+  end
+
+  def self.progress(total = 100, title: nil, color: "cyan", level: 2, style: 3, width: nil, &block)
+    bar = ProgressBar.new(total, title: title, color: color, level: level, style: style, width: width)
+    Kernel.print(HIDE_CURSOR)
+    bar.render
+    begin
+      result = block ? block.call(bar) : bar
+      bar.finish
+      result
+    ensure
+      Kernel.print(SHOW_CURSOR)
+    end
+  end
+
   class SetStyle
     def initialize(
       border:   { color: "cyan",    level: 1 },
@@ -333,7 +475,7 @@ class GRmenu
     end
   end
 
-  attr_accessor :functions, :title, :subtitle, :banner, :banner_style, :divider, :style, :index, :style_config, :center
+  attr_accessor :functions, :title, :subtitle, :banner, :banner_style, :divider, :style, :index, :style_config, :center, :page_size
 
   alias_method :options, :functions
   alias_method :options=, :functions=
@@ -344,11 +486,11 @@ class GRmenu
   alias_method :description, :subtitle
   alias_method :description=, :subtitle=
 
-  def self.STYLES = STYLES
-  def self.COLORS = COLORS
-  def self.BORDERS = BORDERS
-  def self.FONTS = FONTS
-  def self.FONT = FONT_1
+  def self.STYLES; STYLES; end
+  def self.COLORS; COLORS; end
+  def self.BORDERS; BORDERS; end
+  def self.FONTS; FONTS; end
+  def self.FONT; FONT_1; end
 
   def self.terminal_width
     cols = $stdout.winsize[1] rescue nil
@@ -358,6 +500,14 @@ class GRmenu
     80
   end
 
+  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
+
   def self.clear_screen
     Kernel.print(CLEAR_SCREEN_SEQUENCE)
   end
@@ -371,20 +521,20 @@ class GRmenu
     Kernel.print("#{color_code}#{char * width}#{COLORS['reset']}\r\n")
   end
 
-  def self.help
-    w = [terminal_width - 4, 64].min
-    w = [w, 42].max
+  def self.help(section = :all)
+    w = [terminal_width - 4, 70].min
+    w = [w, 46].max
     inner_w = w - 2
     h_line = "═" * inner_w
     s_line = "─" * w
 
     Kernel.print "\r\n"
     Kernel.print "#{Color.bright_cyan("╔" + h_line + "╗")}\r\n"
-    Kernel.print "#{Color.bright_cyan("║")}#{Color.bright_yellow("GRmenu - Guia y Referencia Rapida".center(inner_w))}#{Color.bright_cyan("║")}\r\n"
-    Kernel.print "#{Color.bright_cyan("║")}#{Color.gray("Navegacion interactiva en terminal TTY".center(inner_w))}#{Color.bright_cyan("║")}\r\n"
+    Kernel.print "#{Color.bright_cyan("║")}#{Color.bright_yellow("GRmenu - Guia y Referencia Completa (v2.0)".center(inner_w))}#{Color.bright_cyan("║")}\r\n"
+    Kernel.print "#{Color.bright_cyan("║")}#{Color.gray("Menus interactivos, Banners 3D, Barras de Progreso y TTY".center(inner_w))}#{Color.bright_cyan("║")}\r\n"
     Kernel.print "#{Color.bright_cyan("╚" + h_line + "╝")}\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[1] HELPERS NATIVOS EN MODO CRUDO")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[1] HELPERS NATIVOS")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.bright_green("GRmenu.clear_screen")} #{Color.gray("(o GRmenu.clr)")}\r\n"
     Kernel.print "    * Limpia la terminal al instante con secuencias ANSI.\r\n"
@@ -392,18 +542,55 @@ class GRmenu
     Kernel.print "    * Pausa interactiva: espera una sola tecla en modo TTY crudo.\r\n"
     Kernel.print "  #{Color.bright_green("GRmenu.banner(texto, delay, color:, level:, style:, font:)")}\r\n"
     Kernel.print "    * Renderiza banner ASCII 3D con marco y animacion opcional.\r\n"
+    Kernel.print "  #{Color.bright_green("GRmenu.spinner(mensaje, color:, level:, delay:, &bloque)")}\r\n"
+    Kernel.print "    * Animacion giratoria fluida para tareas de tiempo desconocido.\r\n"
+    Kernel.print "    * Ejemplo: #{Color.bright_white("GRmenu.spinner(\"Conectando...\") { conectar_db }")}\r\n"
+    Kernel.print "  #{Color.bright_green("GRmenu.progress(total, title:, color:, level:, style:, width:, &bloque)")}\r\n"
+    Kernel.print "    * Barra de progreso porcentual dentro de un recuadro estilizado.\r\n"
+    Kernel.print "    * El bloque recibe 'bar'. Metodos disponibles:\r\n"
+    Kernel.print "        - #{Color.cyan("bar.advance(n, status: \"...\")")} -> Avanza n pasos (alias: increment, step).\r\n"
+    Kernel.print "        - #{Color.cyan("bar.set(valor, status: \"...\")")}  -> Fija el valor exacto actual.\r\n"
+    Kernel.print "        - #{Color.cyan("bar.finish(status: \"...\")")}   -> Finaliza la barra al 100%.\r\n"
+    Kernel.print "    * Ejemplo: #{Color.bright_white("GRmenu.progress(10, title: \"Copia\") { |b| 10.times { b.advance(1) } }")}\r\n"
     Kernel.print "  #{Color.bright_green("GRmenu.div(longitud, color, level, char)")}\r\n"
-    Kernel.print "    * Dibuja linea divisoria horizontal adaptable a la consola.\r\n"
-    Kernel.print "  #{Color.bright_green("GRmenu.help")}\r\n"
-    Kernel.print "    * Imprime esta guia visual interactiva en consola.\r\n\r\n"
+    Kernel.print "    * Dibuja linea divisoria horizontal adaptable a la consola.\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[2] MODULO DE COLORES (Color / C)")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[2] FORMATOS DE OPCIONES Y TOOLTIPS DINAMICOS")}\r\n"
+    Kernel.print "#{Color.bright_blue(s_line)}\r\n"
+    Kernel.print "  #{Color.cyan("1. Metodo directo:")}     #{Color.bright_white("method(:iniciar)")} #{Color.gray("(auto-capitaliza nombre)")}\r\n"
+    Kernel.print "  #{Color.cyan("2. Simbolo:")}            #{Color.bright_white(":iniciar")}\r\n"
+    Kernel.print "  #{Color.cyan("3. Nombre propio:")}      #{Color.bright_white("[\"Mi Accion\", method(:iniciar)]")}\r\n"
+    Kernel.print "  #{Color.cyan("4. Con Tooltip/Info:")}   #{Color.bright_white("[\"Mi Accion\", method(:iniciar), \"Descripcion que sale abajo\"]")}\r\n"
+    Kernel.print "  #{Color.cyan("5. Lambda / Proc:")}      #{Color.bright_white("[\"Test\", -> { puts \"Hola\" }, \"Tooltip opcional\"]")}\r\n"
+    Kernel.print "  #{Color.cyan("6. Hash:")}               #{Color.bright_white("{ name: \"Test\", action: method(:iniciar), desc: \"Info\" }")}\r\n\r\n"
+
+    Kernel.print "#{Color.bright_magenta("[3] PARAMETROS DE GRmenu.new(functions, ...)")}\r\n"
+    Kernel.print "#{Color.bright_blue(s_line)}\r\n"
+    Kernel.print "  #{Color.bright_green("functions:")}    #{Color.white("Array")}   -> Lista de opciones (metodos, simbolos, arreglos, lambdas).\r\n"
+    Kernel.print "  #{Color.bright_green("banner:")}       #{Color.white("String")}  -> Texto grande a renderizar en arte ASCII 3D.\r\n"
+    Kernel.print "  #{Color.bright_green("title:")}        #{Color.white("String")}  -> Titulo en el encabezado del recuadro.\r\n"
+    Kernel.print "  #{Color.bright_green("subtitle:")}     #{Color.white("String")}  -> Subtitulo / descripcion (soporta \\n).\r\n"
+    Kernel.print "  #{Color.bright_green("page_size:")}    #{Color.white("Integer")} -> Limite visible para scroll y paginacion automatica.\r\n"
+    Kernel.print "  #{Color.bright_green("font:")}         #{Color.white("Integer")} -> Fuente ASCII del banner (1 al 10, default 1).\r\n"
+    Kernel.print "  #{Color.bright_green("style:")}        #{Color.white("Integer")} -> Estilo de marco de opciones (1 al 20, default 19).\r\n"
+    Kernel.print "  #{Color.bright_green("banner_style:")} #{Color.white("Integer")} -> Estilo de marco del banner (1 al 20, default 3).\r\n"
+    Kernel.print "  #{Color.bright_green("divider:")}      #{Color.white("Boolean")} -> Divisores alineados al banner (true/false).\r\n"
+    Kernel.print "  #{Color.bright_green("center:")}       #{Color.white("Boolean")} -> Centrado simetrico de subtitulo y menu (default true).\r\n\r\n"
+
+    Kernel.print "#{Color.bright_magenta("[4] AUTO-PAGINACION Y SCROLL")}\r\n"
+    Kernel.print "#{Color.bright_blue(s_line)}\r\n"
+    Kernel.print "  * #{Color.white("100% Automatica:")} Si la lista tiene muchas opciones o la pantalla es pequena,\r\n"
+    Kernel.print "    GRmenu calcula el espacio disponible y genera una ventana deslizante suave.\r\n"
+    Kernel.print "  * Indicadores visuales: #{Color.bright_yellow("▲ (+N arriba)")} y #{Color.bright_yellow("▼ (+M abajo)")}.\r\n"
+    Kernel.print "  * Opcional: fija el limite con #{Color.bright_white("page_size: 8")} al instanciar #{Color.bright_green("GRmenu.new")}.\r\n\r\n"
+
+    Kernel.print "#{Color.bright_magenta("[5] MODULO DE COLORES (Color / C)")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.cyan("Uso directo: ")}#{Color.bright_white("puts Color.green(\"Texto\")")} | #{Color.bright_white("puts Color.bright_cyan(\"Texto\")")}\r\n"
     Kernel.print "  #{Color.cyan("Paleta: ")}#{Color.red("red")}, #{Color.green("green")}, #{Color.yellow("yellow")}, #{Color.blue("blue")}, #{Color.magenta("magenta")}, #{Color.purple("purple")}, #{Color.pink("pink")}, #{Color.cyan("cyan")}, #{Color.aqua("aqua")}, #{Color.orange("orange")}, #{Color.white("white")}, #{Color.gray("gray")}, #{Color.black("black")}.\r\n"
     Kernel.print "  #{Color.cyan("Brillo: ")}#{Color.white("1")} = Normal, #{Color.bright_white("2")} = Brillante / Bold.\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[3] FUENTES ASCII 3D DEL BANNER (font: 1 al 10)")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[6] FUENTES ASCII 3D DEL BANNER (font: 1 al 10)")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.yellow("1")} -> #{Color.bright_white("ANSI Shadow 3D (Default)")}  #{Color.cyan("[██████╗  ██╗  ██╗]")}\r\n"
     Kernel.print "  #{Color.yellow("2")} -> #{Color.bright_white("Slant 3D (FIGlet)")}          #{Color.cyan("[    ____        __  __]")}\r\n"
@@ -416,28 +603,17 @@ class GRmenu
     Kernel.print "  #{Color.yellow("9")} -> #{Color.bright_white("Solid Fat 3D Block")}       #{Color.cyan("[  ██████▄  ██   ██]")}\r\n"
     Kernel.print "  #{Color.yellow("10")}-> #{Color.bright_white("Arcade Stars Matrix")}       #{Color.cyan("[  ★★★★   ★   ★]")}\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[4] ESTILOS DE MARCO (style / banner_style: 1 al 20)")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[7] ESTILOS DE MARCO (style / banner_style: 1 al 20)")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.yellow("3")}  -> #{Color.bright_white("Doble linea")}        #{Color.cyan("╔═══╗ ║   ║ ╚═══╝")} (Default en Banner)\r\n"
     Kernel.print "  #{Color.yellow("7")}  -> #{Color.bright_white("Curvas redondeadas")} #{Color.cyan("╭───╮ │   │ ╰───╯")}\r\n"
     Kernel.print "  #{Color.yellow("4")}  -> #{Color.bright_white("Linea gruesa")}       #{Color.cyan("┏━━━┓ ┃   ┃ ┗━━━┛")}\r\n"
     Kernel.print "  #{Color.yellow("2")}  -> #{Color.bright_white("Linea simple")}       #{Color.cyan("┌───┐ │   │ └───┘")}\r\n"
-    Kernel.print "  #{Color.yellow("8")}  -> #{Color.bright_white("Bloques outline")}    #{Color.cyan("▛▀▀▀▜ ▌   ▌ ▙▄▄▄▟")}\r\n"
+    Kernel.print "  #{Color.yellow("8")}  -> #{Color.bright_white("Bloques outline")}    #{Color.cyan("▛▀▀▀▜ ▌   ▐ ▙▄▄▄▟")}\r\n"
     Kernel.print "  #{Color.yellow("19")} -> #{Color.bright_white("Circulos")}           #{Color.cyan("●○○○● ●   ● ●○○○●")} (Default en Opciones)\r\n"
     Kernel.print "  #{Color.yellow("20")} -> #{Color.bright_white("Estrellas")}          #{Color.cyan("★☆☆☆★ ★   ★ ★☆☆☆★")}\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[5] PARAMETROS DE GRmenu.new(functions, ...)")}\r\n"
-    Kernel.print "#{Color.bright_blue(s_line)}\r\n"
-    Kernel.print "  #{Color.bright_green("banner:")}       #{Color.white("String")}  -> Texto grande a renderizar en arte ASCII 3D.\r\n"
-    Kernel.print "  #{Color.bright_green("title:")}        #{Color.white("String")}  -> Titulo en el encabezado del recuadro.\r\n"
-    Kernel.print "  #{Color.bright_green("subtitle:")}     #{Color.white("String")}  -> Subtitulo / descripcion (soporta \\n).\r\n"
-    Kernel.print "  #{Color.bright_green("font:")}         #{Color.white("Integer")} -> Fuente ASCII del banner (1 al 10, default 1).\r\n"
-    Kernel.print "  #{Color.bright_green("style:")}        #{Color.white("Integer")} -> Estilo de marco de opciones (1 al 20, default 19).\r\n"
-    Kernel.print "  #{Color.bright_green("banner_style:")} #{Color.white("Integer")} -> Estilo de marco del banner (1 al 20, default 3).\r\n"
-    Kernel.print "  #{Color.bright_green("divider:")}      #{Color.white("Boolean")} -> Divisores alineados al banner (true/false).\r\n"
-    Kernel.print "  #{Color.bright_green("center:")}       #{Color.white("Boolean")} -> Centrado simetrico de subtitulo y menu (default true).\r\n\r\n"
-
-    Kernel.print "#{Color.bright_magenta("[6] METODOS DE CONFIGURACION (menu.set_style)")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[8] METODOS DE CONFIGURACION (menu.set_style)")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.cyan("menu.set_style.font(id)")}                 -> Cambia fuente ASCII (1..10)\r\n"
     Kernel.print "  #{Color.cyan("menu.set_style.banner(color, level)")}     -> Color y brillo del banner ASCII\r\n"
@@ -448,7 +624,7 @@ class GRmenu
     Kernel.print "  #{Color.cyan("menu.set_style.options(color, level)")}    -> Color y brillo de opciones no activas\r\n"
     Kernel.print "  #{Color.cyan("menu.set_style.focus(color, level)")}      -> Color y brillo de la opcion resaltada\r\n\r\n"
 
-    Kernel.print "#{Color.bright_magenta("[7] EJECUCION (menu.draw)")}\r\n"
+    Kernel.print "#{Color.bright_magenta("[9] EJECUCION (menu.draw)")}\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n"
     Kernel.print "  #{Color.bright_white("menu.draw(size_max: 38)")} -> Inicia el menu interactivo con ancho minimo.\r\n"
     Kernel.print "#{Color.bright_blue(s_line)}\r\n\r\n"
@@ -499,25 +675,32 @@ class GRmenu
 
     ascii_rows = build_ascii_lines(text, cols, font)
     border_cfg = BORDERS[style] || BORDERS[3]
+    h_top = border_cfg[:ht] || border_cfg[:h]
+    h_bot = border_cfg[:hb] || border_cfg[:h]
+    v_l = border_cfg[:vl] || border_cfg[:v]
+    v_r = border_cfg[:vr] || border_cfg[:v]
 
     if ascii_rows
       max_len = ascii_rows.map(&:length).max
-      h_fill = (border_cfg[:h] * ((max_len + 4).to_f / border_cfg[:h].length).ceil)[0...(max_len + 4)]
-      
-      Kernel.print("#{color_code}#{border_cfg[:tl]}#{h_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
+      top_fill = (h_top * ((max_len + 4).to_f / h_top.length).ceil)[0...(max_len + 4)]
+      bot_fill = (h_bot * ((max_len + 4).to_f / h_bot.length).ceil)[0...(max_len + 4)]
+
+      Kernel.print("#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
       ascii_rows.each do |line|
         pad = " " * (max_len - line.length)
-        Kernel.print("#{color_code}#{border_cfg[:v]}  #{line}#{pad}  #{border_cfg[:v]}#{reset_code}\r\n")
+        Kernel.print("#{color_code}#{v_l}  #{line}#{pad}  #{v_r}#{reset_code}\r\n")
         sleep(delay) if delay > 0
       end
-      Kernel.print("#{color_code}#{border_cfg[:bl]}#{h_fill}#{border_cfg[:br]}#{reset_code}\r\n")
+      Kernel.print("#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}\r\n")
     else
       clean_t = text.to_s.strip
       box_w = [clean_t.length + 6, cols - 2].min
-      h_fill = (border_cfg[:h] * ((box_w - 2).to_f / border_cfg[:h].length).ceil)[0...(box_w - 2)]
-      Kernel.print("#{color_code}#{border_cfg[:tl]}#{h_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
-      Kernel.print("#{color_code}#{border_cfg[:v]} #{clean_t.center(box_w - 4)} #{border_cfg[:v]}#{reset_code}\r\n")
-      Kernel.print("#{color_code}#{border_cfg[:bl]}#{h_fill}#{border_cfg[:br]}#{reset_code}\r\n")
+      top_fill = (h_top * ((box_w - 2).to_f / h_top.length).ceil)[0...(box_w - 2)]
+      bot_fill = (h_bot * ((box_w - 2).to_f / h_b.length).ceil)[0...(box_w - 2)]
+
+      Kernel.print("#{color_code}#{border_cfg[:tl]}#{top_fill}#{border_cfg[:tr]}#{reset_code}\r\n")
+      Kernel.print("#{color_code}#{v_l} #{clean_t.center(box_w - 4)} #{v_r}#{reset_code}\r\n")
+      Kernel.print("#{color_code}#{border_cfg[:bl]}#{bot_fill}#{border_cfg[:br]}#{reset_code}\r\n")
     end
   end
 
@@ -526,7 +709,7 @@ class GRmenu
     alias_method :logo, :banner
   end
 
-  def initialize(functions, *positional_arguments, title: nil, banner: nil, subtitle: nil, description: nil, divider: nil, style: nil, banner_style: nil, center: true, font: nil, **keyword_arguments)
+  def initialize(functions, *positional_arguments, title: nil, banner: nil, subtitle: nil, description: nil, divider: nil, style: nil, banner_style: nil, center: true, font: nil, page_size: nil, **keyword_arguments)
     @functions = functions.is_a?(Array) ? functions : Array(functions)
 
     pos_title = positional_arguments[0]
@@ -539,8 +722,8 @@ class GRmenu
     @style        = (style || pos_style || keyword_arguments[:style] || 19).to_i
     @banner_style = (banner_style || keyword_arguments[:banner_style] || 3).to_i
     @center       = center.nil? ? true : center
+    @page_size    = (page_size || keyword_arguments[:page_size])&.to_i
     @index        = 0
-    @clear_seq    = CLEAR_SCREEN_SEQUENCE
 
     init_font = font || keyword_arguments[:font_style] || SetStyle.font || 1
 
@@ -598,13 +781,13 @@ class GRmenu
     banner_border = BORDERS[@banner_style] || BORDERS[3]
     banner_color_cfg = @style_config.banner
 
-    lines = []
-    box_w = 0
     h_top = banner_border[:ht] || banner_border[:h]
     h_bot = banner_border[:hb] || banner_border[:h]
     v_l = banner_border[:vl] || banner_border[:v]
     v_r = banner_border[:vr] || banner_border[:v]
 
+    lines = []
+    box_w = 0
     if ascii_rows
       content_w = ascii_rows.map(&:length).max
       box_w = content_w + 6
@@ -632,40 +815,53 @@ class GRmenu
 
   def render_lines(size_max = 20)
     term_cols = self.class.terminal_width
+    term_rows = self.class.terminal_height
     rendered_lines = []
 
     banner_box_width = 0
+    banner_lines_count = 0
     if @banner && !@banner.empty?
       banner_lines, banner_box_width = render_banner_lines(term_cols)
       rendered_lines.concat(banner_lines)
       rendered_lines << ""
+      banner_lines_count = banner_lines.length + 1
     end
 
-    option_names = @functions.map { |func| extract_name_from_action(func) }
+    all_names = @functions.map { |func| extract_name_from_action(func) }
+    all_descriptions = @functions.map { |func| extract_description_from_action(func) }
+
+    active_desc = all_descriptions[@index] || ""
+
     calculated_width = [size_max, @title.length + 4].max
-    calculated_width = ([calculated_width] + option_names.map { |name| name.length + 6 }).max
+    calculated_width = ([calculated_width] + all_names.map { |name| name.length + 6 }).max
+    calculated_width = ([calculated_width, active_desc.length + 8].max) unless active_desc.empty?
     total_width = [calculated_width, term_cols - 2].min
 
     reference_width = banner_box_width > 0 ? banner_box_width : total_width
     margin_left = (@center && reference_width > total_width) ? " " * ((reference_width - total_width) / 2) : ""
 
+    subtitle_lines_count = 0
     if @subtitle && !@subtitle.empty?
       subtitle_lines = @subtitle.lines.map(&:chomp)
       div_w = @divider.is_a?(Numeric) ? @divider.to_i : [reference_width, term_cols - 2].min
 
       if @divider
         rendered_lines << colorize("─" * div_w, @style_config.divider)
+        subtitle_lines_count += 1
       end
 
       subtitle_lines.each do |sub_line|
         formatted_sub = @center ? sub_line.center(div_w) : sub_line
         rendered_lines << colorize(formatted_sub, @style_config.subtitle)
+        subtitle_lines_count += 1
       end
 
       if @divider
         rendered_lines << colorize("─" * div_w, @style_config.divider)
+        subtitle_lines_count += 1
       end
       rendered_lines << ""
+      subtitle_lines_count += 1
     end
 
     border_color_cfg  = @style_config.border
@@ -675,6 +871,33 @@ class GRmenu
 
     box_border = BORDERS[@style]
 
+    total_items = @functions.length
+    overhead = banner_lines_count + subtitle_lines_count + 6
+    overhead += 2 unless active_desc.empty?
+    available_rows = [term_rows - overhead - 2, 3].max
+
+    effective_page_size = if @page_size && @page_size > 0
+                            [@page_size, total_items].min
+                          elsif total_items > available_rows
+                            available_rows
+                          else
+                            total_items
+                          end
+
+    start_idx = 0
+    end_idx = total_items - 1
+    if total_items > effective_page_size
+      half = effective_page_size / 2
+      start_idx = [[@index - half, 0].max, total_items - effective_page_size].min
+      end_idx = start_idx + effective_page_size - 1
+    end
+
+    visible_indices = (start_idx..end_idx).to_a
+    has_more_above = start_idx > 0
+    has_more_below = end_idx < (total_items - 1)
+
+    avail_w = [total_width - 6, 1].max
+
     if box_border
       h_top = box_border[:ht] || box_border[:h]
       h_bot = box_border[:hb] || box_border[:h]
@@ -699,8 +922,13 @@ class GRmenu
         rendered_lines << "#{margin_left}#{colorize(separator_line, border_color_cfg)}"
       end
 
-      option_names.each_with_index do |option_name, current_index|
-        avail_w = [total_width - 6, 1].max
+      if has_more_above
+        up_indicator = colorize("▲ (+#{start_idx} arriba)".center(avail_w + 2), { color: "gray", level: 2 })
+        rendered_lines << "#{margin_left}#{v_left} #{up_indicator} #{v_right}"
+      end
+
+      visible_indices.each do |current_index|
+        option_name = all_names[current_index]
         if @index == current_index
           highlighted_text = colorize("> #{option_name.ljust(avail_w)}", focus_color_cfg)
           rendered_lines << "#{margin_left}#{v_left} #{highlighted_text} #{v_right}"
@@ -710,6 +938,19 @@ class GRmenu
         end
       end
 
+      if has_more_below
+        remaining_below = total_items - 1 - end_idx
+        down_indicator = colorize("▼ (+#{remaining_below} abajo)".center(avail_w + 2), { color: "gray", level: 2 })
+        rendered_lines << "#{margin_left}#{v_left} #{down_indicator} #{v_right}"
+      end
+
+      unless active_desc.empty?
+        separator_line = v_l_raw + mid_fill + v_r_raw
+        rendered_lines << "#{margin_left}#{colorize(separator_line, border_color_cfg)}"
+        desc_text = colorize("ℹ #{active_desc.ljust(avail_w)}", { color: "cyan", level: 1 })
+        rendered_lines << "#{margin_left}#{v_left} #{desc_text} #{v_right}"
+      end
+
       bottom_border_line = box_border[:bl] + bot_fill + box_border[:br]
       rendered_lines << "#{margin_left}#{colorize(bottom_border_line, border_color_cfg)}"
     else
@@ -725,8 +966,13 @@ class GRmenu
         rendered_lines << "#{margin_left}#{colorize(solid_line, border_color_cfg)}"
       end
 
-      option_names.each_with_index do |option_name, current_index|
-        avail_w = [total_width - 6, 1].max
+      if has_more_above
+        up_indicator = colorize("▲ (+#{start_idx} arriba)".center(avail_w + 2), { color: "gray", level: 2 })
+        rendered_lines << "#{margin_left}#{solid_border} #{up_indicator} #{solid_border}"
+      end
+
+      visible_indices.each do |current_index|
+        option_name = all_names[current_index]
         if @index == current_index
           highlighted_text = colorize("> #{option_name.ljust(avail_w)}", focus_color_cfg)
           rendered_lines << "#{margin_left}#{solid_border} #{highlighted_text} #{solid_border}"
@@ -736,6 +982,18 @@ class GRmenu
         end
       end
 
+      if has_more_below
+        remaining_below = total_items - 1 - end_idx
+        down_indicator = colorize("▼ (+#{remaining_below} abajo)".center(avail_w + 2), { color: "gray", level: 2 })
+        rendered_lines << "#{margin_left}#{solid_border} #{down_indicator} #{solid_border}"
+      end
+
+      unless active_desc.empty?
+        rendered_lines << "#{margin_left}#{colorize(solid_line, border_color_cfg)}"
+        desc_text = colorize("ℹ #{active_desc.ljust(avail_w)}", { color: "cyan", level: 1 })
+        rendered_lines << "#{margin_left}#{solid_border} #{desc_text} #{solid_border}"
+      end
+
       rendered_lines << "#{margin_left}#{colorize(solid_line, border_color_cfg)}"
     end
 
@@ -778,8 +1036,9 @@ class GRmenu
   def draw_frame(target_width)
     lines = render_lines(target_width)
     buffer = String.new(CURSOR_HOME)
-    lines.each do |line|
-      buffer << line << CLEAR_TO_EOL << "\r\n"
+    lines.each_with_index do |line, idx|
+      buffer << line << CLEAR_TO_EOL
+      buffer << "\r\n" if idx < lines.length - 1
     end
     buffer << CLEAR_TO_EOS
     Kernel.print(buffer)
@@ -848,6 +1107,8 @@ class GRmenu
     case action
     when Array
       action[0].to_s
+    when Hash
+      (action[:name] || action[:title] || action["name"] || action["title"] || "Opcion").to_s
     when Method
       format_auto_name(action.name)
     when Symbol
@@ -869,6 +1130,16 @@ class GRmenu
     end
   end
 
+  def extract_description_from_action(action)
+    if action.is_a?(Array) && action.length >= 3
+      action[2].to_s
+    elsif action.is_a?(Hash)
+      (action[:desc] || action[:description] || action["desc"] || action["description"]).to_s
+    else
+      ""
+    end
+  end
+
   def execute_action(action)
     case action
     when Method, Proc
@@ -881,7 +1152,26 @@ class GRmenu
       end
     when Array
       callable = action[1]
-      callable.call if callable.respond_to?(:call)
+      if callable.is_a?(Symbol)
+        if Object.respond_to?(callable, true)
+          Object.send(callable)
+        elsif Kernel.respond_to?(callable, true)
+          Kernel.send(callable)
+        end
+      elsif callable.respond_to?(:call)
+        callable.call
+      end
+    when Hash
+      callable = action[:action] || action[:call] || action["action"] || action["call"]
+      if callable.is_a?(Symbol)
+        if Object.respond_to?(callable, true)
+          Object.send(callable)
+        elsif Kernel.respond_to?(callable, true)
+          Kernel.send(callable)
+        end
+      elsif callable.respond_to?(:call)
+        callable.call
+      end
     else
       action.call if action.respond_to?(:call)
     end

data/README.md

@@ -2,7 +2,7 @@
 
 # GRmenu (Ruby)
 
-**Menús interactivos por teclado para terminal en modo TTY crudo, con soporte para Banners ASCII 3D, estilos y colores personalizados**
+**Menús interactivos por teclado para terminal en modo TTY crudo, con soporte para Banners ASCII 3D, barras de progreso, spinners animados, tooltips dinámicos, estilos y colores personalizados**
 
 Flechas arriba/abajo para moverte · `Enter` para elegir · `q` para salir
 
@@ -18,12 +18,15 @@ Flechas arriba/abajo para moverte · `Enter` para elegir · `q` para salir
 
 - 🎮 **Navegación con flechas** — arriba/abajo para moverte, `Enter` para ejecutar, `q` para salir.
 - 🔤 **10 Fuentes ASCII 3D para Banners** — fuentes tridimensionales (ANSI Shadow, Slant, Doom, Graffiti, Modular, Wire, Block, Stars, etc.).
-- 🎨 **20 estilos de borde** — desde ASCII clásico hasta caracteres Unicode dobles, curvas redondeadas y bloques.
+- 📜 **Auto-Paginación y Scroll Fluido** — calcula la altura de la terminal y crea una ventana deslizante con indicadores automáticos (`▲ (+N arriba)` / `▼ (+M abajo)`).
+- 💡 **Descripciones y Tooltips Dinámicos** — muestra información explicativa en la parte inferior del recuadro al enfocar cada opción.
+- ⏳ **Spinners y Barras de Progreso** — helpers nativos `GRmenu.spinner` y `GRmenu.progress` dentro de recuadros con la misma estética visual.
+- 🎨 **20 estilos de borde** — desde ASCII clásico hasta caracteres Unicode dobles, curvas redondeadas y bloques outline.
 - 🌈 **Paleta de colores completa** — personalización individual de marco, título, banner, subtítulo, divisores, opciones y foco activo con 2 niveles de brillo.
 - 📐 **Centrado simétrico automático** — alinea y centra automáticamente subtítulos y menús de opciones respecto al ancho de banners grandes.
-- 🛠️ **Helpers nativos en modo crudo** — `clear_screen`, `continue`, `banner`, `div` y `help` sin subprocesos lentos del sistema.
+- 🛠️ **Helpers nativos en modo crudo** — `clear_screen`, `continue`, `banner`, `spinner`, `progress`, `div` y `help`.
 - 💻 **100% Multiplataforma** — compatible con Linux, macOS y Windows (PowerShell, CMD, Windows Terminal, VS Code).
-- 📦 **Cero dependencias externas** — utiliza únicamente la librería estándar `io/console`.
+- 📦 **Cero dependencias externas** — utiliza únicamente la librería estándar `io/console` y `json`.
 
 ---
 
@@ -36,7 +39,7 @@ gem install grmenu
 O si trabajás con el archivo directamente en tu proyecto:
 
 ```ruby
-require_relative "GRmenu"
+require "GRmenu"
 ```
 
 <sub>Requiere Ruby ≥ 2.6.</sub>
@@ -45,7 +48,7 @@ require_relative "GRmenu"
 
 ## 💡 Cómo se pasan las opciones y todos los parámetros
 
-`GRmenu` permite pasar métodos directos, símbolos, arreglos con nombres personalizados, bloques lambda/procs y helpers. Además, acepta todos los parámetros de configuración visual en la instanciación:
+`GRmenu` permite pasar métodos directos, símbolos, arreglos con nombres personalizados, bloques lambda/procs y **descripciones explicativas (tooltips)**:
 
 ```ruby
 menu = GRmenu.new(
@@ -53,7 +56,8 @@ menu = GRmenu.new(
     method(:iniciar_servidor),                                       # 1. Method (auto-capitaliza: "Iniciar Servidor")
     :crear_respaldo,                                                 # 2. Symbol (auto-capitaliza: "Crear Respaldo")
     ["Métricas del Sistema", method(:ver_metricas)],                 # 3. Array ["Nombre Personalizado", acción]
-    ["Ejecutar Lambda", -> { puts Color.pink("Lambda!"); GRmenu.continue }], # 4. Lambda/Proc
+    ["Crear Backup", method(:respaldo), "Genera dump SQL de la BD"], # 4. Con Tooltip descriptivo al pie del marco
+    ["Ejecutar Lambda", -> { puts Color.pink("Lambda!"); GRmenu.continue }, "Bloque anónimo Proc/Lambda"],
     ["Probar Banner Helper", method(:prueba_banner_rapido)],         # 5. Helper GRmenu.banner
     ["Ver Ayuda y Referencia", method(:ver_ayuda_completa)],         # 6. Helper GRmenu.help
     method(:salir)                                                   # 7. Salir
@@ -61,11 +65,12 @@ menu = GRmenu.new(
   banner: "DEV OPS",                                                 # Texto gigante en arte ASCII 3D
   title: "Panel de Control",                                         # Título en el marco de opciones
   subtitle: "Consola de Administración\nUsa las flechas y Enter",    # Subtítulo (soporta saltos de línea \n)
-  font: 1,                                                           # Fuente del banner (1 al 10, por defecto 1: ANSI Shadow 3D)
+  font: 1,                                                           # Fuente del banner (1 al 10, default 1: ANSI Shadow 3D)
   style: 7,                                                          # Estilo de marco de opciones (1 al 20, ej: 7=redondeado, 3=doble)
   banner_style: 3,                                                   # Estilo de marco del banner (1 al 20, ej: 3=doble línea)
   divider: true,                                                     # Líneas divisorias a la par del banner (true, false o número)
-  center: true                                                       # Centrado automático del menú y subtítulo respecto al banner
+  center: true,                                                      # Centrado automático del menú y subtítulo respecto al banner
+  page_size: 8                                                       # (Opcional) Límite visible para auto-scroll y paginación
 )
 ```
 
@@ -73,14 +78,14 @@ menu = GRmenu.new(
 
 ## 🌟 Ejemplo Completo de Uso (`e.rb`)
 
-A continuación se muestra el archivo de ejemplo completo [`e.rb`](e.rb) con acciones, helpers, configuración de estilos, fuentes y colores:
+A continuación se muestra el archivo de ejemplo completo [`e.rb`](e.rb) con acciones originales, helpers de carga (`spinner` / `progress`), paginación, configuración de estilos, fuentes y colores:
 
 ```ruby
 # frozen_string_literal: true
 
-require_relative "GRmenu"
+require "GRmenu"
 
-# 1. Definición de acciones/métodos
+# 1. Definición de acciones/métodos originales
 def iniciar_servidor
   GRmenu.clear_screen
   puts Color.bright_green("-> Servidor iniciado correctamente en el puerto 3000.")
@@ -101,7 +106,6 @@ end
 
 def prueba_banner_rapido
   GRmenu.clear_screen
-  # Helper para mostrar un banner estático o animado en cualquier momento
   GRmenu.banner("OK", 0, color: "green", level: 2, style: 3, font: 1)
   GRmenu.div(40, "green", 1, "═")
   puts Color.green("  Prueba completada con éxito.")
@@ -111,7 +115,6 @@ end
 
 def ver_ayuda_completa
   GRmenu.clear_screen
-  # Helper interactivo que imprime toda la guía y referencia de GRmenu
   GRmenu.help
   GRmenu.continue
 end
@@ -122,44 +125,88 @@ def salir
   exit(0)
 end
 
-# 2. Instanciación del menú con TODOS los parámetros disponibles
-menu = GRmenu.new(
-  [
-    method(:iniciar_servidor),                                       # 1. Method (auto-capitaliza: "Iniciar Servidor")
-    :crear_respaldo,                                                 # 2. Symbol (auto-capitaliza: "Crear Respaldo")
-    ["Métricas del Sistema", method(:ver_metricas)],                 # 3. Array ["Nombre Personalizado", acción]
-    ["Ejecutar Lambda", -> { puts Color.pink("Lambda!"); GRmenu.continue }], # 4. Lambda/Proc
-    ["Probar Banner Helper", method(:prueba_banner_rapido)],         # 5. Helper GRmenu.banner
-    ["Ver Ayuda y Referencia", method(:ver_ayuda_completa)],         # 6. Helper GRmenu.help
-    method(:salir)                                                   # 7. Salir
-  ],
-  banner: "DEV OPS",                                                 # Texto gigante en arte ASCII 3D
-  title: "Panel de Control",                                         # Título en el marco de opciones
-  subtitle: "Consola de Administración\nUsa las flechas y Enter",    # Subtítulo (soporta saltos de línea \n)
-  font: 1,                                                           # Fuente del banner (1 al 10, por defecto 1: ANSI Shadow 3D)
-  style: 7,                                                          # Estilo de marco de opciones (1 al 20, ej: 7=redondeado, 3=doble)
-  banner_style: 3,                                                   # Estilo de marco del banner (1 al 20, ej: 3=doble línea)
-  divider: true,                                                     # Líneas divisorias a la par del banner (true, false o número)
-  center: true                                                       # Centrado automático del menú y subtítulo respecto al banner
-)
+# 2. Nuevos ejemplos: Barra de Progreso, Spinner y Paginación
+def demo_barra_progreso
+  GRmenu.clear_screen
+  # Fácil y rápido: pasas el total y bar.advance(1) en tu bucle
+  GRmenu.progress(10, title: "Descargando Paquetes", color: "cyan", style: 3) do |bar|
+    10.times do |i|
+      sleep 0.1
+      bar.advance(1, status: "Paso #{i + 1} de 10 completado")
+    end
+  end
+  puts Color.bright_green("\n-> ¡Barra completada al 100%!")
+  GRmenu.continue
+end
 
-# 3. Configuración completa de colores y estilos (set_style / style_config)
-# Colores disponibles: "black", "gray", "red", "green", "yellow", "blue",
-#                      "magenta", "purple", "pink", "cyan", "aqua", "orange", "white"
-# Niveles de brillo: 1 = normal, 2 = brillante
-
-menu.set_style.font(1)             # 1 = ANSI Shadow 3D, 2 = Slant 3D, 3 = Doom, etc.
-menu.set_style.banner("cyan", 2)   # Color del banner ASCII
-menu.set_style.title("yellow", 2)  # Color del título del recuadro
-menu.set_style.subtitle("white", 1)# Color del subtítulo/descripción
-menu.set_style.divider("blue", 1)  # Color de las líneas divisorias
-menu.set_style.border("yellow", 1) # Color del borde del marco de opciones
-menu.set_style.options("white", 1) # Color de opciones no seleccionadas
-menu.set_style.focus("green", 2)   # Color y brillo de la opción resaltada
-
-# 4. Dibujar y lanzar el menú interactivo
-# size_max / min_width define el ancho mínimo sugerido para el marco de opciones
-menu.draw(size_max: 38)
+def demo_spinner
+  GRmenu.clear_screen
+  GRmenu.spinner("Conectando a la base de datos...", color: "green") do
+    sleep 1.2
+  end
+  puts Color.bright_green("\n-> Conexión establecida con éxito.")
+  GRmenu.continue
+end
+
+def demo_paginacion
+  GRmenu.clear_screen
+  opciones_largas = (1..20).map do |n|
+    ["Elemento ##{n}", -> {
+      GRmenu.clear_screen
+      puts Color.bright_cyan("-> Has seleccionado el Elemento ##{n}")
+      GRmenu.continue
+    }, "Descripción opcional del elemento ##{n}"]
+  end
+
+  sub = GRmenu.new(
+    opciones_largas,
+    title: "Submenú Paginado",
+    subtitle: "Usa ↑ / ↓ para ver el auto-scroll",
+    style: 7,
+    page_size: 6
+  )
+  sub.draw(size_max: 38)
+end
+
+# 3. Instanciación del menú con TODOS los parámetros disponibles
+def main
+  menu = GRmenu.new(
+    [
+      method(:iniciar_servidor),                                       # 1. Method (sin info)
+      :crear_respaldo,                                                 # 2. Symbol (sin info)
+      ["Métricas del Sistema", method(:ver_metricas)],                 # 3. Array (sin info)
+      ["Probar Barra de Progreso", method(:demo_barra_progreso), "Ejemplo fácil de GRmenu.progress al 100%"], # 4. CON Tooltip
+      ["Probar Spinner de Carga", method(:demo_spinner), "Animación en tiempo real para funciones pesadas"],
+      ["Probar Paginación (20 ítems)", method(:demo_paginacion), "Desplazamiento suave de opciones"],
+      ["Ejecutar Lambda", -> { puts Color.pink("¡Lambda!"); GRmenu.continue }], # 5. Lambda/Proc
+      ["Probar Banner Helper", method(:prueba_banner_rapido)],         # 6. Helper GRmenu.banner
+      ["Ver Ayuda y Referencia", method(:ver_ayuda_completa), "Abre la guía de ayuda interactiva"],         # 7. Helper GRmenu.help
+      method(:salir)                                                   # 8. Salir
+    ],
+    banner: " gr codE ",
+    title: "Panel de Control",
+    subtitle: "Consola de Administración TTY\nUsa ↑ / ↓ para navegar y Enter para seleccionar",
+    style: 3,
+    banner_style: 3,
+    divider: true,
+    center: true
+  )
+
+  # 4. Configuración completa de colores y estilos
+  menu.set_style.font(1)             # 1 = ANSI Shadow 3D
+  menu.set_style.banner("cyan", 2)   # Color del banner ASCII
+  menu.set_style.title("yellow", 2)  # Color del título del recuadro
+  menu.set_style.subtitle("white", 1)# Color del subtítulo
+  menu.set_style.divider("blue", 1)  # Color de las líneas divisorias
+  menu.set_style.border("yellow", 1) # Color del borde del marco de opciones
+  menu.set_style.options("white", 1) # Color de opciones no seleccionadas
+  menu.set_style.focus("green", 2)   # Color y brillo de la opción resaltada
+
+  # 5. Dibujar y lanzar el menú interactivo
+  menu.draw(size_max: 38)
+end
+
+main
 ```
 
 ---
@@ -178,28 +225,6 @@ O desde una instancia:
 menu.help
 ```
 
-Salida limpia y estructurada en consola:
-
-```text
-╔══════════════════════════════════════════════════════════════╗
-║              GRmenu - Guia y Referencia Rapida               ║
-║            Navegacion interactiva en terminal TTY            ║
-╚══════════════════════════════════════════════════════════════╝
-
-[1] HELPERS NATIVOS EN MODO CRUDO
-────────────────────────────────────────────────────────────────
-  GRmenu.clear_screen (o GRmenu.clr)
-    * Limpia la terminal al instante con secuencias ANSI.
-  GRmenu.continue(mensaje)
-    * Pausa interactiva: espera una sola tecla en modo TTY crudo.
-  GRmenu.banner(texto, delay, color:, level:, style:, font:)
-    * Renderiza banner ASCII 3D con marco y animacion opcional.
-  GRmenu.div(longitud, color, level, char)
-    * Dibuja linea divisoria horizontal adaptable a la consola.
-  GRmenu.help
-    * Imprime esta guia visual interactiva en consola.
-```
-
 ---
 
 ## 🕹️ Controles
@@ -273,13 +298,23 @@ GRmenu.clear_screen # o GRmenu.clr
 # 2. Imprime un banner o logo gigante responsivo
 GRmenu.banner("SECURE", 0, color: "magenta", style: 3, font: 1)
 
-# 3. Línea divisoria horizontal adaptable
+# 3. Spinner animado en tiempo real mientras corre un bloque
+GRmenu.spinner("Conectando al clúster...", color: "green") do
+  hacer_tarea_pesada()
+end
+
+# 4. Barra de progreso porcentual dentro de un recuadro estilizado
+GRmenu.progress(10, title: "Exportando Datos", color: "cyan") do |bar|
+  10.times { |i| bar.advance(1, status: "Paso #{i + 1}/10") }
+end
+
+# 5. Línea divisoria horizontal adaptable
 GRmenu.div(60, "blue")
 
-# 4. Pausa de consola que espera una sola tecla en modo TTY crudo
+# 6. Pausa de consola que espera una sola tecla en modo TTY crudo
 GRmenu.continue("Presiona cualquier tecla para continuar...")
 
-# 5. Guía interactiva en consola
+# 7. Guía interactiva en consola
 GRmenu.help
 ```
 
@@ -291,7 +326,7 @@ GRmenu.help
 
 | Parámetro        | Tipo       | Descripción |
 |------------------|------------|-------------|
-| `functions`      | `Array`    | Opciones a mostrar (`Method`, `Symbol`, `Array ["Nombre", acción]`, `Proc`/`lambda`). |
+| `functions`      | `Array`    | Opciones a mostrar (`Method`, `Symbol`, `Array ["Nombre", acción, "Descripción"]`, `Proc`/`lambda`). |
 | `banner:`        | `String`   | Texto gigante a renderizar en arte ASCII 3D arriba del menú. |
 | `title:`         | `String`   | Título en la cabecera del marco de opciones. |
 | `subtitle:`      | `String`   | Subtítulo o descripción (soporta múltiples líneas con `\n`). |
@@ -300,6 +335,15 @@ GRmenu.help
 | `banner_style:`  | `Integer`  | Estilo de marco para el banner (1 al 20, default 3). |
 | `divider:`       | `Boolean`  | Dibuja líneas divisorias a la par del ancho del banner. |
 | `center:`        | `Boolean`  | Centra simétricamente el subtítulo y menú de opciones (default `true`). |
+| `page_size:`     | `Integer`  | (Opcional) Número máximo de opciones visibles en pantalla para auto-paginación. |
+
+### `GRmenu.spinner(message, color: "cyan", &block)`
+
+Ejecuta un bloque en segundo plano mientras dibuja una animación giratoria y muestra `✔ Mensaje ¡Listo!` al terminar.
+
+### `GRmenu.progress(total, title:, color:, style:, &block)`
+
+Crea una barra de progreso porcentual dentro de un recuadro estilizado. El bloque recibe el objeto `bar` con los métodos `bar.advance(n, status:)` y `bar.set(valor, status:)`.
 
 ### `menu.set_style`
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grmenu
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 2.0.0
 platform: ruby
 authors:
 - grcode