fatty 0.99.0 → 0.99.3

data/exe/fatty

@@ -7,21 +7,32 @@ require "shellwords"
 
 require "rainbow/refinement"
 using Rainbow
+using Fatty::CoreExt::String
 
 prompt = Fatty::Prompt.new { "#{Dir.pwd}> " }
 history_ctx_proc = -> { { pwd: Dir.pwd } }
 
 on_accept_proc = lambda do |line, env|
-  session = env.session
-  terminal = env.terminal
-
   cmd, *args = Shellwords.split(line)
-
   case cmd
   when "cd"
     dir = args.first || ENV["HOME"]
     dir = File.expand_path(dir)
     Dir.chdir(dir)
+  when "environment"
+    env.append("The environment Fatty has detected is:\n")
+    env.environment.each do |key, value|
+      if value.is_a?(Hash)
+        env.append("#{key}:\n")
+        value.each do |sub_key, sub_value|
+          env.append("  #{sub_key} -> #{sub_value}\n")
+        end
+      else
+        env.append("#{key} -> #{value}\n")
+      end
+    end
+
+    nil
   when "choose"
     choices =
       if args.empty?
@@ -29,42 +40,30 @@ on_accept_proc = lambda do |line, env|
       else
         args
       end
-
-    choice = terminal.choose(
+    choice = env.choose(
       "Select one",
       choices: choices,
       initial_choice_idx: 0,
-      quit_value: nil,
+      cancel_value: nil,
     )
-
-    if choice.nil?
-      session.append_output("choose: cancelled\n")
-    else
-      session.append_output("choose: selected #{choice.inspect}\n")
-    end
+    choice ? "choose: #{choice}\n" : "choose: cancelled\n"
   when "choosevals"
     pairs =
       if args.empty?
-        [["Choice A", 55], ["Choice B", 3.14159], ["Choice C", :done]]
+        { "Choice A" => 55, "Choice B" => 3.14159, "Choice C" => 2.7181828 }
       elsif args.length.odd?
         session.append_output("choosevals: needs even number of args\n")
         next
       else
-        args.each_slice(2).map { |label, value| [label, value] }
+        args.each_slice(2).to_h
       end
-
-    choice = terminal.choose(
+    choice = env.choose(
       "Select one",
       choices: pairs,
       initial_choice_idx: 1,
-      quit_value: nil,
+      cancel_value: nil,
     )
-
-    if choice.nil?
-      session.append_output("choosevals: cancelled\n")
-    else
-      session.append_output("choosevals: selected #{choice.inspect}\n")
-    end
+    choice ? "choosevals: #{choice}\n" : "choosevals: cancelled\n"
   when "choose_multi"
     choices =
       if args.empty?
@@ -72,90 +71,89 @@ on_accept_proc = lambda do |line, env|
       else
         args
       end
-
-    choices = terminal.choose_multi(
+    choices = env.choose_multi(
       "Select one or more",
       choices: choices,
-      quit_value: nil,
+      cancel_value: nil,
     )
-
-    if choices.nil?
-      session.append_output("choose_multi: cancelled\n")
-    else
-      session.append_output("choose_multi: selected #{choices.inspect}\n")
-    end
+    choices ? "choose_multi: #{choices}\n" : "choose_multi: cancelled\n"
   when "choosevals_multi"
     pairs =
       if args.empty?
-        pairs = [["Choice A", 55], ["Choice B", 3.14159], ["Choice C", :done]]
+        { "Choice A" => 55, "Choice B" => 3.14159, "Choice C" => 2.7181828 }
       elsif args.length.odd?
         session.append_output("choosevals_multi: needs even number of args\n")
         next
       else
-        pairs = args.each_slice(2).map { |label, value| [label, value] }
+        args.each_slice(2).to_h
       end
-
-    choices = terminal.choose_multi(
+    choices = env.choose_multi(
       "Select one or more",
       choices: pairs,
-      quit_value: nil,
+      cancel_value: nil,
     )
-
-    if choices.nil?
-      session.append_output("choosevals_multi: cancelled\n")
-    else
-      session.append_output("choosevals_multi: selected #{choices.inspect}\n")
-    end
+    choices ? "choosevals_multi: #{choices}\n" : "choosevals_multi: cancelled\n"
+  when "confirm"
+    prompt =
+      if args.empty?
+        "Do you like fatty?"
+      else
+        args
+      end
+    reply = env.confirm(prompt)
+    reply ? "confirm: True\n" : "confirm: False\n"
   when "menu"
-    result = terminal.menu(
+    result = env.menu(
       "Demo menu",
       choices: {
         "Write to output pane" => proc { |env|
-      env.output("menu: wrote this from MenuEnv#output\n")
-      :output_written
-    },
-
+          env.append("menu: wrote this from MenuEnv#output\n")
+          :output_written
+        },
         "Show status message" => proc { |env|
-      env.status("menu: status set from MenuEnv#status")
-      :status_written
-    },
-
-        "Return plain value" => :plain_value,
+          env.status("menu: status set from MenuEnv#status")
+          :status_written
+        },
+        "Show markdown" => proc { |env|
+          env.markdown("\# Your Choices\n\n- one\n- two\n- three\n")
+          :markdown_written
+        },
       },
-      initial_choice_idx: 0,
-      quit_value: nil,
     )
     if result.nil?
-      session.append_output("menu: cancelled\n")
+      env.append("menu: cancelled\n")
     else
-      session.append_output("menu: result #{result.inspect}\n")
+      env.append("menu: result #{result.inspect}\n")
     end
   when "info"
     message = args.empty? ? "Information message" : args.join(" ")
     message = message.gsub(/ ?~~ ?/, "\n")
-    terminal.info(message)
-    session.append_output("info: #{message}\n")
+    env.info(message)
+    env.append("info: #{message}\n")
   when "good"
     message = args.empty? ? "Success message" : args.join(" ")
     message = message.gsub(/ ?~~ ?/, "\n")
-    terminal.good(message)
-    session.append_output("good: #{message}\n")
+    env.good(message)
+    env.append("good: #{message}\n")
   when "warn"
     message = args.empty? ? "Danger Will Robinson!" : args.join(" ")
     message = message.gsub(/ ?~~ ?/, "\n")
-    terminal.warn(message)
-    session.append_output("warn: #{message}\n")
+    env.warn(message)
+    env.append("warn: #{message}\n")
   when "oops"
     message = args.empty? ? "Something went wrong" : args.join(" ")
     message = message.gsub(/ ?~~ ?/, "\n")
-    terminal.oops(message)
-    session.append_output("oops: #{message}\n")
+    env.oops(message)
+    env.append("oops: #{message}\n")
   when "prompt"
     question = args.empty? ? "Enter value:" : args.join(" ")
-    value = terminal.prompt(question, initial: "demo")
-    session.append_output("prompt: #{value.inspect}\n")
+    value = env.prompt(question, initial: "demo")
+    env.append("prompt: #{value.inspect}\n")
   when "progress"
-    styles = %w[count percent simple_percent trail bar unicode_bar braille_bar spinner]
+    # The first argument is the style (or :trail if not given), the optional
+    # second argument is the total if it is all digits, or the role otherwise.
+    # If the role is not recognized, it defaults to :info
+    styles = %w[count percent count_percent trail bar unicode_bar braille_bar spinner]
     style_name = args.first
     style =
       if style_name && styles.include?(style_name)
@@ -163,35 +161,38 @@ on_accept_proc = lambda do |line, env|
       else
         :trail
       end
-
-    total =
-      begin
-        args.first ? Integer(args.first) : nil
-      rescue StandardError
-        nil
+    total = 40
+    width = 60
+    role = :info
+    args.each do |arg|
+      case arg
+      when /\A\d+\z/
+        total = Integer(arg)
+      when Symbol, String
+        md = arg.match(/good|info|warn|error/i)
+        role = md ? md[0].to_sym : :info
       end
-
+    end
     if style != :spinner
       total ||= 40
       total = 1 if total < 1
     elsif total && total < 1
       total = 1
     end
-
-    prog = env.progress(
+    prog = env.add_progress(
       label: "Demo progress",
       total: total,
       style: style,
+      role: role || :info,
+      width: width,
     )
-
     if style == :spinner && total.nil?
       40.times do
         prog.update(render: true)
         sleep 0.1
       end
-
-      prog.finish("Demo progress complete.", render: true)
-      session.append_output("progress: style=#{style} completed indeterminate demo\n")
+      prog.finish("Done", render: true)
+      env.append("progress: style=#{style} completed indeterminate demo\n")
     else
       total.times do |i|
         indicator =
@@ -201,15 +202,14 @@ on_accept_proc = lambda do |line, env|
           when 2 then "^".fatty_warn
           else "."
           end
-
         prog.update(current: i + 1, indicator: indicator, render: true)
         sleep 0.1
       end
-      prog.finish("Demo progress complete.".green, render: true)
-      session.append_output("progress: style=#{style} completed #{total} steps\n")
+      prog.finish("Done".green, render: true)
+      env.append("progress: style=#{style} completed #{total} steps\n")
     end
   when "keytest"
-    return [[:terminal, :push_modal, Fatty::KeyTestSession.new(owner: session)], [:send, :alert, :clear, {}]]
+    env.keytest
   when 'markdown'
     file = args.first || File.expand_path("../examples/markdown/native-markdown.md", __dir__)
     text = File.read(File.expand_path(file))
@@ -218,17 +218,158 @@ on_accept_proc = lambda do |line, env|
     file = File.expand_path("../examples/markdown/ox-gfm-markdown.md", __dir__)
     text = File.read(File.expand_path(file))
     env.markdown(text)
+  when "interrupt"
+    seconds =
+      if args.first&.match?(/\A\d+\z/)
+        Integer(args.first)
+      else
+        120
+      end
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+    last_remaining = nil
+    begin
+      loop do
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      remaining = (deadline - now).ceil
+      break if remaining <= 0
+
+      if remaining != last_remaining
+        env.status(
+          "Interrupt demo: #{remaining} seconds remaining — press C-c or C-g",
+          replace: true,
+        )
+        last_remaining = remaining
+      end
+      env.check_interrupt!
+      sleep 0.1
+    end
+    rescue Fatty::Interrupt
+      env.warn("Interrupt demo interrupted.", replace: true)
+      raise
+    else
+      env.good("Interrupt demo completed.", replace: true)
+    end
+  when "colors"
+    environment = env.environment
+    available = environment.dig(:curses, :colors).to_i
+    available = 16 if available <= 0
+    truecolor_enabled = environment[:truecolor_enabled]
+
+    env.append("Fatty color report\n")
+    env.append("truecolor enabled -> #{truecolor_enabled}\n")
+    env.append("available indexed colors -> #{available}\n")
+    env.append("rendering mode -> #{truecolor_enabled ? '24-bit RGB' : "#{available}-color indexed"}\n")
+    env.append("\n")
+
+
+    env.append("ANSI colors\n")
+    Fatty::Color.ansi_colors.each do |name, index|
+      rgb = Fatty::Color.xterm_rgb_for_index(index)
+      env.append(
+        color_swatch_line(
+          name: name,
+          requested_rgb: rgb,
+          fallback_index: Fatty::Color.resolve(index, available_colors: available),
+          truecolor: truecolor_enabled,
+        )
+      )
+    end
+
+    env.append("\n256 colors\n")
+    256.times do |index|
+      rgb = Fatty::Color.xterm_rgb_for_index(index)
+      env.append(
+        color_swatch_line(
+          name: Fatty::Color.xterm_color_name(index),
+          requested_rgb: rgb,
+          fallback_index: Fatty::Color.resolve(index, available_colors: available),
+          truecolor: truecolor_enabled,
+        )
+      )
+    end
+
+    env.append("\nX11 colors\n")
+    Fatty::Color.x11_colors_by_name.each do |name, rgb|
+      fallback_index = Fatty::Color.resolve(
+        Fatty::Color.hex_for_rgb(rgb),
+        available_colors: available,
+      )
+
+      env.append(
+        color_swatch_line(
+          name: name,
+          requested_rgb: rgb,
+          fallback_index: fallback_index,
+          truecolor: truecolor_enabled,
+        )
+      )
+    end
+
+    nil
   when 'help'
     env.markdown(Fatty::Help.text)
   else
-    out, _ = Open3.capture2e(line)
-    session.append_output(out)
+    unless line.match?(/\A\s*\z/)
+      out, _ = Open3.capture2e(line)
+      out
+    end
+  end
+  rescue Errno::ENOENT
+    env.alert("Command not found (#{line})", role: :error)
+    nil
+  rescue SystemCallError => ex
+    env.alert(ex.message, role: :error)
+    nil
+end
+
+def color_swatch_line(name:, requested_rgb:, fallback_index:, truecolor:, width: 24)
+  fallback_rgb = Fatty::Color.xterm_rgb_for_index(fallback_index)
+  rendered_rgb =
+    if truecolor
+      requested_rgb
+    else
+      fallback_rgb
+    end
+
+  band = color_band_for_rgb(
+    name: name,
+    rgb: rendered_rgb,
+    truecolor: truecolor,
+    fallback_index: fallback_index,
+    width: width,
+  )
+
+  format(
+    "%3s  %-28s requested %s  rendered %s  fallback %3d %s  %s\n",
+    truecolor ? "-" : fallback_index,
+    name,
+    Fatty::Color.hex_for_rgb(requested_rgb),
+    Fatty::Color.hex_for_rgb(rendered_rgb),
+    fallback_index,
+    Fatty::Color.hex_for_rgb(fallback_rgb),
+    band,
+  )
+end
+
+def color_band_for_rgb(name:, rgb:, truecolor:, fallback_index:, width: 36)
+  label = " #{name} "
+  label = label[0, width].center(width)
+
+  if truecolor
+    fg = Fatty::Color.contrasting_rgb(rgb)
+
+    "\e[38;2;#{fg[0]};#{fg[1]};#{fg[2]}m" \
+    "\e[48;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m" \
+    "#{label}" \
+    "\e[0m"
+  else
+    fg_index = Fatty::Color.contrasting_ansi_index(fallback_index)
+
+    "\e[38;5;#{fg_index}m" \
+    "\e[48;5;#{fallback_index}m" \
+    "#{label}" \
+    "\e[0m"
   end
-  [[:send, :alert, :clear, {}]]
-rescue Errno::ENOENT
-  [[:send, :alert, :show, { level: :error, message: "Command not found (#{line})" }]]
-rescue SystemCallError => ex
-  [[:send, :alert, :show, { level: :error, message: ex.message }]]
 end
 
 cutes = []
@@ -250,8 +391,10 @@ builtins = %w[
   choosevals
   choose_multi
   choosevals_multi
+  colors
   help
   info
+  interrupt
   good
   keytest
   markdown