shellfie 0.1.1 → 1.0.0

data/lib/shellfie/render_segment.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class RenderSegment
+    ATTRIBUTES = %i[
+      foreground background bold italic underline dim reverse strikethrough overline
+    ].freeze
+
+    attr_reader :text, :foreground, :background, :bold, :italic, :underline, :dim, :reverse, :strikethrough, :overline
+
+    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,
+        dim: segment.dim,
+        reverse: segment.reverse,
+        strikethrough: segment.strikethrough,
+        overline: segment.overline
+      )
+    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, dim: false,
+                   reverse: false, strikethrough: false, overline: false)
+      @text = text
+      @foreground = foreground
+      @background = background
+      @bold = bold
+      @italic = italic
+      @underline = underline
+      @dim = dim
+      @reverse = reverse
+      @strikethrough = strikethrough
+      @overline = overline
+      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,122 @@
 
 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 "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 "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)
+      @font_resolver = FontResolver.new(-> { imagemagick_command })
     end
 
-    def render(output_path, scale: 1, shadow: true, transparent: false)
+    def render(output_path, scale: 1, shadow: true, transparent: false, format: nil)
       check_dependencies!
-
       lines = build_lines
-      create_image(lines, output_path, scale: scale, shadow: shadow, transparent: transparent)
-      output_path
+      extension = FormatResolver.resolve(output_path, explicit: format, default: "png")
+      OutputWriter.write(output_path, extension: extension) do |temporary_path|
+        render_method = (extension == "svg") ? :create_svg_image : :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
+
+    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
 
     private
 
-    def load_theme(name)
-      klass = THEMES[name] || THEMES["macos"]
-      klass.new
+    def check_dependencies!
+      DependencyChecker.configure_mini_magick!
+      DependencyChecker.ensure_imagemagick!
     end
 
-    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
+    def imagemagick_command
+      @imagemagick_command ||= DependencyChecker.imagemagick_path.to_s
     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
-    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}"
+        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(expand_tabs(text)).map do |segment|
+        RenderSegment.from_segment(segment, default_color: default_color)
       end
-      y = margin + title_bar_height / 2
-
-      [x, y]
     end
 
-    def draw_line_segments(convert, segments, x, y, font_size, font_config)
-      current_x = x
+    def coalesce_segments(segments)
+      RenderSegment.coalesce(segments)
+    end
 
-      segments.each do |segment|
-        color = segment.foreground ? theme.color_for(segment.foreground) : theme.colors[:foreground]
-        text = escape_text(segment.text)
+    def expand_tabs(text)
+      text.to_s.gsub("\t", " " * config.window[:tab_width])
+    end
 
-        next if text.empty?
+    def create_image(lines, output_path, scale:, shadow:, transparent:)
+      geometry = build_geometry(lines, scale: scale, shadow: shadow)
 
-        convert.fill color
-        convert.pointsize font_size
+      raster_painter.paint(geometry, output_path, transparent: transparent)
+    end
 
-        convert.draw "text #{current_x},#{y} '#{text}'"
+    def create_svg_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
 
-        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

data/lib/shellfie/rendering/shape_helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../image_magick_command_builder"
+
+module Shellfie
+  module Rendering
+    module ShapeHelpers
+      def draw_roundrect(convert, x1, y1, x2, y2, radius)
+        if radius.positive?
+          ImageMagickCommandBuilder.round_rectangle(convert, x1, y1, x2, y2, radius)
+        else
+          ImageMagickCommandBuilder.rectangle(convert, x1, y1, x2, y2)
+        end
+      end
+
+      def draw_windows_icon(convert, index, center_x, center_y, icon_size)
+        case index
+        when 0
+          ImageMagickCommandBuilder.line(convert, center_x - icon_size / 2, center_y, center_x + icon_size / 2, center_y)
+        when 1
+          ImageMagickCommandBuilder.rectangle(
+            convert,
+            center_x - icon_size / 2,
+            center_y - icon_size / 2,
+            center_x + icon_size / 2,
+            center_y + icon_size / 2
+          )
+        when 2
+          ImageMagickCommandBuilder.lines(
+            convert,
+            [
+              { x1: center_x - icon_size / 2, y1: center_y - icon_size / 2,
+                x2: center_x + icon_size / 2, y2: center_y + icon_size / 2 },
+              { x1: center_x + icon_size / 2, y1: center_y - icon_size / 2,
+                x2: center_x - icon_size / 2, y2: center_y + icon_size / 2 }
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shellfie/rendering/text_painter.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../image_magick_command_builder"
+require_relative "../text_metrics"
+
+module Shellfie
+  module Rendering
+    module TextPainter
+      def draw_content(convert, geometry)
+        content_y = content_origin_y(geometry)
+        draw_selected_backgrounds(convert, geometry, content_y)
+
+        geometry[:lines].each_with_index do |line, index|
+          top = content_y + index * geometry[:scaled_line_height]
+          baseline = top + geometry[:scaled_font_size]
+          x = geometry[:margin] + geometry[:scaled_padding]
+
+          draw_line_segments(convert, line[:segments], x, baseline, geometry)
+        end
+      end
+
+      def draw_line_segments(convert, segments, x, baseline, geometry)
+        positioned_segments = position_segments(segments, x, baseline, geometry)
+        draw_segment_backgrounds(convert, positioned_segments)
+        draw_positioned_segments(convert, positioned_segments, geometry)
+      end
+
+      def position_segments(segments, x, baseline, geometry)
+        current_x = x
+        segments.each_with_object([]) do |segment, result|
+          text = segment.text.to_s
+          next if text.empty?
+
+          width = TextMetrics.pixel_width(text, geometry[:scaled_font_size])
+          top = baseline - geometry[:scaled_font_size]
+          foreground, background = segment_colors(segment)
+          result << {
+            segment: segment,
+            text: text,
+            x: current_x,
+            width: width,
+            top: top,
+            bottom: top + geometry[:scaled_line_height],
+            foreground: foreground,
+            background: background
+          }
+          current_x += width
+        end
+      end
+
+      def draw_segment_backgrounds(convert, positioned_segments)
+        positioned_segments
+          .select { |item| item[:background] }
+          .group_by { |item| item[:background] }
+          .each do |background, items|
+            convert.fill background
+            ImageMagickCommandBuilder.rectangles(
+              convert,
+              items.map { |item| { x1: item[:x], y1: item[:top], x2: item[:x] + item[:width], y2: item[:bottom] } }
+            )
+          end
+      end
+
+      def draw_positioned_segments(convert, positioned_segments, geometry)
+        positioned_segments.each do |item|
+          draw_text(
+            convert,
+            item[:text],
+            item[:x],
+            item[:top],
+            item[:foreground],
+            geometry[:scaled_font_size],
+            geometry[:font_config],
+            bold: item[:segment].bold,
+            italic: item[:segment].italic
+          )
+          draw_text_decoration(
+            convert,
+            item[:segment],
+            item[:x],
+            item[:width],
+            item[:top] + geometry[:scaled_font_size],
+            geometry
+          )
+        end
+      end
+
+      def segment_colors(segment)
+        foreground = segment.foreground ? theme.color_for(segment.foreground) : theme.colors[:foreground]
+        background = segment.background ? theme.color_for(segment.background) : nil
+
+        if segment.reverse
+          foreground, background = background || theme.colors[:background], foreground
+        end
+
+        foreground = color_with_opacity(foreground, 0.6, true) if segment.dim
+        [foreground, background]
+      end
+
+      def draw_text(convert, text, x, y, color, font_size, font_config, bold: false, italic: false)
+        convert.gravity "NorthWest"
+        convert.fill color
+        convert.stroke "none"
+        font = font_resolver.resolve(font_config, italic: italic)
+        convert.font font if font
+        convert.pointsize font_size
+        convert.weight(bold ? 700 : 400)
+        convert.style(italic ? "Italic" : "Normal")
+        convert.annotate "+#{x}+#{y}", escape_text(text)
+      end
+
+      def draw_text_decoration(convert, segment, x, width, baseline, geometry)
+        return unless segment.underline || segment.strikethrough || segment.overline
+
+        line_width = [(geometry[:scaled_font_size] / 12.0).ceil, 1].max
+        convert.stroke segment_colors(segment).first
+        convert.strokewidth line_width
+
+        if segment.underline
+          y = baseline + (geometry[:scaled_font_size] * 0.12).ceil
+          ImageMagickCommandBuilder.line(convert, x, y, x + width, y)
+        end
+        if segment.strikethrough
+          y = baseline - (geometry[:scaled_font_size] * 0.35).ceil
+          ImageMagickCommandBuilder.line(convert, x, y, x + width, y)
+        end
+        if segment.overline
+          y = baseline - geometry[:scaled_font_size]
+          ImageMagickCommandBuilder.line(convert, x, y, x + width, y)
+        end
+
+        convert.stroke "none"
+      end
+
+      def draw_selected_backgrounds(convert, geometry, content_y)
+        rectangles = geometry[:lines].each_with_index.each_with_object([]) do |(line, index), result|
+          next unless line[:selected]
+
+          x = geometry[:margin] + geometry[:scaled_padding]
+          top = content_y + index * geometry[:scaled_line_height]
+          result << {
+            x1: x,
+            y1: top,
+            x2: x + geometry[:scaled_width] - geometry[:scaled_padding] * 2,
+            y2: top + geometry[:scaled_line_height]
+          }
+        end
+        return if rectangles.empty?
+
+        convert.fill theme.colors[:selection]
+        ImageMagickCommandBuilder.rectangles(convert, rectangles)
+      end
+
+      def content_origin_y(geometry)
+        base_y = geometry[:margin] + geometry[:scaled_title_bar] + geometry[:scaled_padding]
+        base_y - (geometry[:scroll_offset].to_f * geometry[:scaled_line_height]).round
+      end
+
+      def fit_text(text, max_width, font_size)
+        return "" if max_width <= 0
+        return text if TextMetrics.pixel_width(text, font_size) <= max_width
+
+        max_cells = [(max_width / (font_size * 0.6)).floor - 3, 0].max
+        "#{TextMetrics.take_cells(text, max_cells)}..."
+      end
+
+      def color_with_opacity(color, opacity, allow_rgba)
+        return color unless allow_rgba && opacity < 1.0
+
+        if color.to_s.match?(/\A#[0-9a-fA-F]{6}\z/)
+          r = color[1, 2].to_i(16)
+          g = color[3, 2].to_i(16)
+          b = color[5, 2].to_i(16)
+          "rgba(#{r},#{g},#{b},#{opacity})"
+        else
+          color
+        end
+      end
+
+      def escape_text(text)
+        text.to_s
+          .encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+          .gsub(/[\u0000-\u001f\u007f]/, " ")
+      end
+    end
+  end
+end