fatty 0.99.8 → 0.99.8.2

data/README.org

@@ -773,6 +773,24 @@ If you want a value associated with the user's cancellation of the chooser
 with C-c or C-g, set =cancel_value:= to that value.
 
 
+*** =suspend(&block)=
+
+The =suspend= method temporarily gives control of the terminal to the
+application while the supplied block runs.  When the block finishes, Fatty
+restores its terminal state and redraws the interface.
+
+This is useful for running interactive terminal programs such as editors,
+debuggers, shells, or other programs that need direct access to the terminal.
+
+#+begin_src ruby :tangle no
+  env.suspend do
+    system(ENV.fetch("EDITOR", "vi"), filename)
+  end
+#+end_src
+
+The value of the block is returned by =suspend=.  Terminal state is restored
+even if the block exits by raising an exception.
+
 *** =environment=
 This returns a =Hash= of runtime conditions detected by =Fatty=:
 
@@ -806,6 +824,10 @@ The environment report also includes a nested =:curses= hash:
 | =:color_pairs=      | Number of color pairs available to curses              |
 | =:can_change_color= | Whether curses can redefine color values               |
 
+** Terminal Methods
+*** =Teminal#suspend(&block)=
+Return control to the launching terminal, execute the given block, and return.
+
 * Default Interaction
 ** Parts of the Screen
 *** Input Field
@@ -2134,3 +2156,75 @@ Or you can group them under =markdown= without the =markdown_= prefix:
       bg: navy
       attrs: [underline]
 #+end_src
+
+*** The =themer= helper
+
+Choosing readable colors for the semantic roles---=good=, =info=, =warn=, and
+=error=---is not trivial.  The =themer= utility can suggest suitable foreground
+colors based on a theme's output background.
+
+For an existing theme, =themer= also reports the contrast of the current role
+colors and flags those that fall below its target contrast.
+
+Pass it either the name of an existing theme:
+
+#+begin_src sh :tangle no
+  themer nordic
+#+end_src
+
+#+begin_example
+Theme: nordic
+Output background: #2e3440
+
+Current semantic roles:
+
+good   #22ee00  contrast 7.91  OK
+info   #33deff  contrast 7.75  OK
+warn   #d78700  contrast 4.37  LOW
+error  #d700af  contrast 2.68  LOW
+
+Suggested semantic roles:
+
+good   #28bd41  contrast 5.02
+info   #74abe2  contrast 5.15
+warn   #caa22b  contrast 5.18
+error  #e78d8d  contrast 5.11
+#+end_example
+
+or a hexadecimal background color when developing a new theme:
+
+#+begin_src sh :tangle no
+  themer '#2e3440'
+#+end_src
+
+#+begin_example
+Background: #2e3440
+Output background: #2e3440
+
+Suggested semantic roles:
+
+good   #28bd41  contrast 5.02
+info   #74abe2  contrast 5.15
+warn   #caa22b  contrast 5.18
+error  #e78d8d  contrast 5.11
+#+end_example
+
+You can get the suggestions in YAML form by giving the =--yaml= flag:
+
+#+begin_src sh :tangle no
+  themer --yaml '#2e3440'
+#+end_src
+
+#+begin_example
+good:
+  fg: "#28bd41"
+
+info:
+  fg: "#74abe2"
+
+warn:
+  fg: "#caa22b"
+
+error:
+  fg: "#e78d8d"
+#+end_example

data/exe/fatty

@@ -11,6 +11,15 @@ using Fatty::CoreExt::String
 
 prompt = Fatty::Prompt.new { "#{Dir.pwd}> " }
 history_ctx_proc = -> { { pwd: Dir.pwd } }
+append_text = lambda do |args|
+  if args.length == 1 && File.file?(File.expand_path(args.first))
+    File.read(File.expand_path(args.first))
+  elsif args.empty?
+    "Fatty output role test\n"
+  else
+    "#{args.join(' ')}\n"
+  end
+end
 
 on_accept_proc = lambda do |line, env|
   cmd, *args = Shellwords.split(line)
@@ -107,17 +116,17 @@ on_accept_proc = lambda do |line, env|
       "Demo menu",
       choices: {
         "Write to output pane" => proc { |env|
-          env.append("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
-        },
+      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
-        },
+      env.markdown("\# Your Choices\n\n- one\n- two\n- three\n")
+      :markdown_written
+    },
       },
     )
     if result.nil?
@@ -125,6 +134,34 @@ on_accept_proc = lambda do |line, env|
     else
       env.append("menu: result #{result.inspect}\n")
     end
+  when "append", "append_good", "append_info", "append_warn", "append_error",
+    "append_now", "append_now_good", "append_now_info", "append_now_warn", "append_now_error"
+    role =
+      case cmd
+      when /_good\z/  then :good
+      when /_info\z/  then :info
+      when /_warn\z/  then :warn
+      when /_error\z/ then :error
+      end
+    text = append_text.call(args)
+    if cmd.start_with?("append_now")
+      env.append_now(text, role: role)
+    else
+      env.append(text, role: role)
+    end
+    nil
+  when "append_roles"
+    env.append("GOOD\n", role: :good)
+    env.append("INFO\n", role: :info)
+    env.append("WARN\n", role: :warn)
+    env.append("ERROR\n", role: :error)
+    nil
+  when "append_now_roles"
+    env.append_now("GOOD\n", role: :good)
+    env.append_now("INFO\n", role: :info)
+    env.append_now("WARN\n", role: :warn)
+    env.append_now("ERROR\n", role: :error)
+    nil
   when "info"
     message = args.empty? ? "Information message" : args.join(" ")
     message = message.gsub(/ ?~~ ?/, "\n")
@@ -386,6 +423,18 @@ end
 cutes = cutes.compact.sort_by(&:downcase).uniq
 
 builtins = %w[
+  append
+  append_good
+  append_info
+  append_now
+  append_now_error
+  append_now_good
+  append_now_info
+  append_now_roles
+  append_now_warn
+  append_error
+  append_roles
+  append_warn
   cd
   choose
   choosevals

data/exe/themer

@@ -0,0 +1,273 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+# frozen_string_literal: true
+
+require "optparse"
+require "fatty"
+
+ROLE_HUES = {
+  good: 130.0,
+  info: 210.0,
+  warn: 45.0,
+  error: 0.0,
+}.freeze
+
+TARGET_CONTRAST = 5.0
+
+def normalize_hex(value)
+  hex = value.to_s.delete_prefix("#")
+  raise ArgumentError, "invalid RGB color: #{value.inspect}" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+
+  "##{hex.downcase}"
+end
+
+def hex_color?(value)
+  value.to_s.match?(/\A#?[0-9a-fA-F]{6}\z/)
+end
+
+def hex_to_rgb(hex)
+  hex = normalize_hex(hex).delete_prefix("#")
+  [
+    hex[0, 2].to_i(16),
+    hex[2, 2].to_i(16),
+    hex[4, 2].to_i(16),
+  ]
+end
+
+def rgb_to_hex(rgb)
+  format("#%02x%02x%02x", *rgb)
+end
+
+def srgb_component(value)
+  value /= 255.0
+
+  if value <= 0.04045
+    value / 12.92
+  else
+    ((value + 0.055) / 1.055)**2.4
+  end
+end
+
+def luminance(rgb)
+  red, green, blue = rgb.map { |value| srgb_component(value) }
+
+  (0.2126 * red) +
+    (0.7152 * green) +
+    (0.0722 * blue)
+end
+
+def contrast_ratio(first, second)
+  first_luminance = luminance(first)
+  second_luminance = luminance(second)
+
+  light, dark = [first_luminance, second_luminance].max,
+                [first_luminance, second_luminance].min
+
+  (light + 0.05) / (dark + 0.05)
+end
+
+def hsl_to_rgb(hue, saturation, lightness)
+  chroma = (1 - (2 * lightness - 1).abs) * saturation
+  section = hue / 60.0
+  intermediate = chroma * (1 - ((section % 2) - 1).abs)
+
+  red, green, blue =
+    case section
+    when 0...1 then [chroma, intermediate, 0]
+    when 1...2 then [intermediate, chroma, 0]
+    when 2...3 then [0, chroma, intermediate]
+    when 3...4 then [0, intermediate, chroma]
+    when 4...5 then [intermediate, 0, chroma]
+    else [chroma, 0, intermediate]
+    end
+
+  offset = lightness - chroma / 2
+
+  [red, green, blue].map do |value|
+    ((value + offset) * 255).round.clamp(0, 255)
+  end
+end
+
+def suggested_color(background, hue, target: TARGET_CONTRAST)
+  background_rgb = hex_to_rgb(background)
+  background_luminance = luminance(background_rgb)
+  saturation = 0.65
+
+  lightness_values =
+    if background_luminance < 0.5
+      (35..90).map { |value| value / 100.0 }
+    else
+      (65).downto(10).map { |value| value / 100.0 }
+    end
+
+  best_rgb = nil
+  best_ratio = 0.0
+
+  lightness_values.each do |lightness|
+    rgb = hsl_to_rgb(hue, saturation, lightness)
+    ratio = contrast_ratio(rgb, background_rgb)
+
+    if ratio > best_ratio
+      best_rgb = rgb
+      best_ratio = ratio
+    end
+
+    return [rgb_to_hex(rgb), ratio] if ratio >= target
+  end
+
+  [rgb_to_hex(best_rgb), best_ratio]
+end
+
+def theme_background(name)
+  theme = Fatty::Themes::Manager.fetch(name)
+  background = theme.dig(:roles, :output, :bg)
+
+  unless background
+    raise ArgumentError,
+          "theme #{name.inspect} has no resolved output background"
+  end
+
+  rgb = Fatty::Color.rgb(background)
+
+  unless rgb
+    raise ArgumentError,
+          "cannot resolve output background #{background.inspect} for theme #{name.inspect}"
+  end
+
+  rgb_to_hex(rgb)
+rescue Fatty::Themes::ResolveError => e
+  raise ArgumentError, e.message
+end
+
+def current_roles(name, background)
+  theme = Fatty::Themes::Manager.fetch(name)
+  background_rgb = hex_to_rgb(background)
+
+  ROLE_HUES.keys.to_h do |role|
+    foreground = theme.dig(:roles, role, :fg)
+    rgb = Fatty::Color.rgb(foreground)
+
+    data =
+      if rgb
+        ratio = contrast_ratio(rgb, background_rgb)
+
+        {
+          hex: rgb_to_hex(rgb),
+          contrast: ratio,
+          status: ratio >= TARGET_CONTRAST ? "OK" : "LOW",
+        }
+      else
+        {
+          hex: foreground.to_s,
+          contrast: nil,
+          status: "UNKNOWN",
+        }
+      end
+
+    [role, data]
+  end
+end
+
+def print_yaml(suggestions)
+  suggestions.each do |role, data|
+    puts "#{role}:"
+    puts "  fg: #{data[:hex].inspect}\n\n"
+  end
+end
+
+def print_roles(title, roles, status: false)
+  puts title
+  puts
+
+  roles.each do |role, data|
+    if data[:contrast]
+      line = format(
+        "%-6s %-8s contrast %.2f",
+        role,
+        data[:hex],
+        data[:contrast],
+      )
+      line += "  #{data[:status]}" if status
+      puts line
+    else
+      puts format(
+             "%-6s %-8s contrast unknown%s",
+             role,
+             data[:hex],
+             status ? "  #{data[:status]}" : "",
+           )
+    end
+  end
+end
+
+def print_report(source:, background:, current: nil, suggestions:)
+  puts source
+  puts "Output background: #{background}"
+  puts
+
+  if current
+    print_roles("Current semantic roles:", current, status: true)
+    puts
+  end
+
+  print_roles("Suggested semantic roles:", suggestions)
+end
+
+options = {
+  yaml: false,
+}
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: themer THEME|RGB [options]"
+
+  parser.on("--yaml", "Output role definitions as YAML") do
+    options[:yaml] = true
+  end
+end.parse!
+
+argument = ARGV.shift
+
+unless argument
+  warn "Usage: themer THEME|RGB [--yaml]"
+  exit 1
+end
+
+begin
+  current = nil
+  if hex_color?(argument)
+    background = normalize_hex(argument)
+    source = "Background: #{background}"
+  else
+    background = theme_background(argument)
+    source = "Theme: #{argument}"
+    current = current_roles(argument, background)
+  end
+
+  suggestions =
+    ROLE_HUES.to_h do |role, hue|
+      hex, ratio = suggested_color(background, hue)
+
+      [
+        role,
+        {
+          hex: hex,
+          contrast: ratio,
+        },
+      ]
+    end
+
+  if options[:yaml]
+    print_yaml(suggestions)
+  else
+    print_report(
+      source: source,
+      background: background,
+      current: current,
+      suggestions: suggestions,
+    )
+  end
+rescue ArgumentError => e
+  warn e.message
+  exit 1
+end

data/lib/fatty/ansi/renderer.rb

@@ -13,7 +13,13 @@ module Fatty
         spec = palette&.[](role.to_sym)
         return text.to_s unless spec
 
-        "#{sgr_for_spec(spec)}#{text}#{reset}"
+        text.to_s.split(/(\n)/).map do |part|
+          if part == "\n"
+            part
+          else
+            "#{sgr_for_spec(spec)}#{part}#{reset}"
+          end
+        end.join
       end
 
       def render_line(row:, col:, width:, text:, role:, palette:)
@@ -154,13 +160,17 @@ module Fatty
         fg = rgb_for_style_color(style.fg, fallback: fallback_spec[:fg_rgb])
         bg = rgb_for_style_color(style.bg, fallback: fallback_spec[:bg_rgb])
 
-        codes = []
-        codes << "1" if style.bold
-        codes << "3" if style.italic
-        codes << "4" if style.underline
-        codes << "9" if style.strike
+        attrs = Array(fallback_spec[:attrs]).map(&:to_sym)
 
-        if style.reverse
+        codes = []
+        codes << "1" if attrs.include?(:bold) || style.bold
+        codes << "2" if attrs.include?(:dim)
+        codes << "3" if attrs.include?(:italic) || style.italic
+        codes << "4" if attrs.include?(:underline) || style.underline
+        codes << "9" if attrs.include?(:strike) || style.strike
+
+        reverse = attrs.include?(:reverse) || style.reverse
+        if reverse
           if fg && bg
             fg, bg = bg, fg
           else

data/lib/fatty/api/output.rb

@@ -4,19 +4,21 @@ module Fatty
   module OutputApi
     def append(text, follow: true, role: nil)
       payload = {
-        text: output_text(text, role: role),
+        text: text.to_s,
         follow: follow,
       }
+      payload[:role] = role if role
       queue(Command.session(output_id, :append, **payload))
       nil
     end
 
     def append_now(text, follow: true, mode: nil, role: nil)
       payload = {
-        text: output_text(text, role: role),
+        text: text.to_s,
         follow: follow,
       }
       payload[:mode] = mode if mode
+      payload[:role] = role if role
 
       terminal.apply_command(Command.session(output_id, :append, **payload))
       terminal.render_frame
@@ -37,19 +39,6 @@ module Fatty
 
     private
 
-    def output_text(text, role:)
-      text = text.to_s
-      if role
-        Fatty::Ansi::Renderer.new.style(
-          text,
-          role: role,
-          palette: markdown_palette,
-        )
-      else
-        text
-      end
-    end
-
     def markdown_palette
       terminal.renderer.palette if terminal.respond_to?(:renderer) && terminal.renderer
     end

data/lib/fatty/api/suspend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fatty
+  module SuspendApi
+    def suspend(&block)
+      terminal.suspend(&block)
+    end
+  end
+end

data/lib/fatty/api.rb

@@ -36,3 +36,4 @@ require_relative './api/progress.rb'
 require_relative './api/menu.rb'
 require_relative './api/keytest.rb'
 require_relative './api/environment.rb'
+require_relative './api/suspend.rb'

data/lib/fatty/callback_environment.rb

@@ -29,6 +29,7 @@ module Fatty
     include AlertApi
     include KeytestApi
     include EnvironmentApi
+    include SuspendApi
 
     attr_reader :label, :payload, :commands, :terminal, :progress
 

data/lib/fatty/config_files/themes/capuchin_monk.yml

@@ -25,20 +25,16 @@ region:
   bg: "#c98a4a"
 
 good:
-  fg: "#a9b665"
-  bg: "#24160f"
+  fg: "#22a037"
 
 info:
-  fg: "#e8d8b8"
-  bg: "#24160f"
+  fg: "#468fd8"
 
 warn:
-  fg: "#24160f"
-  bg: "#d8a657"
+  fg: "#a88724"
 
 error:
-  fg: "#f5e6c8"
-  bg: "#9d3f35"
+  fg: "#de6363"
 
 pager_status:
   fg: "#24160f"

data/lib/fatty/config_files/themes/catppuccin_latte.yml

@@ -25,20 +25,16 @@ region:
   bg: "#1e66f5"
 
 good:
-  fg: "#40a02b"
-  bg: "#eff1f5"
+  fg: "#197628"
 
 info:
-  fg: "#4c4f69"
-  bg: "#eff1f5"
+  fg: "#2569ad"
 
 warn:
-  fg: "#eff1f5"
-  bg: "#df8e1d"
+  fg: "#7a621a"
 
 error:
-  fg: "#eff1f5"
-  bg: "#d20f39"
+  fg: "#c22929"
 
 pager_status:
   fg: "#eff1f5"

data/lib/fatty/config_files/themes/catppuccin_mocha.yml

@@ -25,20 +25,16 @@ region:
   bg: "#89b4fa"
 
 good:
-  fg: "#a6e3a1"
-  bg: "#1e1e2e"
+  fg: "#23a438"
 
 info:
-  fg: "#cdd6f4"
-  bg: "#1e1e2e"
+  fg: "#4e94da"
 
 warn:
-  fg: "#1e1e2e"
-  bg: "#f9e2af"
+  fg: "#ad8b25"
 
 error:
-  fg: "#1e1e2e"
-  bg: "#f38ba8"
+  fg: "#e06c6c"
 
 pager_status:
   fg: "#1e1e2e"

data/lib/fatty/config_files/themes/cyberpunk.yml

@@ -25,20 +25,16 @@ region:
   bg: "#00d7ff"
 
 good:
-  fg: "#00ff5f"
-  bg: "#000000"
+  fg: "#1f9333"
 
 info:
-  fg: "#00d7ff"
-  bg: "#000000"
+  fg: "#2d80d2"
 
 warn:
-  fg: "#000000"
-  bg: "#ffff00"
+  fg: "#977a20"
 
 error:
-  fg: "#ffffff"
-  bg: "#ff005f"
+  fg: "#d94a4a"
 
 pager_status:
   fg: "#000000"