shellfie 0.1.1 → 1.1.0

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,195 @@
+# 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], ambiguous_width: geometry[:ambiguous_width])
+          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|
+          unless item[:segment].conceal
+            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
+            )
+          end
+          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 if segment.conceal
+        return unless segment.underline || segment.strikethrough || segment.overline
+
+        line_width = [(geometry[:scaled_font_size] / 12.0).ceil, 1].max
+        decoration_color = segment.underline_color ? theme.color_for(segment.underline_color) : segment_colors(segment).first
+        convert.stroke decoration_color
+        convert.strokewidth line_width
+        convert.stroke_dasharray "#{line_width},#{line_width * 2}" if segment.underline_style == :dotted
+        convert.stroke_dasharray "#{line_width * 3},#{line_width * 2}" if segment.underline_style == :dashed
+
+        if segment.underline
+          y = baseline + (geometry[:scaled_font_size] * 0.12).ceil
+          ImageMagickCommandBuilder.line(convert, x, y, x + width, y)
+          ImageMagickCommandBuilder.line(convert, x, y + line_width * 2, x + width, y + line_width * 2) if segment.underline_style == :double
+        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"
+        convert.stroke_dasharray "none" if %i[dotted dashed].include?(segment.underline_style)
+      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, ambiguous_width: config.window[:ambiguous_width]) <= max_width
+
+        max_cells = [(max_width / (font_size * 0.6)).floor - 3, 0].max
+        "#{TextMetrics.take_cells(text, max_cells, ambiguous_width: config.window[:ambiguous_width])}..."
+      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

data/lib/shellfie/rendering/window_chrome.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative "shape_helpers"
+require_relative "../image_magick_command_builder"
+require_relative "../text_metrics"
+
+module Shellfie
+  module Rendering
+    module WindowChrome
+      include ShapeHelpers
+
+      def draw_shadow(convert, geometry)
+        shadow = theme.window_decoration[:shadow]
+        scale = geometry[:scale]
+        offset_x = (shadow[:offset_x] * scale).to_i
+        offset_y = (shadow[:offset_y] * scale).to_i
+        radius = geometry[:scaled_radius]
+        margin = geometry[:margin]
+
+        convert.fill shadow[:color]
+        draw_roundrect(
+          convert,
+          margin + offset_x,
+          margin + offset_y,
+          margin + geometry[:scaled_width] - 1 + offset_x,
+          margin + geometry[:scaled_height] - 1 + offset_y,
+          radius
+        )
+        convert.blur "0x#{(shadow[:blur] * scale).to_i}"
+      end
+
+      def draw_window(convert, geometry, transparent:)
+        margin = geometry[:margin]
+        background = color_with_opacity(theme.colors[:background], config.window[:opacity], true)
+
+        convert.fill background
+        draw_roundrect(
+          convert,
+          margin,
+          margin,
+          margin + geometry[:scaled_width] - 1,
+          margin + geometry[:scaled_height] - 1,
+          geometry[:scaled_radius]
+        )
+
+        draw_border(convert, geometry)
+      end
+
+      def draw_title_bar(convert, geometry)
+        margin = geometry[:margin]
+        title_y2 = margin + geometry[:scaled_title_bar] - 1
+
+        convert.fill theme.colors[:title_bar]
+        draw_roundrect(
+          convert,
+          margin,
+          margin,
+          margin + geometry[:scaled_width] - 1,
+          title_y2,
+          geometry[:scaled_radius]
+        )
+        convert.fill theme.colors[:title_bar]
+        ImageMagickCommandBuilder.rectangle(
+          convert,
+          margin,
+          margin + geometry[:scaled_radius],
+          margin + geometry[:scaled_width] - 1,
+          title_y2
+        )
+
+        draw_title_separator(convert, geometry, title_y2)
+        draw_buttons(convert, geometry)
+        draw_title(convert, geometry)
+      end
+
+      def draw_title_separator(convert, geometry, y)
+        color = theme.colors[:title_bar_border]
+        return unless color
+
+        convert.stroke color
+        convert.strokewidth 1
+        ImageMagickCommandBuilder.line(convert, geometry[:margin], y, geometry[:margin] + geometry[:scaled_width] - 1, y)
+        convert.stroke "none"
+      end
+
+      def draw_border(convert, geometry)
+        color = theme.colors[:border]
+        return unless color
+
+        convert.fill "none"
+        convert.stroke color
+        convert.strokewidth [geometry[:scale].to_i, 1].max
+        draw_roundrect(
+          convert,
+          geometry[:margin],
+          geometry[:margin],
+          geometry[:margin] + geometry[:scaled_width] - 1,
+          geometry[:margin] + geometry[:scaled_height] - 1,
+          geometry[:scaled_radius]
+        )
+        convert.stroke "none"
+      end
+
+      def draw_buttons(convert, geometry)
+        return draw_windows_buttons(convert, geometry) if theme.button_style == :icons
+
+        button_radius = ((theme.window_decoration[:button_size] / 2.0) * geometry[:scale]).to_i
+        centers = circle_button_centers(geometry)
+
+        centers.each_with_index do |(x, y), index|
+          convert.fill theme.button_colors[index]
+          convert.stroke "rgba(0,0,0,0.18)"
+          convert.strokewidth [geometry[:scale].to_i, 1].max
+          ImageMagickCommandBuilder.circle(convert, x, y, button_radius)
+        end
+        convert.stroke "none"
+      end
+
+      def circle_button_centers(geometry)
+        scale = geometry[:scale]
+        size = (theme.window_decoration[:button_size] * scale).to_i
+        spacing = ((theme.window_decoration[:button_spacing] + theme.window_decoration[:button_size]) * scale).to_i
+        y = geometry[:margin] + geometry[:scaled_title_bar] / 2
+
+        start_x = if theme.buttons_position == :left
+                    geometry[:margin] + (16 * scale).to_i
+                  else
+                    group_width = size * 3 + (theme.window_decoration[:button_spacing] * scale).to_i * 2
+                    geometry[:margin] + geometry[:scaled_width] - (16 * scale).to_i - group_width + size / 2
+                  end
+
+        3.times.map { |index| [start_x + index * spacing, y] }
+      end
+
+      def draw_windows_buttons(convert, geometry)
+        scale = geometry[:scale]
+        button_width = ((theme.window_decoration[:button_width] || 46) * scale).to_i
+        icon_size = (10 * scale).to_i
+        start_x = geometry[:margin] + geometry[:scaled_width] - button_width * 3
+        center_y = geometry[:margin] + geometry[:scaled_title_bar] / 2
+        color = theme.colors[:title_text]
+
+        convert.stroke color
+        convert.strokewidth [scale.to_i, 1].max
+        convert.fill "none"
+
+        3.times do |index|
+          center_x = start_x + button_width * index + button_width / 2
+          draw_windows_icon(convert, index, center_x, center_y, icon_size)
+        end
+
+        convert.stroke "none"
+      end
+
+      def draw_title(convert, geometry)
+        scaled_font_size = geometry[:scaled_font_size]
+        group_width = button_group_width(geometry)
+        reserve_left = theme.buttons_position == :left ? group_width + (32 * geometry[:scale]).to_i : (12 * geometry[:scale]).to_i
+        reserve_right = theme.buttons_position == :right ? group_width + (12 * geometry[:scale]).to_i : (12 * geometry[:scale]).to_i
+        available_width = geometry[:scaled_width] - reserve_left - reserve_right
+        title = fit_text(config.title.to_s, available_width, scaled_font_size)
+        title_width = TextMetrics.pixel_width(title, scaled_font_size, ambiguous_width: config.window[:ambiguous_width])
+        min_x = geometry[:margin] + reserve_left
+        max_x = geometry[:margin] + geometry[:scaled_width] - reserve_right - title_width
+        centered_x = geometry[:margin] + (geometry[:scaled_width] - title_width) / 2
+        x = title_x(min_x, max_x, centered_x)
+        y = geometry[:margin] + geometry[:scaled_title_bar] / 2 + (scaled_font_size * 0.6).round
+
+        draw_text(convert, title, x, y - scaled_font_size, theme.colors[:title_text], scaled_font_size, geometry[:font_config])
+      end
+
+      def title_x(min_x, max_x, centered_x)
+        case theme.title_alignment
+        when :left
+          min_x
+        when :right
+          max_x
+        else
+          [[centered_x, min_x].max, max_x].min
+        end
+      end
+
+      def button_group_width(geometry)
+        scale = geometry[:scale]
+        if theme.button_style == :icons
+          ((theme.window_decoration[:button_width] || 46) * 3 * scale).to_i
+        else
+          size = theme.window_decoration[:button_size]
+          spacing = theme.window_decoration[:button_spacing]
+          ((size * 3 + spacing * 2) * scale).to_i
+        end
+      end
+
+    end
+  end
+end

data/lib/shellfie/reproducibility_manifest.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "rbconfig"
+
+module Shellfie
+  class ReproducibilityManifest
+    def self.build(config, output_path:, format:)
+      renderer = Renderer.new(config)
+      {
+        schema: 1,
+        config_sha256: Digest::SHA256.hexdigest(JSON.generate(config.to_h)),
+        output: output_path,
+        output_sha256: output_digest(output_path),
+        format: format,
+        ruby: RUBY_DESCRIPTION,
+        platform: RbConfig::CONFIG["host_os"],
+        unicode: {
+          version: TextMetrics::UNICODE_VERSION,
+          width_table: TextMetrics::WIDTH_TABLE_VERSION,
+          ambiguous_width: config.window[:ambiguous_width]
+        },
+        imagemagick: DependencyChecker.imagemagick_details[:version],
+        ffmpeg: DependencyChecker.ffmpeg_version,
+        fonts: renderer.font_info
+      }
+    end
+
+    def self.output_digest(path)
+      return Digest::SHA256.file(path).hexdigest if File.file?(path)
+      return unless File.directory?(path)
+
+      digest = Digest::SHA256.new
+      Dir.glob(File.join(path, "**", "*"), File::FNM_DOTMATCH).select { |entry| File.file?(entry) }.sort.each do |entry|
+        digest << entry.delete_prefix("#{path}#{File::SEPARATOR}") << "\0" << Digest::SHA256.file(entry).digest
+      end
+      digest.hexdigest
+    end
+  end
+end

data/lib/shellfie/session.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require_relative "parser"
+require_relative "terminal_screen"
+
+module Shellfie
+  class Session
+    attr_reader :events, :captures, :exit_status, :screen
+
+    def initialize(columns:, rows:, title: "Terminal Session", events: [], captures: {}, exit_status: nil)
+      unless columns.is_a?(Integer) && columns.between?(1, 500) && rows.is_a?(Integer) && rows.between?(1, 200)
+        raise ParseError, "Invalid session dimensions"
+      end
+
+      @title = title
+      @events = events
+      @captures = captures
+      @exit_status = exit_status
+      @screen = TerminalScreen.new(columns: columns, rows: rows)
+      events.each { |event| @screen.feed(event[:text].to_s) if event.fetch(:visible, true) }
+    end
+
+    def record(text, delay: 0, visible: true, status: nil)
+      screen.feed(text) if visible
+      event = { text: visible ? text : "", delay: delay, visible: visible, status: status }
+      events << event
+      @exit_status = status unless status.nil?
+      event
+    end
+
+    def capture(name)
+      captures[name] = screen.render_lines
+    end
+
+    def render_config(theme:, options: {}, animated: false, lines: nil)
+      base = {
+        theme: theme,
+        title: @title,
+        window: options.fetch(:window, {}),
+        font: options.fetch(:font, {}),
+        animation: options.fetch(:animation, {}),
+        headless: options.fetch(:headless, false)
+      }
+      if animated
+        raise ValidationError, "Captured screens cannot be rendered as animations" if lines
+
+        frames = []
+        each_snapshot do |event, snapshot|
+          frame = Frame.new(screen: snapshot, delay: [(event[:delay].to_f * 1_000).round, 1].max)
+          frames << frame
+        end
+        Config.new(**base, frames: frames)
+      else
+        Config.new(**base, lines: (lines || screen.render_lines).map { |line| Line.new(output: line) })
+      end
+    end
+
+    def compose_hash
+      frames = []
+      each_snapshot do |event, snapshot|
+        frames << {
+          "screen" => snapshot,
+          "delay" => [(event[:delay].to_f * 1_000).round, 1].max
+        }
+      end
+      {
+        "version" => 1,
+        "title" => @title,
+        "window" => { "width" => screen.columns * 8, "visible_lines" => screen.rows },
+        "frames" => frames
+      }
+    end
+
+    def to_h
+      {
+        version: 1,
+        title: @title,
+        columns: screen.columns,
+        rows: screen.rows,
+        events: events,
+        captures: captures,
+        exit_status: exit_status
+      }
+    end
+
+    private
+
+    def each_snapshot
+      replay = TerminalScreen.new(columns: screen.columns, rows: screen.rows)
+      count = characters = 0
+      events.each do |event|
+        next unless event[:visible]
+
+        text = event[:text].to_s
+        next if text.empty? && !event[:delay].to_f.positive?
+
+        count += 1
+        raise ResourceLimitError, "Too many session frames (max #{Config::DEFAULTS[:limits][:max_frames]})" if count > Config::DEFAULTS[:limits][:max_frames]
+
+        replay.feed(text) unless text.empty?
+        snapshot = event[:screen] || replay.render_lines
+        characters += snapshot.sum(&:length)
+        if characters > Config::DEFAULTS[:limits][:max_characters]
+          raise ResourceLimitError, "Session snapshots are too large (max #{Config::DEFAULTS[:limits][:max_characters]} characters)"
+        end
+        yield event, snapshot
+      end
+    end
+  end
+end