shellfie 0.1.1 → 1.1.0

data/lib/shellfie/line_layout.rb

@@ -0,0 +1,146 @@
+# 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
+      [@config.window[:height], @config.window[:max_height]].compact.each do |height|
+        available_height = 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|
+        TextMetrics.graphemes(segment.text).each do |char|
+          width = TextMetrics.grapheme_width(char, ambiguous_width: ambiguous_width)
+          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, ambiguous_width: ambiguous_width)
+        next if text.empty?
+
+        result << copy_segment(segment, text)
+        remaining -= TextMetrics.cell_width(text, ambiguous_width: ambiguous_width)
+      end
+    end
+
+    def scroll_segments(segments, max_cells)
+      total_cells = segments.sum { |segment| TextMetrics.cell_width(segment.text, ambiguous_width: ambiguous_width) }
+      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, ambiguous_width: ambiguous_width)
+        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, ambiguous_width: ambiguous_width) : 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.underline_style,
+        segment.underline_color,
+        segment.dim,
+        segment.reverse,
+        segment.strikethrough,
+        segment.overline,
+        segment.blink,
+        segment.conceal,
+        segment.link
+      ]
+    end
+
+    def ambiguous_width
+      @config.window[:ambiguous_width]
+    end
+  end
+end

data/lib/shellfie/output_writer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tempfile"
+require "tmpdir"
+
+module Shellfie
+  class OutputWriter
+    class << self
+      def write(path, extension:, io: nil)
+        FileUtils.mkdir_p(output_directory(path)) unless stdout?(path)
+        temp = Tempfile.new(["shellfie", ".#{extension}"], output_directory(path), binmode: true)
+        temp.close
+        yield temp.path
+
+        if stdout?(path)
+          return File.binread(temp.path) unless io
+
+          File.open(temp.path, "rb") { |source| IO.copy_stream(source, io) }
+          return path
+        end
+
+        FileUtils.mv(temp.path, path)
+        path
+      ensure
+        if temp
+          temp.close unless temp.closed?
+          File.delete(temp.path) if File.exist?(temp.path)
+        end
+      end
+
+      private
+
+      def stdout?(path)
+        path == "-"
+      end
+
+      def output_directory(path)
+        return Dir.tmpdir if stdout?(path)
+
+        directory = File.dirname(path)
+        directory == "." ? Dir.pwd : directory
+      end
+    end
+  end
+end

data/lib/shellfie/parser.rb

@@ -3,88 +3,241 @@
 require "yaml"
 require_relative "config"
 require_relative "errors"
+require_relative "parser_validation"
+require_relative "yaml_safety"
 
 module Shellfie
   class Parser
+    MAX_INCLUDE_BYTES = 1_048_576
+    MAX_INCLUDE_DEPTH = 50
+    MAX_INCLUDE_FILES = 100
+    MAX_TOTAL_INCLUDE_BYTES = 10 * MAX_INCLUDE_BYTES
+
     class << self
-      def parse(path)
-        raise ParseError, "Configuration file not found: #{path}" unless File.exist?(path)
+      include ParserValidation
 
-        content = File.read(path)
-        parse_string(content)
+      def parse(path)
+        return parse_string($stdin.read(MAX_INCLUDE_BYTES + 1), base_dir: Dir.pwd) if path == "-"
+        source_path = File.realpath(path)
+        content = read_config(source_path)
+        state = { files: 1, bytes: content.bytesize, cache: {}, sources: {} }
+        parse_string(content, base_dir: File.dirname(source_path), include_stack: [source_path], source_name: source_path,
+                              include_state: state)
+      rescue Errno::ENOENT
+        raise ParseError, "Configuration file not found: #{path}"
       end
 
-      def parse_string(content)
-        raw = YAML.safe_load(content, symbolize_names: true)
+      def parse_string(content, base_dir: nil, include_stack: [], source_name: nil, include_state: nil)
+        raise ParseError, "Configuration is too large (max #{MAX_INCLUDE_BYTES} bytes)" if content.bytesize > MAX_INCLUDE_BYTES
+
+        raw = YAML.safe_load(content, symbolize_names: true, aliases: true)
+        YamlSafety.validate_tree!(raw)
+        if base_dir
+          include_state ||= { files: 1, bytes: content.bytesize, cache: {}, sources: {} }
+          raw = apply_includes(raw, base_dir, stack: include_stack, root: base_dir, state: include_state)
+        end
         validate_config(raw)
-        build_config(raw)
-      rescue Psych::SyntaxError => e
+        sources = (include_stack + Array(include_state&.dig(:cache)&.keys)).uniq
+        build_config(raw, source_paths: sources)
+      rescue Psych::Exception => e
         raise ParseError, "Invalid YAML syntax: #{e.message}"
+      rescue ValidationError => e
+        raise e unless source_name
+
+        documents = [[source_name, content]] + include_state.fetch(:sources, {}).to_a.reverse
+        raise YamlSafety.annotate_validation_error(e, documents)
       end
 
       private
 
-      def validate_config(raw)
-        raise ValidationError, "Empty configuration" if raw.nil? || raw.empty?
-
-        valid_themes = %w[macos ubuntu windows]
-        if raw[:theme] && !valid_themes.include?(raw[:theme])
-          raise ValidationError, "Invalid theme '#{raw[:theme]}'\n  → Available themes: #{valid_themes.join(", ")}"
-        end
-
-        if raw[:lines].nil? && raw[:frames].nil?
-          raise ValidationError, "Configuration must have either 'lines' or 'frames'"
-        end
-      end
-
-      def build_config(raw)
+      def build_config(raw, source_paths: [])
         options = {
+          version: raw[:version],
           theme: raw[:theme],
+          window_theme: raw[:window_theme],
+          color_scheme: raw[:color_scheme],
+          colors: symbolize_hash(raw[:colors]),
+          window_decoration: symbolize_hash(raw[:window_decoration]),
           title: raw[:title],
           window: symbolize_hash(raw[:window]),
           font: symbolize_hash(raw[:font]),
           lines: parse_lines(raw[:lines]),
           animation: symbolize_hash(raw[:animation]),
+          cursor: symbolize_hash(raw[:cursor]),
+          limits: symbolize_hash(raw[:limits]),
           frames: parse_frames(raw[:frames]),
-          headless: raw[:headless] || false
+          headless: raw[:headless] || false,
+          source_paths: source_paths
         }.compact
 
         Config.new(options)
       end
 
+      def apply_includes(raw, base_dir, stack: [], root: base_dir, policy: nil, state:, depth: 0)
+        return raw unless raw.is_a?(Hash) && raw[:include]
+        raise ParseError, "YAML include depth exceeds #{MAX_INCLUDE_DEPTH}" if depth >= MAX_INCLUDE_DEPTH
+
+        policy ||= raw[:include_policy] || "allow"
+        raise ParseError, "include_policy must be allow or root" unless %w[allow root].include?(policy)
+        includes = Array(raw[:include])
+        included_config = includes.reduce({}) do |merged, include_path|
+          raise ParseError, "Included configuration path must be a string" unless include_path.is_a?(String)
+
+          include_file = File.expand_path(include_path, base_dir)
+          raise ParseError, "Included configuration file not found: #{include_path}" unless File.exist?(include_file)
+
+          include_file = File.realpath(include_file)
+          if policy == "root" && include_file != root && !include_file.start_with?("#{root}#{File::SEPARATOR}")
+            raise ParseError, "Included configuration escapes the configuration root: #{include_path}"
+          end
+          if stack.include?(include_file)
+            chain = (stack + [include_file]).map { |path| File.basename(path) }.join(" -> ")
+            raise ParseError, "Circular YAML include: #{chain}"
+          end
+
+          state[:files] += 1
+          raise ParseError, "Too many YAML includes (max #{MAX_INCLUDE_FILES})" if state[:files] > MAX_INCLUDE_FILES
+          included_raw = state[:cache][include_file]
+          unless included_raw
+            included_content = read_config(include_file)
+            state[:sources][include_file] = included_content
+            state[:bytes] += included_content.bytesize
+            if state[:bytes] > MAX_TOTAL_INCLUDE_BYTES
+              raise ParseError, "Included YAML is too large in total (max #{MAX_TOTAL_INCLUDE_BYTES} bytes)"
+            end
+            included_raw = YAML.safe_load(included_content, symbolize_names: true, aliases: true)
+            YamlSafety.validate_tree!(included_raw)
+            state[:cache][include_file] = included_raw
+          end
+          included_raw = apply_includes(
+            included_raw,
+            File.dirname(include_file),
+            stack: stack + [include_file],
+            root: root,
+            policy: policy,
+            state: state,
+            depth: depth + 1
+          )
+          deep_merge(merged, included_raw || {})
+        end
+
+        deep_merge(included_config, raw.reject { |key, _value| key == :include })
+      end
+
+      def read_config(path)
+        YamlSafety.read_file(path, max_bytes: MAX_INCLUDE_BYTES)
+      end
+
+      def deep_merge(base, overrides)
+        base.merge(overrides) do |_key, left, right|
+          left.is_a?(Hash) && right.is_a?(Hash) ? deep_merge(left, right) : right
+        end
+      end
+
       def symbolize_hash(hash)
         return nil unless hash.is_a?(Hash)
 
-        hash.transform_keys(&:to_sym)
+        Config.normalize_keys(hash)
       end
 
       def parse_lines(lines)
-        return [] unless lines.is_a?(Array)
+        return [] if lines.nil?
 
         lines.map do |line|
           Line.new(
             prompt: line[:prompt],
             command: line[:command],
-            output: line[:output]
+            output: line[:output],
+            prompt_color: line[:prompt_color],
+            command_color: line[:command_color],
+            output_color: line[:output_color],
+            selected: line[:selected] || false
           )
         end
       end
 
       def parse_frames(frames)
-        return [] unless frames.is_a?(Array)
+        return [] if frames.nil?
 
         frames.map do |frame|
           Frame.new(
             prompt: frame[:prompt],
             type: frame[:type],
             output: frame[:output],
-            delay: frame[:delay] || 0
+            screen: frame[:screen],
+            delay: frame[:delay] || 0,
+            prompt_color: frame[:prompt_color],
+            command_color: frame[:command_color],
+            output_color: frame[:output_color]
           )
         end
       end
     end
   end
 
-  Line = Struct.new(:prompt, :command, :output, keyword_init: true)
-  Frame = Struct.new(:prompt, :type, :output, :delay, keyword_init: true)
+  class Line
+    attr_reader :prompt, :command, :output, :prompt_color, :command_color, :output_color, :selected
+
+    def initialize(prompt: nil, command: nil, output: nil, prompt_color: nil, command_color: nil, output_color: nil,
+                   selected: false)
+      @prompt = prompt
+      @command = command
+      @output = output
+      @prompt_color = prompt_color
+      @command_color = command_color
+      @output_color = output_color
+      @selected = selected
+      freeze
+    end
+
+    def to_h
+      {
+        prompt: prompt,
+        command: command,
+        output: output,
+        prompt_color: prompt_color,
+        command_color: command_color,
+        output_color: output_color,
+        selected: selected
+      }.compact
+    end
+
+    def to_s
+      [prompt, command, output].compact.join("\n")
+    end
+  end
+
+  class Frame
+    attr_reader :prompt, :type, :output, :delay, :prompt_color, :command_color, :output_color, :screen
+
+    def initialize(prompt: nil, type: nil, output: nil, delay: 0, prompt_color: nil, command_color: nil,
+                   output_color: nil, screen: nil)
+      @prompt = prompt
+      @type = type
+      @output = output
+      @delay = delay
+      @prompt_color = prompt_color
+      @command_color = command_color
+      @output_color = output_color
+      @screen = screen
+      freeze
+    end
+
+    def to_h
+      {
+        prompt: prompt,
+        type: type,
+        output: output,
+        delay: delay,
+        prompt_color: prompt_color,
+        command_color: command_color,
+        output_color: output_color,
+        screen: screen
+      }.compact
+    end
+
+    def to_s
+      [prompt, type, output, screen, delay].compact.join("\n")
+    end
+  end
 end

data/lib/shellfie/parser_validation.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module Shellfie
+  module ParserValidation
+    MAX_FRAME_DELAY_MS = 86_400_000
+    TOP_LEVEL_KEYS = %i[
+      version include include_policy theme window_theme color_scheme colors window_decoration title window font animation cursor lines frames
+      headless limits
+    ].freeze
+    WINDOW_KEYS = %i[
+      width height padding opacity visible_lines max_lines max_height wrap overflow margin exact_size trim tab_width
+      ambiguous_width osc_policy graphics_policy ansi_state background_gradient scroll_offset
+    ].freeze
+    FONT_KEYS = %i[family size line_height fallback_family italic_family emoji_family].freeze
+    ANIMATION_KEYS = %i[
+      typing_speed command_delay cursor_blink loop typing_jitter seed typing_chunk_size output_delay final_delay max_frames
+      dither palette gif_colors gif_optimize webp_lossless webp_quality webp_method webp_near_lossless
+      apng_prediction loop_count scroll_easing
+      direction loop_offset
+      framerate playback_speed
+    ].freeze
+    CURSOR_KEYS = %i[style color].freeze
+    LIMIT_KEYS = %i[max_lines max_frames max_render_frames max_characters max_pixels max_total_pixels max_temp_bytes].freeze
+    LINE_KEYS = %i[prompt command output prompt_color command_color output_color selected].freeze
+    FRAME_KEYS = %i[prompt type output screen delay prompt_color command_color output_color].freeze
+    COLOR_KEYS = %i[
+      background foreground title_bar title_text title_bar_border border selection black red green yellow blue magenta cyan
+      white bright_black bright_red bright_green bright_yellow bright_blue bright_magenta bright_cyan bright_white
+    ].freeze
+    WINDOW_DECORATION_KEYS = %i[
+      title_bar_height button_size button_spacing button_width corner_radius shadow
+    ].freeze
+    SHADOW_KEYS = %i[blur offset_x offset_y color].freeze
+
+    private
+
+    def validate_config(raw)
+      raise ValidationError, "Empty configuration" if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+      raise ValidationError, "Configuration must be a YAML mapping" unless raw.is_a?(Hash)
+
+      validate_keys!(raw, TOP_LEVEL_KEYS, "configuration")
+      validate_nested_hash!(raw, :window, WINDOW_KEYS)
+      validate_nested_hash!(raw, :font, FONT_KEYS)
+      validate_nested_hash!(raw, :animation, ANIMATION_KEYS)
+      validate_nested_hash!(raw, :cursor, CURSOR_KEYS)
+      validate_nested_hash!(raw, :limits, LIMIT_KEYS)
+      validate_nested_hash!(raw, :colors, COLOR_KEYS)
+      validate_nested_hash!(raw, :window_decoration, WINDOW_DECORATION_KEYS)
+      if raw.dig(:window_decoration, :shadow)
+        validate_nested_hash!(raw[:window_decoration], :shadow, SHADOW_KEYS, "window_decoration.shadow")
+      end
+      validate_theme!(raw[:theme]) if raw[:theme]
+      validate_window_theme!(raw[:window_theme]) if raw[:window_theme]
+      validate_color_scheme!(raw[:color_scheme]) if raw.key?(:color_scheme)
+      if raw[:include_policy] && !%w[allow root].include?(raw[:include_policy])
+        raise ValidationError, "include_policy must be allow or root"
+      end
+
+      raise ValidationError, "Configuration must have either 'lines' or 'frames'" if raw[:lines].nil? && raw[:frames].nil?
+
+      validate_lines!(raw[:lines]) if raw.key?(:lines)
+      validate_frames!(raw[:frames]) if raw.key?(:frames)
+    end
+
+    def validate_theme!(theme)
+      return if ThemeRegistry.valid_theme?(theme)
+
+      raise ValidationError, "Invalid theme '#{theme}'\n  → Available themes: #{ThemeRegistry.available_themes.join(", ")}"
+    end
+
+    def validate_window_theme!(theme)
+      return if ThemeRegistry.valid_window_theme?(theme)
+
+      raise ValidationError, "Invalid window_theme '#{theme}'"
+    end
+
+    def validate_color_scheme!(scheme)
+      return if ThemeRegistry.valid_color_scheme?(scheme)
+
+      raise ValidationError, "Invalid color_scheme '#{scheme}'"
+    end
+
+    def validate_nested_hash!(raw, key, allowed_keys, context = key.to_s)
+      return unless raw.key?(key)
+      raise ValidationError, "#{key} must be a mapping" unless raw[key].is_a?(Hash)
+
+      validate_keys!(raw[key], allowed_keys, context) if allowed_keys
+    end
+
+    def validate_keys!(hash, allowed_keys, context)
+      unknown_keys = hash.keys - allowed_keys
+      return if unknown_keys.empty?
+
+      suggestions = unknown_keys.filter_map do |key|
+        match = DidYouMean::SpellChecker.new(dictionary: allowed_keys.map(&:to_s)).correct(key.to_s).first
+        "#{key} -> #{match}" if match
+      end
+      hint = suggestions.empty? ? "" : " (did you mean #{suggestions.join(", ")}?)"
+      raise ValidationError, "Unknown #{context} key(s): #{unknown_keys.join(", ")}#{hint}"
+    end
+
+    def validate_lines!(lines)
+      raise ValidationError, "lines must be an array" unless lines.is_a?(Array)
+
+      lines.each_with_index do |line, index|
+        raise ValidationError, "lines[#{index}] must be a mapping" unless line.is_a?(Hash)
+
+        validate_keys!(line, LINE_KEYS, "lines[#{index}]")
+        if line.values_at(:prompt, :command, :output).all?(&:nil?)
+          raise ValidationError, "lines[#{index}] must include at least one of prompt, command, or output"
+        end
+        validate_line_values!(line, index)
+      end
+    end
+
+    def validate_frames!(frames)
+      raise ValidationError, "frames must be an array" unless frames.is_a?(Array)
+
+      frames.each_with_index do |frame, index|
+        raise ValidationError, "frames[#{index}] must be a mapping" unless frame.is_a?(Hash)
+
+        validate_keys!(frame, FRAME_KEYS, "frames[#{index}]")
+        validate_frame_shape!(frame, index)
+      end
+    end
+
+    def validate_line_values!(line, index)
+      %i[prompt command output prompt_color command_color output_color].each do |key|
+        validate_string_value!(line[key], "lines[#{index}].#{key}") if line.key?(key)
+      end
+      validate_boolean_value!(line[:selected], "lines[#{index}].selected") if line.key?(:selected)
+    end
+
+    def validate_frame_shape!(frame, index)
+      raise ValidationError, "frames[#{index}].prompt requires type" if frame[:prompt] && frame[:type].nil?
+
+      if frame.values_at(:type, :output, :screen, :delay).all?(&:nil?)
+        raise ValidationError, "frames[#{index}] must include type, output, screen, or delay"
+      end
+
+      validate_string_value!(frame[:prompt], "frames[#{index}].prompt") if frame.key?(:prompt)
+      validate_string_value!(frame[:type], "frames[#{index}].type") if frame.key?(:type)
+      validate_string_value!(frame[:output], "frames[#{index}].output") if frame.key?(:output)
+      if frame.key?(:screen) && (!frame[:screen].is_a?(Array) || !frame[:screen].all?(String))
+        raise ValidationError, "frames[#{index}].screen must be an array of strings"
+      end
+      validate_string_value!(frame[:prompt_color], "frames[#{index}].prompt_color") if frame.key?(:prompt_color)
+      validate_string_value!(frame[:command_color], "frames[#{index}].command_color") if frame.key?(:command_color)
+      validate_string_value!(frame[:output_color], "frames[#{index}].output_color") if frame.key?(:output_color)
+      if frame.key?(:delay)
+        validate_non_negative_integer!(frame[:delay], "frames[#{index}].delay")
+        if frame[:delay] > MAX_FRAME_DELAY_MS
+          raise ValidationError, "frames[#{index}].delay must be at most #{MAX_FRAME_DELAY_MS}"
+        end
+      end
+    end
+
+    def validate_string_value!(value, name)
+      return if value.is_a?(String)
+
+      raise ValidationError, "#{name} must be a string"
+    end
+
+    def validate_boolean_value!(value, name)
+      return if value == true || value == false
+
+      raise ValidationError, "#{name} must be true or false"
+    end
+
+    def validate_non_negative_integer!(value, name)
+      return if value.is_a?(Integer) && value >= 0
+
+      raise ValidationError, "#{name} must be a non-negative integer"
+    end
+  end
+end