fatty 0.99.0

data/lib/fatty/themes/loader.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Fatty
+  module Themes
+    module Loader
+      RESERVED_KEYS = %i[name inherit markdown].freeze
+
+      ROLE_ALIASES = {
+        status_good: :good,
+        status_info: :info,
+        status_warn: :warn,
+        status_error: :error,
+
+        search: :search_input,
+        search_highlight: :match_current,
+        search_highlight_secondary: :match_other,
+      }.freeze
+
+      def self.load_dir(path, registry:)
+        Dir.glob(File.join(path.to_s, "*.{yml,yaml}")).sort.each do |file|
+          load_file(file, registry: registry)
+        end
+        registry
+      end
+
+      def self.load_file(path, registry:)
+        data = YAML.safe_load_file(
+          path,
+          permitted_classes: [Symbol],
+          aliases: false,
+          symbolize_names: true,
+        )
+
+        unless data.is_a?(Hash)
+          registry.warnings << "Theme file did not contain a mapping: #{path}"
+          return
+        end
+
+        registry.add(normalize(data), source: path)
+      rescue Psych::Exception => e
+        message = "Theme YAML error in #{path}: #{e.class}: #{e.message}"
+        registry.warnings << message
+        Fatty.warn(message, tag: :theme) if Fatty.respond_to?(:warn)
+        nil
+      rescue StandardError => e
+        message = "Theme load error in #{path}: #{e.class}: #{e.message}"
+        registry.warnings << message
+        Fatty.warn(message, tag: :theme) if Fatty.respond_to?(:warn)
+        nil
+      end
+
+      def self.normalize(data)
+        out = {
+          name: normalize_optional_symbol(data[:name]),
+          inherit: normalize_optional_symbol(data[:inherit]),
+          roles: {},
+        }
+
+        data.each do |key, value|
+          k = key.to_sym
+          next if RESERVED_KEYS.include?(k)
+
+          out[:roles][normalize_role_name(k)] = normalize_spec(value)
+        end
+
+        normalize_markdown_roles(data[:markdown]).each do |role, spec|
+          out[:roles][role] ||= spec
+        end
+
+        out
+      end
+
+      def self.normalize_role_name(name)
+        sym = name.to_sym
+        ROLE_ALIASES.fetch(sym, sym)
+      end
+
+      def self.normalize_markdown_roles(value)
+        return {} unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, spec), roles|
+          role = :"markdown_#{normalize_role_name(key)}"
+          roles[role] = normalize_spec(spec)
+        end
+      end
+
+      def self.normalize_spec(spec_hash)
+        return {} unless spec_hash.is_a?(Hash)
+
+        normalized =
+          spec_hash.each_with_object({}) do |(k, v), h|
+            key = k.to_sym
+            h[key] =
+              case key
+              when :attr
+                v
+              when :attrs
+                normalize_attrs(v)
+              when :border, :corners
+                normalize_optional_symbol(v)
+              else
+                v
+              end
+          end
+
+        if normalized.key?(:attr)
+          attr = normalized.delete(:attr)
+          attrs = normalized.key?(:attrs) ? normalized[:attrs] : []
+          normalized[:attrs] = normalize_attrs(attrs + Array(attr))
+        end
+
+        normalized
+      end
+
+      def self.normalize_attrs(value)
+        Array(value).map(&:to_sym)
+      end
+
+      def self.normalize_optional_symbol(value)
+        return if value.nil?
+
+        text = value.to_s.strip
+        return if text.empty?
+
+        case text.downcase
+        when "null", "nil", "none"
+          nil
+        else
+          text.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/fatty/themes/manager.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Themes
+    module Manager
+      FALLBACK_THEME = :terminal
+
+      def self.registry
+        @registry ||=
+          begin
+            reg = Registry.new
+            Loader.load_dir(Fatty::Config.user_themes_dir, registry: reg)
+            reg
+          end
+      end
+
+      def self.load!
+        registry.clear
+        Loader.load_dir(Fatty::Config.user_themes_dir, registry: registry)
+        registry
+      end
+
+      def self.theme_names
+        registry.names.sort
+      end
+
+      def self.current
+        return @current if @current
+
+        theme = Fatty::Config.config[:theme]
+
+        @current =
+          if theme && !theme.to_s.strip.empty?
+            theme.to_sym
+          else
+            FALLBACK_THEME
+          end
+      end
+
+      def self.set(theme)
+        t = theme.to_sym
+        if theme_names.include?(t)
+          @current = t
+        else
+          Fatty.warn("Unknown theme: #{theme}, falling back to #{FALLBACK_THEME}", tag: :theme)
+          @current = FALLBACK_THEME
+        end
+      end
+
+      def self.cycle
+        names = theme_names
+        return set(FALLBACK_THEME) if names.empty?
+
+        idx = names.index(current) || 0
+        set(names[(idx + 1) % names.length])
+      end
+
+      def self.fetch(name)
+        Resolver.resolve(registry, name)
+      end
+
+      def self.roles(name = current)
+        fetch(name)[:roles]
+      end
+
+      def self.markdown(name = current)
+        fetch(name)[:markdown]
+      end
+    end
+  end
+end

data/lib/fatty/themes/registry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Themes
+    class Registry
+      attr_reader :warnings
+
+      def initialize
+        @defs = {}
+        @warnings = []
+      end
+
+      def clear
+        @defs.clear
+        @warnings.clear
+        nil
+      end
+
+      def add(defn, source: nil)
+        name = normalize_name(defn[:name])
+        if name
+          @defs[name] = defn.merge(name: name, source: source)
+        else
+          warn("Theme missing name#{source_suffix(source)}")
+        end
+        nil
+      end
+
+      def names
+        @defs.keys
+      end
+
+      def include?(name)
+        @defs.key?(normalize_name(name))
+      end
+
+      def fetch(name)
+        @defs[normalize_name(name)]
+      end
+
+      def each(&block)
+        @defs.each_value(&block)
+      end
+
+      private
+
+      def normalize_name(name)
+        return if name.nil?
+
+        text = name.to_s.strip
+        text.empty? ? nil : text.to_sym
+      end
+
+      def warn(message)
+        @warnings << message
+        Fatty.warn(message, tag: :theme) if Fatty.respond_to?(:warn)
+      end
+
+      def source_suffix(source)
+        source ? " in #{source}" : ""
+      end
+    end
+  end
+end

data/lib/fatty/themes/resolver.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Themes
+    class ResolveError < StandardError; end
+    class MissingThemeError < ResolveError; end
+    class InheritanceCycleError < ResolveError; end
+
+    # The Resolver module is responsible for transforming a raw theme loaded
+    # by the Loader into a fully-resolved "theme_spec".
+    #
+    # Resolution includes:
+    # - applying inheritance between themes
+    # - applying inheritance between roles
+    # - filling in default attributes
+    # - synthesizing "composite" roles used by the alert panel
+    #
+    # Composite alert roles (e.g., :alert_info, :alert_warn, etc.) combine the
+    # background and structural properties of the :alert role with the foreground
+    # and attributes of the semantic roles (:good, :info, :warn, :error).
+    #
+    # The result of resolution is a Hash keyed by role names, where each value
+    # is a symbolic color specification (typically using color names and attrs).
+    # We refer to this Hash as a "theme_spec".
+    #
+    # A theme_spec is not directly renderable. Before rendering, it must be
+    # "compiled" into a palette by Fatty::Colors::Palette.apply!. The palette
+    # maps each role to concrete rendering data (RGB values for truecolor or
+    # Curses color pairs, along with attributes).
+    #
+    # Renderer classes consume only the compiled palette and never operate
+    # directly on the theme_spec.
+    # module Resolver
+    module Resolver
+      DEFAULT_ROLE_SPECS = {
+        region: { attrs: [:reverse] },
+        cursor: { attrs: [:reverse] },
+        input_suggestion: { attrs: [:dim] },
+        pager_status: { attrs: [:reverse] },
+        search_input: { attrs: [:reverse] },
+        match_current: { attrs: [:reverse] },
+        match_other: { attrs: [:underline] },
+        popup_counts: { attrs: [:bold] },
+        alert: { attrs: [:bold] },
+        markdown_table_cell: {},
+        markdown_underline: { attrs: [:underline] },
+        markdown_hrule: { attrs: [:dim] },
+      }.freeze
+
+      ROLE_PARENTS = {
+        input: :output,
+        input_suggestion: :input,
+
+        region: :output,
+        cursor: :input,
+
+        popup: :output,
+        popup_frame: :popup,
+        popup_input: :input,
+        popup_selection: :region,
+        popup_counts: :popup,
+
+        search_input: :popup,
+
+        match_current: :region,
+        match_other: :region,
+
+        status: :output,
+        alert: :output,
+        info: :output,
+        good: :info,
+        warn: :info,
+        error: :warn,
+
+        pager_status: :status,
+
+        markdown_h1: :output,
+        markdown_h2: :markdown_h1,
+        markdown_h3: :markdown_h2,
+
+        markdown_code: :output,
+        markdown_code_gutter: :markdown_code,
+
+        markdown_strong: :output,
+        markdown_emphasis: :output,
+
+        markdown_link: :output,
+        markdown_url: :markdown_link,
+
+        markdown_quote_gutter: :output,
+        markdown_highlight: :output,
+        markdown_table_header: :markdown_strong,
+        markdown_table_cell: :output,
+        markdown_underline: :output,
+        markdown_hrule: :output,
+      }.freeze
+
+      def self.empty_theme
+        {
+          name: nil,
+          inherit: nil,
+          roles: {},
+          source: nil,
+        }
+      end
+
+      def self.resolve(registry, name)
+        raw = merge_theme_chain(registry, name.to_sym, stack: [])
+        raw[:roles] = resolve_role_inheritance(raw[:roles])
+        raw[:roles] = add_composite_roles(raw[:roles])
+        raw[:name] = name.to_sym
+        raw
+      end
+
+      def self.merge_theme_chain(registry, name, stack:)
+        defn = registry.fetch(name)
+        raise MissingThemeError, "Theme not found: #{name}" unless defn
+
+        if stack.include?(name)
+          cycle = (stack + [name]).join(" -> ")
+          raise InheritanceCycleError, "Theme inheritance cycle: #{cycle}"
+        end
+
+        parent =
+          if defn[:inherit]
+            merge_theme_chain(registry, defn[:inherit], stack: stack + [name])
+          else
+            empty_theme
+          end
+
+        merged = deep_merge(parent, defn)
+        merged[:name] = name
+        merged[:inherit] = defn[:inherit]
+        merged[:source] = defn[:source]
+        merged
+      end
+
+      def self.resolve_role_inheritance(roles)
+        resolved = {}
+        names = (
+          ROLE_PARENTS.keys +
+          ROLE_PARENTS.values +
+          DEFAULT_ROLE_SPECS.keys +
+          roles.keys
+        ).compact.uniq
+
+        names.each do |name|
+          resolve_role(name, roles, resolved, stack: [])
+        end
+
+        resolved
+      end
+
+      def self.resolve_role(name, roles, resolved, stack:)
+        return resolved[name] if resolved.key?(name)
+
+        if stack.include?(name)
+          raise InheritanceCycleError, "Role inheritance cycle: #{(stack + [name]).join(' -> ')}"
+        end
+
+        spec = roles[name] || DEFAULT_ROLE_SPECS.fetch(name, {})
+        parent_name =
+          if spec.key?(:inherit)
+            spec[:inherit]&.to_sym
+          else
+            ROLE_PARENTS[name]
+          end
+
+        parent_spec =
+          if parent_name
+            resolve_role(parent_name, roles, resolved, stack: stack + [name])
+          else
+            {}
+          end
+
+        resolved[name] = deep_merge_hash(parent_spec, spec.reject { |k, _| k == :inherit })
+      end
+
+      def self.deep_merge(parent, child)
+        out = parent.dup
+
+        out[:roles] = deep_merge_hash(parent[:roles] || {}, child[:roles] || {})
+
+        child.each do |key, value|
+          next if key == :roles
+
+          out[key] = value
+        end
+
+        out
+      end
+
+      def self.deep_merge_hash(parent, child)
+        parent.merge(child) do |_key, old_value, new_value|
+          if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+            deep_merge_hash(old_value, new_value)
+          else
+            new_value
+          end
+        end
+      end
+
+      def self.add_composite_roles(roles)
+        roles = roles.dup
+
+        roles[:alert_info]  = composite_role(roles[:alert] || {}, roles[:info]  || {})
+        roles[:alert_good]  = composite_role(roles[:alert] || {}, roles[:good]  || {})
+        roles[:alert_warn]  = composite_role(roles[:alert] || {}, roles[:warn]  || {})
+        roles[:alert_error] = composite_role(roles[:alert] || {}, roles[:error] || {})
+        roles
+      end
+      private_class_method :add_composite_roles
+
+      def self.composite_role(base, accent)
+        {
+          fg: accent[:fg] || accent["fg"] || base[:fg] || base["fg"],
+          bg: base[:bg] || base["bg"] || accent[:bg] || accent["bg"],
+          attrs: accent[:attrs] || accent["attrs"] || base[:attrs] || base["attrs"],
+        }.compact
+      end
+      private_class_method :composite_role
+    end
+  end
+end

data/lib/fatty/themes/themes.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Fatty
+  module Colors
+    module Themes
+      # Theme values may be:
+      # - ANSI names (e.g., "yellow", "bright_white")
+      # - Aliases supported by Fatty::Color (e.g., "navy", "dark_blue")
+      # - Integers 0..255
+      # - Hex strings "#RRGGBB"
+      # - X11 color names (if present in your bundled rgb.txt)
+      #
+      # Roles are intentionally scoped (popup_selection vs region, etc.)
+      THEMES = {
+        wordperfect: {
+          output: { fg: "white", bg: "navy" },
+          input: { fg: "white", bg: "navy" },
+          input_suggestion: { fg: "lightgray", bg: "navy" },
+          cursor: { fg: "white", bg: "red" },
+
+          region: { fg: "navy", bg: "yellow" },
+
+          status_good: { fg: "green", bg: "navy" },
+          status_info: { fg: "white", bg: "navy" },
+          status_warn: { fg: "black", bg: "magenta" },
+          status_error: { fg: "white", bg: "red" },
+
+          pager_status: { fg: "black", bg: "lightgreen" },
+
+          search_highlight: { fg: "black", bg: "red" },
+          search_highlight_secondary: { fg: "grey", bg: "pink" },
+          search: { fg: "black", bg: "cyan" },
+
+          popup: { fg: "white", bg: "navy" },
+          popup_selection: { fg: "navy",   bg: 'yellow' },
+          popup_input: { fg: "white",  bg: "dark_blue" },
+          popup_frame: { fg: "white",  bg: "navy" },
+          popup_counts: { fg: "navy",  bg: "white" },
+        },
+
+        nordic: {
+          output: { fg: "#d8dee9", bg: "#2e3440" },
+          input: { fg: "#eceff4", bg: "#3b4252" },
+          input_suggestion: { fg: "#81a1c1", bg: "#3b4252" },
+          cursor: { fg: "#2e3440", bg: "#88c0d0" },
+
+          region: { fg: "#2e3440", bg: "#88c0d0" },
+
+          status_good: { fg: "green", bg: "#2e3440" },
+          status_info: { fg: "#d8dee9", bg: "#2e3440" },
+          status_warn: { fg: "#2e3440", bg: "#ebcb8b" },
+          status_error: { fg: "#eceff4", bg: "#bf616a" },
+
+          pager_status: { fg: "black", bg: "lightgreen" },
+
+          search_highlight: { fg: "black", bg: "yellow" },
+          search_highlight_secondary: { fg: "black", bg: "lightgray" },
+          search: { fg: "black", bg: "cyan" },
+
+          popup: { fg: "#d8dee9", bg: "#3b4252" },
+          popup_selection: { fg: "#2e3440", bg: "#88c0d0" },
+          popup_input: { fg: "#eceff4", bg: "#434c5e" },
+          popup_frame: { fg: "#81a1c1", bg: "#3b4252" },
+          popup_counts: { fg: "#2e3440", bg: "white" },
+        },
+
+        solarized_dark: {
+          output: { fg: "#839496", bg: "#002b36" },
+          input: { fg: "#93a1a1", bg: "#073642" },
+          input_suggestion: { fg: "#657b83", bg: "#073642" },
+          cursor: { fg: "#002b36", bg: "#b58900" },
+
+          region: { fg: "#002b36", bg: "#b58900" },
+
+          status_good: { fg: "green", bg: "#002b36" },
+          status_info: { fg: "#839496", bg: "#002b36" },
+          status_warn: { fg: "#002b36", bg: "#cb4b16" },
+          status_error: { fg: "#fdf6e3", bg: "red" },
+
+          pager_status: { fg: "black", bg: "lightgreen" },
+
+          search_highlight: { fg: "black", bg: "yellow" },
+          search_highlight_secondary: { fg: "black", bg: "lightgray" },
+          search: { fg: "black", bg: "cyan" },
+
+          popup: { fg: "#839496", bg: "#073642" },
+          popup_selection: { fg: "#002b36", bg: "#b58900" },
+          popup_input: { fg: "#93a1a1", bg: "#002b36" },
+          popup_frame: { fg: "#268bd2", bg: "#073642" },
+          popup_counts: { fg: "#002b36", bg: "white" },
+        },
+
+        mono: {
+          output: { fg: "black", bg: "white" },
+          input: { fg: "white", bg: "black" },
+          input_suggestion: { fg: "gray", bg: "white" },
+          cursor: { fg: "black", bg: "white" },
+
+          region: { fg: "black", bg: "white" },
+
+          search_highlight: { fg: "black", bg: "yellow" },
+          search_highlight_secondary: { fg: "black", bg: "lightgray" },
+          search: { fg: "black", bg: "cyan" },
+
+          pager_status: { fg: "black", bg: "white" },
+
+          status_good: { fg: "green", bg: "white" },
+          status_info: { fg: "black", bg: "white" },
+          status_warn: { fg: "default", bg: "default" },
+          status_error: { fg: "default", bg: "default" },
+
+          popup: { fg: "black", bg: "white" },
+          popup_selection: { fg: "white", bg: "black" },
+          popup_input: { fg: "white", bg: "black" },
+          popup_frame: { fg: "black", bg: "white" },
+          popup_counts: { fg: "white", bg: "gray" },
+        },
+      }.freeze
+
+      def self.fetch(name)
+        return if name.nil?
+
+        THEMES[name.to_sym]
+      end
+
+      def self.names
+        THEMES.keys
+      end
+    end
+  end
+end

data/lib/fatty/themes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "themes/manager"
+require_relative "themes/loader"
+require_relative "themes/registry"
+require_relative "themes/resolver"

data/lib/fatty/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Fatty
+  VERSION = "0.99.0"
+end

data/lib/fatty/view/alert_view.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Fatty
+  class AlertView < Fatty::View
+    def initialize(id: "alert", z: 1_000, log: false)
+      super(id: id, z: z, log: log)
+    end
+
+    def draw(screen:, renderer:, terminal:, session:)
+      # session is AlertSession; it owns `current`
+      renderer.render_alert(session.current)
+    end
+  end
+end

data/lib/fatty/view/cursor_view.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fatty
+  class CursorView < Fatty::View
+    def draw(screen:, renderer:, terminal:, session:)
+      # When paging is active, the output pane owns the screen and the shell
+      # input cursor should be turned off. This also prevents the underlying
+      # ShellSession from overriding the cursor while a modal (e.g. SearchSession)
+      # is displayed over the pager/status line.
+      if session.respond_to?(:pager_active?) && session.pager_active?
+        ::Curses.curs_set(0)
+      else
+        ::Curses.curs_set(1)
+        renderer.restore_cursor(session.field)
+      end
+    end
+  end
+end

data/lib/fatty/view/input_view.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fatty
+  class InputView < Fatty::View
+    def draw(screen:, renderer:, terminal:, session:)
+      renderer.render_input_field(session.field)
+    end
+  end
+end

data/lib/fatty/view/output_view.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fatty
+  class OutputView < View
+    def draw(screen:, renderer:, terminal:, session:)
+      renderer.render_output(session.output, viewport: session.viewport)
+    end
+  end
+end