shellfie 0.1.1 → 1.0.0

data/lib/shellfie/font_resolver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class FontResolver
+    FONT_FILES = {
+      "Monaco" => "/System/Library/Fonts/Monaco.ttf",
+      "SF Mono" => "/System/Library/Fonts/SFNSMono.ttf",
+      "SF Mono Italic" => "/System/Library/Fonts/SFNSMonoItalic.ttf",
+      "Menlo" => "/System/Library/Fonts/Menlo.ttc",
+      "Courier" => "/System/Library/Fonts/Courier.ttc",
+      "Courier New" => "/System/Library/Fonts/Supplemental/Courier New.ttf",
+      "DejaVu-Sans-Mono" => "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+      "DejaVu Sans Mono" => "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
+    }.freeze
+
+    def initialize(command_provider)
+      @command_provider = command_provider
+    end
+
+    def resolve(font_config, italic:)
+      candidates = []
+      candidates << font_config[:italic_family] if italic
+      candidates << font_config[:family]
+      candidates << font_config[:fallback_family]
+      candidates << font_config[:emoji_family]
+      candidates << "Menlo"
+      candidates << "DejaVu-Sans-Mono"
+      candidates << "Courier"
+
+      candidates.compact.flat_map { |candidate| font_candidates(candidate.to_s) }
+                .find { |candidate| font_available?(candidate) }
+    end
+
+    private
+
+    def font_available?(font)
+      return true if File.exist?(font)
+      return true if available_fonts.include?(font)
+
+      false
+    end
+
+    def font_candidates(font)
+      [font, FONT_FILES[font]].compact
+    end
+
+    def available_fonts
+      @available_fonts ||= begin
+        command = @command_provider.call
+        if command.empty?
+          []
+        else
+          `#{command} -list font 2>/dev/null`.scan(/^\s*Font:\s+(.+)$/).flatten
+        end
+      end
+    end
+  end
+end

data/lib/shellfie/format_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class FormatResolver
+    class << self
+      def resolve(output_path, explicit:, default:)
+        return explicit if explicit
+        return default if output_path == "-"
+
+        extension = File.extname(output_path).delete_prefix(".")
+        extension.empty? ? default : extension
+      end
+    end
+  end
+end

data/lib/shellfie/gif_generator.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
 require "mini_magick"
+require "fileutils"
+require "tmpdir"
+require_relative "animation_frame_builder"
+require_relative "dependency_checker"
+require_relative "format_resolver"
+require_relative "gif_palette"
+require_relative "image_magick_command_builder"
+require_relative "output_writer"
+require_relative "render_chrome_cache"
 require_relative "renderer"
 
 module Shellfie
@@ -11,141 +20,128 @@ module Shellfie
       @config = config
       @renderer = Renderer.new(config)
       @theme = @renderer.theme
+      @frame_builder = AnimationFrameBuilder.new(config)
     end
 
-    def generate(output_path, scale: 1, shadow: true)
+    def generate(output_path, scale: 1, shadow: true, transparent: false, format: nil)
       check_dependencies!
 
-      frames = build_animation_frames
-      images = render_frames(frames, scale: scale, shadow: shadow)
-      combine_to_gif(images, output_path)
-      cleanup_temp_files(images)
-      output_path
+      images = []
+      chrome_cache = RenderChromeCache.new
+      begin
+        frames = build_animation_frames
+        validate_frame_limit!(frames)
+        warn_frame_count(frames)
+        images = render_frames(frames, scale: scale, shadow: shadow, transparent: transparent, chrome_cache: chrome_cache)
+        extension = FormatResolver.resolve(output_path, explicit: format, default: "gif")
+        OutputWriter.write(output_path, extension: extension) do |temporary_path|
+          combine_to_animation(images, temporary_path, format: extension)
+        end
+      ensure
+        cleanup_temp_files(images)
+        chrome_cache.cleanup
+      end
+    rescue MiniMagick::Error => e
+      raise RenderError.new("ImageMagick animation render failed: #{e.message}", category: :render)
     end
 
     private
 
     def check_dependencies!
-      result = `which magick 2>/dev/null || which convert 2>/dev/null`.strip
-      if result.empty?
-        raise DependencyError, <<~MSG
-          ImageMagick not found
-            → Please install ImageMagick: brew install imagemagick
-            → Or visit: https://imagemagick.org/script/download.php
-        MSG
-      end
+      DependencyChecker.configure_mini_magick!
+      DependencyChecker.ensure_imagemagick!
     end
 
     def build_animation_frames
-      frames = []
-      current_lines = []
-      animation_settings = config.animation
-
-      config.frames.each do |frame|
-        if frame.type
-          typing_frames = build_typing_frames(
-            current_lines.dup,
-            frame.prompt || "",
-            frame.type,
-            animation_settings[:typing_speed] || 80
-          )
-          frames.concat(typing_frames)
-          current_lines << { prompt: frame.prompt, command: frame.type }
-        end
-
-        if frame.output
-          frame.output.split("\n").each do |line|
-            current_lines << { output: line }
-          end
-          frames << { lines: build_display_lines(current_lines), delay: frame.delay || 100 }
-        end
-
-        if frame.delay && frame.delay > 0 && !frame.output
-          frames << { lines: build_display_lines(current_lines), delay: frame.delay }
-        end
-      end
-
-      frames
+      @frame_builder.build
     end
 
-    def build_typing_frames(base_lines, prompt, command, typing_speed)
-      frames = []
-      chars = command.chars
-
-      chars.each_with_index do |_char, i|
-        typed = command[0..i]
-        lines = base_lines.dup
-        lines << { prompt: prompt, command: typed, cursor: true }
-        frames << { lines: build_display_lines(lines), delay: typing_speed }
-      end
-
-      final_lines = base_lines.dup
-      final_lines << { prompt: prompt, command: command }
-      frames << { lines: build_display_lines(final_lines), delay: typing_speed }
-
-      frames
+    def cursor_text
+      @frame_builder.cursor_text
     end
 
-    def build_display_lines(lines_data)
-      lines_data.map do |line_data|
-        if line_data[:prompt]
-          text = "#{line_data[:prompt]}#{line_data[:command]}"
-          text += "█" if line_data[:cursor]
-          Line.new(prompt: text, command: nil, output: nil)
-        else
-          Line.new(prompt: nil, command: nil, output: line_data[:output])
-        end
-      end
-    end
-
-    def render_frames(frames, scale:, shadow:)
+    def render_frames(frames, scale:, shadow:, transparent:, chrome_cache:)
       temp_dir = Dir.mktmpdir("shellfie")
       images = []
 
       frames.each_with_index do |frame, idx|
-        frame_config = create_frame_config(frame[:lines])
-        renderer = Renderer.new(frame_config)
+        frame_config = create_frame_config(frame[:lines], window_overrides: frame[:window] || {})
+        renderer = Renderer.new(frame_config, chrome_cache: chrome_cache)
         output_path = File.join(temp_dir, "frame_#{format("%04d", idx)}.png")
-        renderer.render(output_path, scale: scale, shadow: shadow)
+        renderer.render(output_path, scale: scale, shadow: shadow, transparent: transparent)
         images << { path: output_path, delay: frame[:delay] }
       end
 
       images
     end
 
-    def create_frame_config(lines)
+    def create_frame_config(lines, window_overrides: {})
       Config.new(
         theme: config.theme,
+        window_theme: config.window_theme,
+        color_scheme: config.color_scheme,
+        colors: config.colors,
+        window_decoration: config.window_decoration,
         title: config.title,
-        window: config.window,
+        window: config.window.merge(window_overrides),
         font: config.font,
         lines: lines,
+        animation: config.animation,
+        cursor: config.cursor,
+        limits: config.limits,
         headless: config.headless
       )
     end
 
-    def combine_to_gif(images, output_path)
-      MiniMagick.convert do |convert|
-        convert.dispose "none"
+    def combine_to_animation(images, output_path, format:)
+      palette = GifPalette.new(config: config, theme: theme) if format == "gif"
+      ImageMagickCommandBuilder.convert do |convert|
+        convert.dispose "none" if format == "gif"
         convert.loop config.animation[:loop] ? 0 : 1
 
         images.each do |img|
-          delay = (img[:delay] / 10.0).round
-          convert.delay delay
+          convert.delay gif_delay(img[:delay])
           convert << img[:path]
         end
 
-        convert.dither "FloydSteinberg"
-        convert.colors 256
+        configure_animation_format(convert, format, images: images, palette: palette)
+        ImageMagickCommandBuilder.output(convert, output_path, format: format)
+      end
+    ensure
+      palette&.cleanup
+    end
+
+    def configure_animation_format(convert, format, images:, palette:)
+      case format
+      when "gif"
+        palette.apply(convert, images: images)
         convert.layers "optimize"
-        convert << output_path
+      when "webp"
+        convert.define "webp:lossless=true"
       end
     end
 
     def cleanup_temp_files(images)
-      images.each { |img| File.delete(img[:path]) if File.exist?(img[:path]) }
       temp_dir = File.dirname(images.first[:path]) if images.any?
-      Dir.rmdir(temp_dir) if temp_dir && Dir.exist?(temp_dir) && Dir.empty?(temp_dir)
+      FileUtils.rm_rf(temp_dir) if temp_dir && Dir.exist?(temp_dir)
+    end
+
+    def gif_delay(milliseconds)
+      [(milliseconds / 10.0).round, 1].max
     end
+
+    def warn_frame_count(frames)
+      max_frames = config.animation[:max_frames]
+      return unless max_frames && frames.size > max_frames
+
+      $stderr.puts "Warning: animation will generate #{frames.size} frames (max_frames is #{max_frames})"
+    end
+
+    def validate_frame_limit!(frames)
+      return if frames.size <= config.limits[:max_render_frames]
+
+      raise ResourceLimitError, "Animation would generate #{frames.size} frames (max #{config.limits[:max_render_frames]})"
+    end
+
   end
 end

data/lib/shellfie/gif_palette.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require_relative "image_magick_command_builder"
+
+module Shellfie
+  class GifPalette
+    def initialize(config:, theme:, command_builder: ImageMagickCommandBuilder)
+      @config = config
+      @theme = theme
+      @command_builder = command_builder
+      @temporary_files = []
+    end
+
+    def apply(convert, images: [])
+      convert.dither(dither_mode)
+
+      case @config.animation[:palette]
+      when "global"
+        apply_global_palette(convert, images)
+      when "theme"
+        apply_theme_palette(convert)
+      else
+        convert.colors 256
+      end
+    end
+
+    def cleanup
+      @temporary_files.each { |file| file.close! if file.respond_to?(:close!) }
+      @temporary_files.clear
+    end
+
+    private
+
+    def apply_global_palette(convert, images)
+      palette_path = build_global_palette(images)
+      convert.remap palette_path if palette_path
+      convert.colors 256
+    end
+
+    def apply_theme_palette(convert)
+      palette_path = build_theme_palette
+      convert.remap palette_path if palette_path
+      convert.colors(theme_color_count)
+    end
+
+    def build_global_palette(images)
+      return nil if images.empty?
+
+      path = palette_path
+      @command_builder.convert do |convert|
+        images.each { |image| convert << image[:path] }
+        convert.append
+        convert.colors 256
+        convert.unique_colors
+        @command_builder.output(convert, path, format: "png")
+      end
+      path
+    end
+
+    def build_theme_palette
+      colors = theme_colors.first(256)
+      return nil if colors.empty?
+
+      path = palette_path
+      @command_builder.convert do |convert|
+        @command_builder.canvas(convert, width: colors.size, height: 1, background: "xc:transparent")
+        colors.each_with_index do |color, index|
+          convert.fill color
+          @command_builder.point(convert, index, 0)
+        end
+        @command_builder.output(convert, path, format: "png")
+      end
+      path
+    end
+
+    def palette_path
+      file = Tempfile.new(["shellfie-palette", ".png"])
+      @temporary_files << file
+      file.close
+      file.path
+    end
+
+    def dither_mode
+      @config.animation[:dither] ? "FloydSteinberg" : "None"
+    end
+
+    def theme_color_count
+      [[theme_colors.size, 16].max, 256].min
+    end
+
+    def theme_colors
+      @theme_colors ||= [
+        @theme.colors.values,
+        @theme.button_colors,
+        @theme.window_decoration.dig(:shadow, :color),
+        @theme.window_decoration[:border]
+      ].flatten.compact.uniq
+    end
+  end
+end

data/lib/shellfie/headless_theme_registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "theme_data"
+
+module Shellfie
+  class HeadlessThemeRegistry
+    VARIANTS = {
+      "plain" => {
+        window_decoration: {
+          title_bar_height: 0,
+          corner_radius: 0,
+          button_size: 0,
+          button_spacing: 0
+        },
+        button_colors: [],
+        button_style: :none,
+        buttons_position: :left,
+        title_alignment: :left
+      }
+    }.freeze
+
+    class << self
+      def build(theme, variant: "plain")
+        settings = VARIANTS.fetch(variant)
+        ThemeData.new(
+          name: theme.name,
+          colors: theme.colors,
+          window_decoration: ThemeData.deep_merge(theme.window_decoration, settings[:window_decoration]),
+          button_colors: settings[:button_colors],
+          buttons_position: settings[:buttons_position],
+          button_style: settings[:button_style],
+          font: theme.font,
+          title_alignment: settings[:title_alignment]
+        )
+      end
+
+      def available_variants
+        VARIANTS.keys
+      end
+    end
+  end
+end

data/lib/shellfie/image_magick_command_builder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "mini_magick"
+
+module Shellfie
+  class ImageMagickCommandBuilder
+    class << self
+      def convert(&block)
+        MiniMagick.convert(&block)
+      end
+
+      def canvas(convert, width:, height:, background:)
+        convert.size "#{width}x#{height}"
+        convert << background
+      end
+
+      def output(convert, path, format: nil)
+        convert << output_path(path, format: format || File.extname(path).delete_prefix("."))
+      end
+
+      def output_path(path, format:)
+        format == "apng" ? "apng:#{path}" : path
+      end
+
+      def draw(convert, command)
+        convert.draw command
+      end
+
+      def rectangle(convert, x1, y1, x2, y2)
+        draw(convert, "rectangle #{x1},#{y1} #{x2},#{y2}")
+      end
+
+      def rectangles(convert, rectangles)
+        return if rectangles.empty?
+
+        draw(convert, rectangles.map { |rect| "rectangle #{rect[:x1]},#{rect[:y1]} #{rect[:x2]},#{rect[:y2]}" }.join(" "))
+      end
+
+      def round_rectangle(convert, x1, y1, x2, y2, radius)
+        draw(convert, "roundrectangle #{x1},#{y1} #{x2},#{y2} #{radius},#{radius}")
+      end
+
+      def line(convert, x1, y1, x2, y2)
+        draw(convert, "line #{x1},#{y1} #{x2},#{y2}")
+      end
+
+      def lines(convert, lines)
+        return if lines.empty?
+
+        draw(convert, lines.map { |line| "line #{line[:x1]},#{line[:y1]} #{line[:x2]},#{line[:y2]}" }.join(" "))
+      end
+
+      def circle(convert, center_x, center_y, radius)
+        draw(convert, "circle #{center_x},#{center_y} #{center_x + radius},#{center_y}")
+      end
+
+      def point(convert, x, y)
+        draw(convert, "point #{x},#{y}")
+      end
+
+      def region(convert, x:, y:, width:, height:)
+        convert.region "#{width}x#{height}+#{x}+#{y}"
+      end
+
+      def clear_region(convert)
+        convert << "+region"
+      end
+
+      def composite_over(convert)
+        convert.compose "over"
+        convert.composite
+      end
+    end
+  end
+end

data/lib/shellfie/line_layout.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "ansi_parser"
+require_relative "render_segment"
+require_relative "text_metrics"
+
+module Shellfie
+  class LineLayout
+    attr_reader :visible_count
+
+    def initialize(config)
+      @config = config
+    end
+
+    def prepare(lines, content_width:, font_size:, title_bar_height:, padding:, line_height:)
+      max_cells = [(content_width / (font_size * 0.6)).floor, 1].max
+      mode = @config.window[:wrap] ? "wrap" : @config.window[:overflow]
+      display_lines = lines.flat_map { |line| apply_overflow(line, max_cells, mode) }
+      line_limit = vertical_line_limit(title_bar_height, padding, line_height)
+      @visible_count = line_limit || display_lines.size
+      render_limit = render_line_limit(line_limit)
+      render_limit ? display_lines.last(render_limit) : display_lines
+    end
+
+    private
+
+    def apply_overflow(line, max_cells, mode)
+      return [line] if line[:segments].empty?
+
+      case mode
+      when "wrap"
+        wrap_line(line, max_cells)
+      when "scroll"
+        [line.merge(segments: scroll_segments(line[:segments], max_cells))]
+      else
+        [line.merge(segments: clip_segments(line[:segments], max_cells))]
+      end
+    end
+
+    def vertical_line_limit(title_bar_height, padding, line_height)
+      limits = [@config.window[:visible_lines], @config.window[:max_lines]].compact
+      if @config.window[:max_height]
+        available_height = @config.window[:max_height] - title_bar_height - padding * 2
+        limits << [(available_height / line_height).floor, 1].max
+      end
+
+      limits.empty? ? nil : limits.min
+    end
+
+    def render_line_limit(line_limit)
+      return nil unless line_limit
+
+      line_limit + (@config.window[:scroll_offset].to_f.positive? ? 1 : 0)
+    end
+
+    def wrap_line(line, max_cells)
+      wrapped = [{ segments: [], selected: line[:selected] }]
+      used_cells = 0
+
+      line[:segments].each do |segment|
+        segment.text.to_s.each_char do |char|
+          width = TextMetrics.char_width(char)
+          if used_cells.positive? && used_cells + width > max_cells
+            wrapped << { segments: [], selected: line[:selected] }
+            used_cells = 0
+          end
+
+          append_segment_text(wrapped.last[:segments], segment, char)
+          used_cells += width
+        end
+      end
+
+      wrapped
+    end
+
+    def clip_segments(segments, max_cells)
+      remaining = max_cells
+      segments.each_with_object([]) do |segment, result|
+        break result if remaining <= 0
+
+        text = TextMetrics.take_cells(segment.text, remaining)
+        next if text.empty?
+
+        result << copy_segment(segment, text)
+        remaining -= TextMetrics.cell_width(text)
+      end
+    end
+
+    def scroll_segments(segments, max_cells)
+      total_cells = segments.sum { |segment| TextMetrics.cell_width(segment.text) }
+      return clip_segments(segments, max_cells) if total_cells <= max_cells
+
+      cells_to_drop = total_cells - max_cells
+      scrolled = []
+
+      segments.each do |segment|
+        segment_cells = TextMetrics.cell_width(segment.text)
+        if cells_to_drop >= segment_cells
+          cells_to_drop -= segment_cells
+          next
+        end
+
+        text = cells_to_drop.positive? ? TextMetrics.drop_cells(segment.text, cells_to_drop) : segment.text
+        cells_to_drop = 0
+        scrolled << copy_segment(segment, text) unless text.empty?
+      end
+
+      clip_segments(scrolled, max_cells)
+    end
+
+    def append_segment_text(segments, source_segment, char)
+      if segments.last && segment_style_key(segments.last) == segment_style_key(source_segment)
+        segments.last.text << char
+      else
+        segments << copy_segment(source_segment, char)
+      end
+    end
+
+    def copy_segment(segment, text)
+      RenderSegment.copy(segment, text)
+    end
+
+    def segment_style_key(segment)
+      [
+        segment.foreground,
+        segment.background,
+        segment.bold,
+        segment.italic,
+        segment.underline,
+        segment.dim,
+        segment.reverse,
+        segment.strikethrough,
+        segment.overline
+      ]
+    end
+  end
+end