shellfie 0.1.1 → 1.1.0

data/lib/shellfie/raster_painter.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require_relative "image_magick_command_builder"
+require_relative "rendering/text_painter"
+require_relative "rendering/window_chrome"
+
+module Shellfie
+  class RasterPainter
+    include Rendering::TextPainter
+    include Rendering::WindowChrome
+
+    attr_reader :config, :theme, :font_resolver
+
+    def initialize(config:, theme:, font_resolver:, chrome_cache: nil)
+      @config = config
+      @theme = theme
+      @font_resolver = font_resolver
+      @chrome_cache = chrome_cache
+    end
+
+    def paint(geometry, output_path, transparent:)
+      return create_cached_image(geometry, output_path, transparent: transparent) if @chrome_cache
+
+      create_full_image(geometry, output_path, transparent: transparent)
+    end
+
+    private
+
+    def create_full_image(geometry, output_path, transparent:)
+      return create_direct_image(geometry, output_path, transparent: transparent) unless clip_content?(geometry)
+
+      with_temp_png do |base_path|
+        with_temp_png do |content_path|
+          create_chrome_image(geometry, base_path, transparent: transparent)
+          create_content_layer(geometry, content_path)
+          composite_layers(base_path, content_path, output_path)
+        end
+      end
+    end
+
+    def create_direct_image(geometry, output_path, transparent:)
+      ImageMagickCommandBuilder.convert do |convert|
+        ImageMagickCommandBuilder.canvas(
+          convert,
+          width: geometry[:canvas_width],
+          height: geometry[:canvas_height],
+          background: canvas_background(transparent)
+        )
+        draw_chrome(convert, geometry, transparent: transparent)
+        draw_content(convert, geometry)
+        finish_image(convert, output_path)
+      end
+    end
+
+    def create_cached_image(geometry, output_path, transparent:)
+      base_path = @chrome_cache.fetch(geometry, transparent: transparent) do |path|
+        create_chrome_image(geometry, path, transparent: transparent)
+      end
+      return create_cached_direct_image(base_path, geometry, output_path) unless clip_content?(geometry)
+
+      with_temp_png do |content_path|
+        create_content_layer(geometry, content_path)
+        composite_layers(base_path, content_path, output_path)
+      end
+    end
+
+    def create_cached_direct_image(base_path, geometry, output_path)
+      ImageMagickCommandBuilder.convert do |convert|
+        convert << base_path
+        draw_content(convert, geometry)
+        finish_image(convert, output_path)
+      end
+    end
+
+    def create_chrome_image(geometry, output_path, transparent:)
+      ImageMagickCommandBuilder.convert do |convert|
+        ImageMagickCommandBuilder.canvas(
+          convert,
+          width: geometry[:canvas_width],
+          height: geometry[:canvas_height],
+          background: canvas_background(transparent)
+        )
+        draw_chrome(convert, geometry, transparent: transparent)
+        ImageMagickCommandBuilder.output(convert, output_path, format: "png")
+      end
+    end
+
+    def create_content_layer(geometry, output_path)
+      ImageMagickCommandBuilder.convert do |convert|
+        ImageMagickCommandBuilder.canvas(
+          convert,
+          width: geometry[:canvas_width],
+          height: geometry[:canvas_height],
+          background: "xc:transparent"
+        )
+        ImageMagickCommandBuilder.region(convert, **content_region(geometry))
+        draw_content(convert, geometry)
+        ImageMagickCommandBuilder.clear_region(convert)
+        ImageMagickCommandBuilder.output(convert, output_path, format: "png")
+      end
+    end
+
+    def composite_layers(base_path, content_path, output_path)
+      ImageMagickCommandBuilder.convert do |convert|
+        convert << base_path
+        convert << content_path
+        ImageMagickCommandBuilder.composite_over(convert)
+        finish_image(convert, output_path)
+      end
+    end
+
+    def draw_chrome(convert, geometry, transparent:)
+      draw_shadow(convert, geometry) if geometry[:shadow]
+      draw_window(convert, geometry, transparent: transparent)
+      draw_title_bar(convert, geometry) unless config.headless
+    end
+
+    def finish_image(convert, output_path)
+      if config.window[:trim]
+        convert.trim
+        convert << "+repage"
+      end
+      ImageMagickCommandBuilder.output(convert, output_path)
+    end
+
+    def canvas_background(transparent)
+      gradient = config.window[:background_gradient]
+      return "xc:transparent" if transparent
+      return "gradient:#{gradient[0]}-#{gradient[1]}" if gradient.is_a?(Array) && gradient.size == 2
+
+      "xc:#{theme.colors[:background]}"
+    end
+
+    def clip_content?(geometry)
+      geometry[:scroll_offset].to_f.positive?
+    end
+
+    def content_region(geometry)
+      {
+        x: geometry[:margin] + geometry[:scaled_padding],
+        y: geometry[:margin] + geometry[:scaled_title_bar] + geometry[:scaled_padding],
+        width: [geometry[:scaled_width] - geometry[:scaled_padding] * 2, 1].max,
+        height: [geometry[:scaled_height] - geometry[:scaled_title_bar] - geometry[:scaled_padding] * 2, 1].max
+      }
+    end
+
+    def with_temp_png
+      file = Tempfile.new(["shellfie-layer", ".png"])
+      path = file.path
+      file.close
+      yield path
+    ensure
+      File.delete(path) if path && File.exist?(path)
+    end
+  end
+end

data/lib/shellfie/render_chrome_cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Shellfie
+  class RenderChromeCache
+    def initialize
+      @entries = {}
+    end
+
+    def fetch(geometry, transparent:)
+      key = cache_key(geometry, transparent)
+      return @entries[key].path if @entries.key?(key)
+
+      temp = Tempfile.new(["shellfie-chrome", ".png"], binmode: true)
+      temp.close
+      yield temp.path
+      @entries[key] = temp
+      temp.path
+    end
+
+    def cleanup
+      @entries.each_value do |temp|
+        File.delete(temp.path) if File.exist?(temp.path)
+        temp.close unless temp.closed?
+      end
+      @entries.clear
+    end
+
+    private
+
+    def cache_key(geometry, transparent)
+      [
+        transparent,
+        geometry.values_at(:canvas_width, :canvas_height, :scaled_width, :scaled_height, :scaled_title_bar, :margin,
+          :shadow, :scaled_radius)
+      ]
+    end
+  end
+end

data/lib/shellfie/render_geometry.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative "line_layout"
+
+module Shellfie
+  class RenderGeometry
+    def initialize(config:, theme:)
+      @config = config
+      @theme = theme
+    end
+
+    def build(lines, scale:, shadow:)
+      font_config = @theme.font
+      line_height = font_config[:size] * font_config[:line_height]
+      display_lines, visible_count = display_lines(lines, font_config, line_height)
+      total_height = @config.window[:height] || title_bar_height + [visible_count, 1].max * line_height + padding * 2
+      margin = canvas_margin(scale, shadow && !exact_size?)
+      geometry = geometry_hash(
+        display_lines,
+        font_config,
+        line_height,
+        total_height,
+        scale,
+        margin,
+        shadow && !exact_size?,
+        visible_count
+      )
+      validate_pixel_limit!(geometry)
+      geometry
+    end
+
+    private
+
+    def display_lines(lines, font_config, line_height)
+      layout = LineLayout.new(@config)
+      display_lines = layout.prepare(
+        lines,
+        content_width: [width - (padding * 2), 1].max,
+        font_size: font_config[:size],
+        title_bar_height: title_bar_height,
+        padding: padding,
+        line_height: line_height
+      )
+      [display_lines, layout.visible_count]
+    end
+
+    def geometry_hash(lines, font_config, line_height, total_height, scale, margin, shadow, visible_count)
+      {
+        lines: lines,
+        visible_line_count: visible_count,
+        font_config: font_config,
+        width: width,
+        height: total_height,
+        padding: padding,
+        line_height: line_height,
+        font_size: font_config[:size],
+        title_bar_height: title_bar_height,
+        logical_width: width,
+        logical_height: total_height.ceil,
+        scale: scale,
+        scaled_width: (width * scale).to_i,
+        scaled_height: (total_height * scale).ceil,
+        scaled_padding: (padding * scale).to_i,
+        scaled_line_height: (line_height * scale).ceil,
+        scaled_font_size: (font_config[:size] * scale).to_i,
+        scaled_title_bar: (title_bar_height * scale).to_i,
+        scaled_radius: (corner_radius * scale).to_i,
+        scroll_offset: @config.window[:scroll_offset].to_f,
+        ambiguous_width: @config.window[:ambiguous_width],
+        margin: margin,
+        canvas_width: (width * scale).to_i + margin * 2,
+        canvas_height: (total_height * scale).ceil + margin * 2,
+        shadow: shadow
+      }
+    end
+
+    def width
+      @config.window[:width]
+    end
+
+    def padding
+      @config.window[:padding]
+    end
+
+    def title_bar_height
+      @config.headless ? 0 : @theme.window_decoration[:title_bar_height]
+    end
+
+    def corner_radius
+      @config.headless ? 0 : @theme.window_decoration[:corner_radius]
+    end
+
+    def exact_size?
+      @config.window[:exact_size]
+    end
+
+    def canvas_margin(scale, shadow)
+      configured = @config.window[:margin]
+      return (configured * scale).to_i if configured
+      return 0 if @config.headless && !shadow
+      return 0 if exact_size?
+      return (10 * scale).to_i unless shadow
+
+      shadow_config = @theme.window_decoration[:shadow]
+      (([shadow_config[:blur].to_i, shadow_config[:offset_x].to_i.abs, shadow_config[:offset_y].to_i.abs].max + 10) * scale).to_i
+    end
+
+    def validate_pixel_limit!(geometry)
+      pixels = geometry[:canvas_width] * geometry[:canvas_height]
+      return if pixels <= @config.limits[:max_pixels]
+
+      raise ResourceLimitError, "Estimated image is too large (#{pixels} pixels, max #{@config.limits[:max_pixels]})"
+    end
+  end
+end

data/lib/shellfie/render_segment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class RenderSegment
+    ATTRIBUTES = %i[
+      foreground background bold italic underline underline_style underline_color dim reverse strikethrough overline blink conceal link
+    ].freeze
+
+    attr_reader :text, :foreground, :background, :bold, :italic, :underline, :underline_style, :underline_color,
+                :dim, :reverse, :strikethrough, :overline, :blink, :conceal, :link
+
+    def self.from_segment(segment, default_color:)
+      new(
+        text: segment.text.to_s,
+        foreground: segment.foreground || default_color,
+        background: segment.background,
+        bold: segment.bold,
+        italic: segment.italic,
+        underline: segment.underline,
+        underline_style: segment.underline_style,
+        underline_color: segment.underline_color,
+        dim: segment.dim,
+        reverse: segment.reverse,
+        strikethrough: segment.strikethrough,
+        overline: segment.overline,
+        blink: segment.blink,
+        conceal: segment.conceal,
+        link: segment.link
+      )
+    end
+
+    def self.copy(segment, text)
+      new(**ATTRIBUTES.each_with_object(text: text.dup) { |attribute, values| values[attribute] = segment.public_send(attribute) })
+    end
+
+    def self.coalesce(segments)
+      segments.each_with_object([]) do |segment, result|
+        if result.last&.same_style?(segment)
+          result[-1] = copy(result.last, result.last.text + segment.text)
+        else
+          result << segment
+        end
+      end
+    end
+
+    def initialize(text:, foreground: nil, background: nil, bold: false, italic: false, underline: false,
+                   underline_style: nil, underline_color: nil, dim: false, reverse: false, strikethrough: false,
+                   overline: false, blink: false, conceal: false, link: nil)
+      @text = text
+      @foreground = foreground
+      @background = background
+      @bold = bold
+      @italic = italic
+      @underline = underline
+      @underline_style = underline_style
+      @underline_color = underline_color
+      @dim = dim
+      @reverse = reverse
+      @strikethrough = strikethrough
+      @overline = overline
+      @blink = blink
+      @conceal = conceal
+      @link = link
+      freeze
+    end
+
+    def same_style?(other)
+      ATTRIBUTES.all? { |attribute| public_send(attribute) == other.public_send(attribute) }
+    end
+  end
+end

data/lib/shellfie/renderer.rb

@@ -2,192 +2,139 @@
 
 require "mini_magick"
 require_relative "ansi_parser"
-require_relative "themes/base"
-require_relative "themes/macos"
-require_relative "themes/ubuntu"
-require_relative "themes/windows_terminal"
+require_relative "dependency_checker"
+require_relative "font_resolver"
+require_relative "format_resolver"
+require_relative "html_renderer"
+require_relative "output_writer"
+require_relative "raster_painter"
+require_relative "render_chrome_cache"
+require_relative "render_geometry"
+require_relative "render_segment"
+require_relative "svg_raster_wrapper"
+require_relative "svg_renderer"
+require_relative "theme_registry"
 
 module Shellfie
   class Renderer
-    THEMES = {
-      "macos" => Themes::MacOS,
-      "ubuntu" => Themes::Ubuntu,
-      "windows" => Themes::WindowsTerminal
-    }.freeze
+    attr_reader :config, :theme, :font_resolver
 
-    attr_reader :config, :theme
-
-    def initialize(config)
+    def initialize(config, chrome_cache: nil)
       @config = config
-      @theme = load_theme(config.theme)
-      @ansi_parser = AnsiParser.new
+      @chrome_cache = chrome_cache
+      @theme = ThemeRegistry.build(config)
+      @ansi_parser = AnsiParser.new(
+        state_mode: config.window[:ansi_state] || :persistent,
+        tab_width: config.window[:tab_width],
+        osc_policy: config.window[:osc_policy],
+        graphics_policy: config.window[:graphics_policy]
+      )
+      @font_resolver = FontResolver.new(-> { imagemagick_command })
     end
 
-    def render(output_path, scale: 1, shadow: true, transparent: false)
-      check_dependencies!
-
+    def render(output_path, scale: 1, shadow: true, transparent: false, format: nil, io: nil)
+      extension = FormatResolver.resolve(output_path, explicit: format, default: "png")
+      check_dependencies! unless %w[svg html].include?(extension)
       lines = build_lines
-      create_image(lines, output_path, scale: scale, shadow: shadow, transparent: transparent)
-      output_path
+      OutputWriter.write(output_path, extension: extension, io: io) do |temporary_path|
+        render_method = { "svg" => :create_svg_image, "svg-raster" => :create_svg_raster_image, "html" => :create_html }.fetch(extension, :create_image)
+        send(render_method, lines, temporary_path, scale: scale, shadow: shadow, transparent: transparent)
+      end
+    rescue MiniMagick::Error => e
+      raise RenderError.new("ImageMagick render failed: #{e.message}", category: :render)
     end
 
-    private
+    def estimate(scale: 1, shadow: true)
+      geometry = build_geometry(build_lines, scale: scale, shadow: shadow)
+      geometry.slice(:canvas_width, :canvas_height, :scaled_width, :scaled_height, :logical_width, :logical_height, :scale)
+    end
 
-    def load_theme(name)
-      klass = THEMES[name] || THEMES["macos"]
-      klass.new
+    def font_info
+      font_resolver.details(theme.font)
     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_lines
-      config.lines.flat_map do |line|
-        result = []
-        if line.prompt
-          prompt_segments = @ansi_parser.parse(line.prompt)
-          command_segments = line.command ? @ansi_parser.parse(line.command) : []
-          result << { segments: prompt_segments + command_segments }
-        end
-        if line.output
-          line.output.split("\n").each do |output_line|
-            result << { segments: @ansi_parser.parse(output_line) }
-          end
-        end
-        result
-      end
+    def imagemagick_command
+      @imagemagick_command ||= DependencyChecker.imagemagick_path.to_s
     end
 
-    def create_image(lines, output_path, scale:, shadow:, transparent:)
-      decoration = theme.window_decoration
-      font_config = config.font.is_a?(Hash) ? config.font : theme.font
-      padding = config.window[:padding] || 20
-      width = config.window[:width] || 600
-      line_height = (font_config[:size] || 14) * (font_config[:line_height] || 1.4)
-      title_bar_height = config.headless ? 0 : decoration[:title_bar_height]
-      visible_lines = config.window[:visible_lines]
-
-      display_line_count = visible_lines || lines.size
-      content_height = display_line_count * line_height + padding * 2
-      total_height = title_bar_height + content_height
-      corner_radius = decoration[:corner_radius]
-
-      if visible_lines && lines.size > visible_lines
-        lines = lines.last(visible_lines)
-      end
-
-      scaled_width = (width * scale).to_i
-      scaled_height = (total_height * scale).to_i
-      scaled_padding = (padding * scale).to_i
-      scaled_title_bar = (title_bar_height * scale).to_i
-      scaled_line_height = (line_height * scale).to_i
-      scaled_font_size = ((font_config[:size] || 14) * scale).to_i
-      scaled_radius = (corner_radius * scale).to_i
-
-      margin = shadow ? (50 * scale).to_i : (10 * scale).to_i
-      canvas_width = scaled_width + margin * 2
-      canvas_height = scaled_height + margin * 2
-
-      MiniMagick.convert do |convert|
-        convert.size "#{canvas_width}x#{canvas_height}"
-        convert << "xc:transparent"
-
-        if shadow
-          convert.fill "rgba(0,0,0,0.3)"
-          shadow_offset = (10 * scale).to_i
-          convert.draw "roundrectangle #{margin + shadow_offset},#{margin + shadow_offset} " \
-                       "#{margin + scaled_width - 1 + shadow_offset},#{margin + scaled_height - 1 + shadow_offset} " \
-                       "#{scaled_radius},#{scaled_radius}"
-          convert.blur "0x#{(15 * scale).to_i}"
+    def build_lines
+      config.lines.flat_map do |line|
+        rendered_lines = []
+        if line.prompt || line.command
+          rendered_lines << {
+            segments: coalesce_segments(
+              parse_with_default(line.prompt.to_s, line.prompt_color) +
+                parse_with_default(line.command.to_s, line.command_color)
+            ),
+            selected: line.selected
+          }
         end
 
-        convert.fill theme.colors[:background]
-        convert.draw "roundrectangle #{margin},#{margin} " \
-                     "#{margin + scaled_width - 1},#{margin + scaled_height - 1} " \
-                     "#{scaled_radius},#{scaled_radius}"
-
-        unless config.headless
-          convert.fill theme.colors[:title_bar]
-          title_y2 = margin + scaled_title_bar - 1
-          convert.draw "roundrectangle #{margin},#{margin} " \
-                       "#{margin + scaled_width - 1},#{title_y2} " \
-                       "#{scaled_radius},#{scaled_radius}"
-          convert.fill theme.colors[:title_bar]
-          convert.draw "rectangle #{margin},#{margin + scaled_radius} " \
-                       "#{margin + scaled_width - 1},#{title_y2}"
-
-          button_x, button_y = button_positions(margin, scaled_title_bar, scale)
-          button_radius = ((theme.window_decoration[:button_size] / 2) * scale).to_i
-
-          theme.button_colors.each_with_index do |color, i|
-            spacing = ((theme.window_decoration[:button_spacing] + theme.window_decoration[:button_size]) * scale).to_i
-            bx = button_x + i * spacing
-            convert.fill color
-            convert.draw "circle #{bx},#{button_y} #{bx + button_radius},#{button_y}"
-          end
-
-          convert.fill theme.colors[:title_text]
-          convert.pointsize scaled_font_size
-          title_y = margin + scaled_title_bar / 2 + scaled_font_size / 3
-          title_x = margin + scaled_width / 2
-          convert.gravity "NorthWest"
-          convert.draw "text #{title_x - config.title.to_s.length * scaled_font_size / 4},#{title_y - scaled_font_size} '#{escape_text(config.title.to_s)}'"
-        end
+        next rendered_lines unless line.output
 
-        content_y = margin + scaled_title_bar + scaled_padding
-        lines.each_with_index do |line, idx|
-          y = content_y + idx * scaled_line_height + scaled_font_size
-          x = margin + scaled_padding
-          draw_line_segments(convert, line[:segments], x, y, scaled_font_size, font_config)
+        line.output.to_s.split("\n", -1).each do |output_line|
+          rendered_lines << { segments: coalesce_segments(parse_with_default(output_line, line.output_color)), selected: line.selected }
         end
-
-        convert << output_path
+        rendered_lines
       end
     end
 
-    def button_positions(margin, title_bar_height, scale)
-      button_size = (theme.window_decoration[:button_size] * scale).to_i
-      scaled_width = ((config.window[:width] || 600) * scale).to_i
-
-      if theme.buttons_position == :left
-        x = margin + (16 * scale).to_i
-      else
-        x = margin + scaled_width - (16 * scale).to_i - button_size * 3
+    def parse_with_default(text, default_color)
+      @ansi_parser.parse(text).map do |segment|
+        RenderSegment.from_segment(segment, default_color: default_color)
       end
-      y = margin + title_bar_height / 2
+    end
 
-      [x, y]
+    def coalesce_segments(segments)
+      RenderSegment.coalesce(segments)
     end
 
-    def draw_line_segments(convert, segments, x, y, font_size, font_config)
-      current_x = x
+    def create_image(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
 
-      segments.each do |segment|
-        color = segment.foreground ? theme.color_for(segment.foreground) : theme.colors[:foreground]
-        text = escape_text(segment.text)
+      raster_painter.paint(geometry, output_path, transparent: transparent)
+    end
 
-        next if text.empty?
+    def create_svg_image(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
+      SvgRenderer.new(config: config, theme: theme).render(geometry, output_path, transparent: transparent)
+    end
 
-        convert.fill color
-        convert.pointsize font_size
+    def create_svg_raster_image(lines, output_path, scale:, shadow:, transparent:)
+      SvgRasterWrapper.write(output_path) { |png_path| create_image(lines, png_path, scale: scale, shadow: shadow, transparent: transparent) }
+    end
 
-        convert.draw "text #{current_x},#{y} '#{text}'"
+    def create_html(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
+      HtmlRenderer.new(config: config, theme: theme).render(geometry, output_path, transparent: transparent)
+    end
 
-        char_width = font_size * 0.6
-        current_x += (segment.text.length * char_width).to_i
-      end
+    def build_geometry(lines, scale:, shadow:)
+      geometry_builder.build(lines, scale: scale, shadow: shadow)
     end
 
     def escape_text(text)
-      text.to_s.gsub("'", "\\\\'").gsub("\\", "\\\\\\\\")
+      raster_painter.send(:escape_text, text)
+    end
+
+    def geometry_builder
+      @geometry_builder ||= RenderGeometry.new(config: config, theme: theme)
+    end
+
+    def raster_painter
+      @raster_painter ||= RasterPainter.new(
+        config: config,
+        theme: theme,
+        font_resolver: font_resolver,
+        chrome_cache: @chrome_cache
+      )
     end
   end
 end