ruby_everywhere 0.4.0 → 0.6.0

data/lib/everywhere/desktop_assets.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Everywhere
+  # Compiles an app's native/desktop/assets/ tree into the flat assets/ folder
+  # the desktop shell reads at runtime — Resources/assets/ inside a packaged
+  # .app, or the source tree itself under `every dev` (NATIVE_ASSETS_DIR).
+  #
+  # Unlike iOS and Android there is no platform resource format to generate:
+  # macOS has no catalog for a Tauri bundle's loose resources, so "compiling"
+  # here means validating the names and copying. The filenames stay exactly as
+  # written, because the shell resolves variants itself (see assets_dir /
+  # asset_path in the shell's main.rs) — it is the one consumer, and it can read
+  # a suffix as cheaply as we can rewrite one.
+  #
+  # Filenames are the whole API, matching AssetCatalog: <name>[@2x|@3x][~dark].<ext>.
+  # Sub-directories organise the tree but do NOT namespace it — names are global,
+  # so assets/branding/logo.png is still "logo". That also means the destination
+  # can be flat, which is what keeps the Rust side a plain directory read.
+  #
+  # These assets are for the SHELL, not for your pages: window and tray icons,
+  # splash artwork, and anything extension Rust loads. Images your HTML
+  # references should keep coming from the asset pipeline, which already
+  # fingerprints and serves them.
+  module DesktopAssets
+    # What the shell can actually decode. Deliberately narrower than
+    # AssetCatalog's: these are handed to tauri::image::Image or read by
+    # extension Rust, and neither speaks PDF or SVG.
+    RASTER = %w[.png .jpg .jpeg].freeze
+    # Windows tray icons are conventionally .ico; it's passed through untouched
+    # for an extension that wants to hand one to the platform directly.
+    PASSTHROUGH = %w[.ico].freeze
+    EXTENSIONS = (RASTER + PASSTHROUGH).freeze
+    VECTOR = %w[.pdf .svg].freeze
+
+    # Names the shell gives meaning to on its own. Not reserved — providing one
+    # is exactly how you override a default — but worth naming here so the list
+    # has one home.
+    #
+    #   tray           the menu-bar / system-tray icon, drawn as-is
+    #   tray-template  same, but declared a macOS template image: black + alpha,
+    #                  recoloured by the system so it stays legible in a light
+    #                  menu bar, a dark one, and under a highlight. Wins over
+    #                  `tray` when both are present.
+    SHELL_NAMES = %w[tray tray-template].freeze
+
+    VALID_NAME = /\A[A-Za-z0-9_][A-Za-z0-9_.-]*\z/
+
+    class << self
+      # Copy every image under `source` into `dest`. Returns [names, errors];
+      # nothing is written when errors is non-empty, so a broken assets/ tree
+      # can't half-stamp a bundle.
+      #
+      # `dest` is regenerated wholesale — this module owns that directory, and
+      # an asset deleted from the app repo has to stop shipping.
+      def write!(source, dest)
+        files, errors = plan(source)
+        return [[], errors] unless errors.empty?
+
+        FileUtils.rm_rf(dest)
+        return [[], []] if files.empty?
+
+        FileUtils.mkdir_p(dest)
+        files.each { |file| FileUtils.cp(file[:path], File.join(dest, File.basename(file[:path]))) }
+
+        [files.map { |file| file[:name] }.uniq.sort, []]
+      end
+
+      private
+
+      # Errors are collected rather than raised so one `every build` reports
+      # every problem in the tree, not just the first.
+      def plan(source)
+        return [[], []] unless File.directory?(source)
+
+        errors = []
+        found = Dir.glob(File.join(source, "**", "*"))
+                   .select { |path| File.file?(path) && !File.basename(path).start_with?(".") }
+                   .sort
+        images, other = found.partition { |path| EXTENSIONS.include?(File.extname(path).downcase) }
+
+        other.each { |path| errors << unsupported_error(path, source) }
+        files = images.filter_map { |path| variant(path, source, errors) }
+
+        files.group_by { |file| file[:name] }.each do |name, group|
+          dirs = group.map { |file| file[:dir] }.uniq
+          if dirs.length > 1
+            errors << "#{name}: same asset name in #{dirs.map { |dir| label(dir) }.join(" and ")} — " \
+                      "names are global (the shell reads one flat folder), so rename one"
+          end
+          group.group_by { |file| [file[:scale], file[:dark]] }.each_value do |clash|
+            next if clash.length < 2
+
+            errors << "#{name}: #{clash.map { |file| file[:relative] }.join(" and ")} both claim the same slot"
+          end
+        end
+
+        [files, errors]
+      end
+
+      # A vector gets its own message: "unsupported image type" reads like the
+      # file is broken, when the real answer is a one-line export.
+      def unsupported_error(path, source)
+        relative = relative(path, source)
+        if VECTOR.include?(File.extname(path).downcase)
+          "#{relative}: the desktop shell can't rasterize vectors — export a PNG " \
+            "(at @2x, so it stays sharp on a Retina display)"
+        else
+          "#{relative}: unsupported image type — use #{EXTENSIONS.join(", ")}"
+        end
+      end
+
+      def variant(path, source, errors)
+        relative = relative(path, source)
+        name, scale, dark = parse(File.basename(path, File.extname(path)))
+
+        unless name.match?(VALID_NAME)
+          errors << "#{relative}: #{name.inspect} isn't a usable asset name — use letters, digits, _, - and ."
+          return nil
+        end
+
+        { name: name, dir: File.dirname(relative), scale: scale, dark: dark, path: path, relative: relative }
+      end
+
+      # Trailing @2x/@3x and ~dark markers, in either order, off the stem.
+      # Identical to AssetCatalog#parse on purpose: one filename convention
+      # across all three platforms is the whole point of the suffix API.
+      def parse(base)
+        name = base.dup
+        scale = nil
+        dark = false
+        loop do
+          if name.sub!(/~dark\z/, "")
+            dark = true
+          elsif name.sub!(/@([23])x\z/, "")
+            scale = "#{Regexp.last_match(1)}x"
+          else
+            break
+          end
+        end
+        [name, scale, dark]
+      end
+
+      def label(dir) = dir == "." ? "assets/" : "assets/#{dir}/"
+
+      def relative(path, source) = path.delete_prefix("#{source}/")
+    end
+  end
+end

data/lib/everywhere/dock/footer.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "../ui"
+
+module Everywhere
+  class Dock
+    # Renders the pinned footer. PURE: state in, array of strings out. No IO, no
+    # clock, no terminal — every layout decision here is testable with plain
+    # string assertions.
+    #
+    # Composition rule: build every segment as PLAIN text, measure it, truncate,
+    # and only then paint. Measuring or cutting a string that already contains
+    # SGR codes is how you end up slicing through "\e[32" and corrupting the
+    # terminal, and it makes the width math quietly wrong under NO_COLOR.
+    module Footer
+      # Every state gets its own glyph, so the footer stays fully legible with
+      # NO_COLOR — color is redundant reinforcement, never the only signal.
+      # A nil glyph means "use the spinner frame".
+      GLYPHS = {
+        idle: ["○", :gray],
+        booting: [nil, :cyan],
+        building: [nil, :cyan],
+        installing: [nil, :cyan],
+        running: ["●", :green],
+        failed: ["✗", :red],
+        stopped: ["!", :yellow]
+      }.freeze
+
+      GAP = "   "
+      KEY_GAP = " · "
+      ELLIPSIS = "…"
+
+      module_function
+
+      # targets: Array<State::Target>. elapsed: ->(target) { seconds }.
+      # keys: Array<[key, description]>, or nil to omit the keymap row.
+      def render(targets, cols:, keys: nil, frame: 0, elapsed: nil, rule: true)
+        cols = [cols.to_i, 1].max
+        lines = []
+        lines << UI.gray("─" * cols) if rule
+        lines << status_row(targets, cols, frame, elapsed)
+        lines << keys_row(keys, cols) if keys
+        lines
+      end
+
+      # --- status row ----------------------------------------------------------
+
+      # Three levels of degradation, tried in order until one fits: everything;
+      # details only on what's actually working; then drop idle targets. A hard
+      # truncation is the last resort.
+      def status_row(targets, cols, frame, elapsed)
+        segments = targets.map { |t| segment(t, frame, elapsed) }
+
+        candidates = [
+          segments,
+          segments.map { |s| s[:busy] ? s : s.merge(detail: nil) },
+          segments.select { |s| s[:state] != :idle }
+        ]
+        chosen = candidates.find { |set| plain_width(set) <= cols } || candidates.last
+        fit(chosen.map { |s| [plain(s), painted(s)] }, cols)
+      end
+
+      def segment(target, frame, elapsed)
+        glyph, color = GLYPHS.fetch(target.state, GLYPHS[:idle])
+        { glyph: glyph || UI::FRAMES[frame % UI::FRAMES.size],
+          color: color,
+          label: target.label,
+          detail: detail_for(target, elapsed),
+          state: target.state,
+          busy: target.busy? }
+      end
+
+      # Busy targets carry a running clock — the whole reason the dock exists is
+      # that a cold Gradle build looks identical to a hung one without it.
+      def detail_for(target, elapsed)
+        if target.busy?
+          seconds = elapsed&.call(target)
+          [target.state == :building ? nil : target.state.to_s,
+           (UI.elapsed(seconds) if seconds)].compact.join(" ")
+        else
+          target.detail
+        end
+      end
+
+      def plain(seg)
+        [seg[:glyph], seg[:label], presence(seg[:detail])].compact.join(" ")
+      end
+
+      def painted(seg)
+        tint = UI.method(seg[:color])
+        parts = [tint.call(seg[:glyph]), seg[:state] == :idle ? UI.gray(seg[:label]) : seg[:label]]
+        parts << UI.dim(seg[:detail]) if presence(seg[:detail])
+        parts.join(" ")
+      end
+
+      def plain_width(segments) = segments.sum { |s| plain(s).length } + (GAP.length * [segments.size - 1, 0].max)
+
+      # --- keys row ------------------------------------------------------------
+
+      # Named keys with dot separators, then named keys packed tighter, then
+      # bare letters. Measured on the plain text and painted only once a tier
+      # fits, so the width math can't be thrown off by SGR codes.
+      def keys_row(keys, cols)
+        tiers = [
+          [:named, KEY_GAP],
+          [:named, "  "],
+          [:bare,  " "]
+        ]
+        tiers.each do |style, gap|
+          plain = "⌨ #{keys.map { |key, desc| plain_key(key, desc, style) }.join(gap)}"
+          next unless plain.length <= cols
+
+          painted = keys.map { |key, desc| paint_key(key, desc, style) }.join(gap == KEY_GAP ? UI.gray(gap) : gap)
+          return "#{UI.cyan("⌨")} #{painted}"
+        end
+        ""
+      end
+
+      def plain_key(key, desc, style) = style == :bare ? key : "#{key} #{desc}"
+
+      def paint_key(key, desc, style)
+        style == :bare ? UI.bold(key) : "#{UI.bold(key)} #{UI.dim(desc)}"
+      end
+
+      # --- fitting -------------------------------------------------------------
+
+      # pairs: [[plain, painted], …]. Emit painted segments while they fit,
+      # measuring only the plain text; cut the first one that doesn't.
+      def fit(pairs, cols)
+        out = +""
+        width = 0
+        pairs.each_with_index do |(text, colored), index|
+          gap = index.zero? ? "" : GAP
+          if width + gap.length + text.length <= cols
+            out << gap << colored
+            width += gap.length + text.length
+            next
+          end
+
+          room = cols - width - gap.length - ELLIPSIS.length
+          out << gap << text[0, room] << ELLIPSIS if room.positive?
+          break
+        end
+        out
+      end
+
+      def presence(str) = str.nil? || str.empty? ? nil : str
+    end
+  end
+end

data/lib/everywhere/dock/screen.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Everywhere
+  class Dock
+    # Emits the escape sequences that keep the footer pinned to the bottom.
+    #
+    # THE MECHANIC, and why it isn't the obvious one:
+    #
+    # The tempting approach is DECSTBM — set a scroll region (ESC[1;Nr) that
+    # excludes the last few rows and let the terminal itself keep output off
+    # them. It works, and it even confines child processes writing straight to
+    # the fd. It was rejected for two reasons:
+    #
+    #   1. It destroys scrollback. tmux only copies scrolled-out rows into its
+    #      history when the scroll region is the full screen
+    #      (grid_view_scroll_region_up checks rupper == 0 && rlower == sy - 1);
+    #      screen and, as far as we can tell, iTerm2 behave the same way. Losing
+    #      the ability to scroll up and read a Rails backtrace is a far worse
+    #      regression than the one the dock is fixing.
+    #   2. Its failure mode is terrible. If the CLI is SIGKILLed before it can
+    #      emit ESC[r, the user's terminal keeps a dead band at the bottom until
+    #      they run `reset`.
+    #
+    # So instead we own every byte (the dev server and shells are relayed
+    # through us, not inherited) and repaint: erase the footer rows, write the
+    # new content — which scrolls normally, preserving scrollback everywhere —
+    # then draw the footer again. This is what indicatif, Ink, docker compose
+    # and cargo all do. Worst-case failure is one stale line on screen.
+    #
+    # Everything is emitted as a SINGLE write per frame. Byte interleaving
+    # between processes happens between write(2) calls, not inside one.
+    class Screen
+      ERASE_ROW = "\r\e[2K"        # clear this row, cursor back to column 1
+      UP_ROW    = "\e[1A\e[2K"     # up one row and clear it
+      HIDE      = "\e[?25l"
+      SHOW      = "\e[?25h"
+
+      DEFAULT_SIZE = [24, 80].freeze
+
+      def initialize(io:, size: nil)
+        @io = io
+        @size = size
+        @drawn = 0
+        @open = false
+      end
+
+      def open
+        return if @open
+
+        @open = true
+        @sync = @io.sync
+        @io.sync = true
+        @io.write(HIDE)
+      end
+
+      # content: text to land above the footer (must end in a newline, or be
+      # empty). footer: the rows to pin.
+      def frame(content, footer)
+        return unless @open
+
+        out = +""
+        out << erase
+        out << content
+        out << footer.join("\n")
+        @drawn = footer.length
+        @io.write(out)
+      end
+
+      # Wipe the footer without redrawing it — for anything that has to write
+      # outside our frame discipline (stderr, an interactive child).
+      def clear
+        return unless @open && @drawn.positive?
+
+        @io.write(erase)
+        @drawn = 0
+      end
+
+      def close
+        return unless @open
+
+        @io.write("#{erase}#{SHOW}")
+        @drawn = 0
+        @open = false
+        @io.sync = @sync
+      end
+
+      # Rows and columns, re-read on every resize. IO#winsize is a plain
+      # TIOCGWINSZ ioctl — it does not touch termios, so it is safe alongside
+      # the `stty -icanon -echo` the key loop sets.
+      def size
+        return @size if @size
+
+        require "io/console"
+        @io.winsize
+      rescue StandardError
+        env = [ENV["LINES"].to_i, ENV["COLUMNS"].to_i]
+        env.all?(&:positive?) ? env : DEFAULT_SIZE
+      end
+
+      def rows = size[0]
+      def cols = size[1]
+
+      private
+
+      # Cursor sits at the end of the last footer row; walk back up to column 1
+      # of the first, clearing as we go.
+      def erase
+        return "" if @drawn.zero?
+
+        ERASE_ROW + (UP_ROW * (@drawn - 1))
+      end
+    end
+  end
+end

data/lib/everywhere/dock/state.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Everywhere
+  class Dock
+    # What the dock knows about each thing `every dev` is running. Pure data
+    # with an injected clock, so elapsed times are deterministic under test.
+    class State
+      # Ordered so the dock reads left-to-right the way the session starts up.
+      ORDER = %i[web desktop ios android].freeze
+
+      LABELS = {
+        web: "web",
+        desktop: "desktop",
+        ios: "iOS",
+        android: "Android"
+      }.freeze
+
+      # States that are "in flight" — they get a spinner and a running clock.
+      BUSY = %i[booting building installing].freeze
+
+      Target = Struct.new(:key, :label, :state, :detail, :since, keyword_init: true) do
+        def busy? = BUSY.include?(state)
+      end
+
+      def initialize(keys, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        @clock = clock
+        @lock = Mutex.new
+        ordered = ORDER & keys
+        @targets = ordered.to_h do |key|
+          [key, Target.new(key: key, label: LABELS.fetch(key, key.to_s), state: :idle, since: clock.call)]
+        end
+      end
+
+      def set(key, state, detail: nil)
+        @lock.synchronize do
+          target = @targets[key] or return nil
+          # Keep `since` when nothing actually changed, so a repeated
+          # set(:ios, :building) from a retry doesn't reset the elapsed clock.
+          target.since = @clock.call unless target.state == state
+          target.state = state
+          target.detail = detail
+          target
+        end
+      end
+
+      def detail(key, text)
+        @lock.synchronize { @targets[key]&.detail = text }
+      end
+
+      def [](key) = @lock.synchronize { @targets[key] }
+
+      def targets = @lock.synchronize { @targets.values.map(&:dup) }
+
+      def busy? = @lock.synchronize { @targets.each_value.any?(&:busy?) }
+
+      def elapsed(target) = @clock.call - target.since
+    end
+  end
+end