shellfie 0.1.1 → 1.0.0

data/lib/shellfie/animation_frame_builder.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "animation_scroll_easing"
+require_relative "animation_timeline"
+
+module Shellfie
+  class AnimationFrameBuilder
+    def initialize(config)
+      @config = config
+      @random = Random.new(0)
+      @scroll_easing = AnimationScrollEasing.new(config)
+    end
+
+    def build
+      return [{ lines: @config.lines, delay: @config.animation[:final_delay] }] if @config.frames.empty?
+
+      frames = []
+      current_lines = []
+      AnimationTimeline.new(@config).each do |event|
+        case event.kind
+        when :command
+          frames.concat(command_frames(current_lines, event.frame))
+        when :output
+          frames.concat(output_frames(current_lines, event.frame))
+        when :pause
+          frames << { lines: build_display_lines(current_lines), delay: event.frame.delay }
+        end
+      end
+
+      if @config.animation[:final_delay].positive?
+        frames << { lines: build_display_lines(current_lines), delay: @config.animation[:final_delay] }
+      end
+      frames
+    end
+
+    def cursor_text
+      glyph = case @config.cursor[:style]
+              when "bar"
+                "|"
+              when "underline"
+                "_"
+              else
+                "█"
+              end
+      color = @config.cursor[:color]
+      return glyph unless color
+
+      "#{ansi_color(color)}#{glyph}\e[0m"
+    end
+
+    private
+
+    def command_frames(current_lines, frame)
+      prompt = frame.prompt || ""
+      frames = build_typing_frames(current_lines.dup, frame)
+      current_lines << command_line(prompt, frame.type, prompt_color: frame.prompt_color, command_color: frame.command_color)
+      frames.concat(command_pause_frames(current_lines, frame))
+      frames
+    end
+
+    def build_typing_frames(base_lines, frame)
+      frames = []
+      prompt = frame.prompt || ""
+      command = frame.type
+      chars = command.chars
+      chunk_size = @config.animation[:typing_chunk_size]
+
+      (chunk_size..chars.length).step(chunk_size).each do |index|
+        typed = chars.first(index).join
+        frames << typing_frame(base_lines, frame, typed)
+      end
+
+      frames << typing_frame(base_lines, frame, command) if chars.length % chunk_size != 0 || frames.empty?
+      final_lines = base_lines.dup
+      final_lines << command_line(prompt, command, prompt_color: frame.prompt_color, command_color: frame.command_color)
+      frames << { lines: build_display_lines(final_lines), delay: @config.animation[:typing_speed] }
+      frames
+    end
+
+    def typing_frame(base_lines, frame, typed)
+      lines = base_lines.dup
+      lines << command_line(
+        frame.prompt || "",
+        typed,
+        cursor: true,
+        prompt_color: frame.prompt_color,
+        command_color: frame.command_color
+      )
+      {
+        lines: build_display_lines(lines),
+        delay: jittered_delay(@config.animation[:typing_speed], @config.animation[:typing_jitter])
+      }
+    end
+
+    def command_pause_frames(current_lines, frame)
+      delay = @config.animation[:command_delay]
+      return [] unless delay.positive?
+      return [{ lines: build_display_lines(current_lines), delay: delay }] unless @config.animation[:cursor_blink]
+
+      half_delay = [delay / 2, 1].max
+      [
+        { lines: build_display_lines(current_lines[0...-1] + [cursor_command_line(frame)]), delay: half_delay },
+        { lines: build_display_lines(current_lines), delay: delay - half_delay }
+      ]
+    end
+
+    def output_frames(current_lines, frame)
+      output_lines = frame.output.to_s.split("\n", -1)
+      output_delay = @config.animation[:output_delay]
+
+      if output_delay.positive?
+        output_lines.each_with_index.each_with_object([]) do |(line, index), frames|
+          previous_count = current_lines.size
+          current_lines << { output: line, output_color: frame.output_color }
+          delay = @scroll_easing.output_delay(output_delay, index, output_lines.size)
+          frames.concat(
+            @scroll_easing.transition_frames(
+              build_display_lines(current_lines),
+              delay: delay,
+              previous_count: previous_count
+            )
+          )
+        end
+      else
+        output_lines.each { |line| current_lines << { output: line, output_color: frame.output_color } }
+        [{ lines: build_display_lines(current_lines), delay: frame.delay || 100 }]
+      end
+    end
+
+    def command_line(prompt, command, cursor: false, prompt_color: nil, command_color: nil)
+      { prompt: prompt, command: command, cursor: cursor, prompt_color: prompt_color, command_color: command_color }
+    end
+
+    def cursor_command_line(frame)
+      command_line(
+        frame.prompt || "",
+        frame.type,
+        cursor: true,
+        prompt_color: frame.prompt_color,
+        command_color: frame.command_color
+      )
+    end
+
+    def build_display_lines(lines_data)
+      lines_data.map do |line_data|
+        if line_data[:prompt]
+          command = line_data[:command].to_s
+          command += cursor_text if line_data[:cursor]
+          Line.new(
+            prompt: line_data[:prompt],
+            command: command,
+            output: nil,
+            prompt_color: line_data[:prompt_color],
+            command_color: line_data[:command_color]
+          )
+        else
+          Line.new(prompt: nil, command: nil, output: line_data[:output], output_color: line_data[:output_color])
+        end
+      end
+    end
+
+    def ansi_color(color)
+      return "" unless 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)
+      "\e[38;2;#{r};#{g};#{b}m"
+    end
+
+    def jittered_delay(base_delay, jitter)
+      return base_delay unless jitter.positive?
+
+      factor = 1.0 + @random.rand(-jitter..jitter)
+      [(base_delay * factor).round, 1].max
+    end
+  end
+end

data/lib/shellfie/animation_scroll_easing.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class AnimationScrollEasing
+    def initialize(config)
+      @config = config
+    end
+
+    def output_delay(base_delay, index, total)
+      return base_delay if total <= 1 || easing == "linear"
+
+      progress = index.to_f / (total - 1)
+      [(base_delay * delay_factor(progress)).round, 1].max
+    end
+
+    def transition_frames(lines, delay:, previous_count:)
+      return [{ lines: lines, delay: delay }] unless scroll_transition?(delay, previous_count)
+
+      delays = split_delay(delay, scroll_frame_count(delay))
+      delays.each_with_index.map do |frame_delay, index|
+        progress = (index + 1).to_f / delays.size
+        {
+          lines: lines,
+          delay: frame_delay,
+          window: { scroll_offset: scroll_progress(progress) }
+        }
+      end
+    end
+
+    private
+
+    def easing
+      @config.animation[:scroll_easing]
+    end
+
+    def scroll_transition?(delay, previous_count)
+      visible_lines = @config.window[:visible_lines]
+      visible_lines && previous_count >= visible_lines && delay.positive?
+    end
+
+    def scroll_frame_count(delay)
+      [[[(delay / 40.0).ceil, 1].max, 4].min, delay].min
+    end
+
+    def split_delay(delay, count)
+      base_delay = delay / count
+      remainder = delay % count
+      Array.new(count) { |index| base_delay + (index < remainder ? 1 : 0) }
+    end
+
+    def delay_factor(progress)
+      case easing
+      when "ease_in"
+        0.75 + progress * 0.5
+      when "ease_out"
+        1.25 - progress * 0.5
+      when "ease_in_out"
+        0.75 + (0.5 - (progress - 0.5).abs) * 1.0
+      else
+        1.0
+      end
+    end
+
+    def scroll_progress(progress)
+      case easing
+      when "ease_in"
+        progress**2
+      when "ease_out"
+        1.0 - ((1.0 - progress)**2)
+      when "ease_in_out"
+        0.5 - Math.cos(progress * Math::PI) / 2.0
+      else
+        progress
+      end
+    end
+  end
+end

data/lib/shellfie/animation_timeline.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class AnimationTimeline
+    Event = Struct.new(:kind, :frame, keyword_init: true)
+
+    def initialize(config)
+      @config = config
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @config.frames.each do |frame|
+        yield Event.new(kind: :command, frame: frame) if frame.type
+        yield Event.new(kind: :output, frame: frame) if frame.output
+        yield Event.new(kind: :pause, frame: frame) if pause_frame?(frame)
+      end
+    end
+
+    private
+
+    def pause_frame?(frame)
+      frame.delay&.positive? && frame.output.nil? && frame.type.nil?
+    end
+  end
+end

data/lib/shellfie/ansi_colors.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Shellfie
+  module AnsiColors
+    COLORS = {
+      30 => :black,
+      31 => :red,
+      32 => :green,
+      33 => :yellow,
+      34 => :blue,
+      35 => :magenta,
+      36 => :cyan,
+      37 => :white,
+      90 => :bright_black,
+      91 => :bright_red,
+      92 => :bright_green,
+      93 => :bright_yellow,
+      94 => :bright_blue,
+      95 => :bright_magenta,
+      96 => :bright_cyan,
+      97 => :bright_white
+    }.freeze
+
+    BG_COLORS = {
+      40 => :black,
+      41 => :red,
+      42 => :green,
+      43 => :yellow,
+      44 => :blue,
+      45 => :magenta,
+      46 => :cyan,
+      47 => :white,
+      100 => :bright_black,
+      101 => :bright_red,
+      102 => :bright_green,
+      103 => :bright_yellow,
+      104 => :bright_blue,
+      105 => :bright_magenta,
+      106 => :bright_cyan,
+      107 => :bright_white
+    }.freeze
+
+    XTERM_COLOR_STEPS = [0, 95, 135, 175, 215, 255].freeze
+
+    module_function
+
+    def parse_extended_color(codes, index)
+      return [index, nil] if codes[index + 1].nil?
+
+      case codes[index + 1]
+      when 5
+        color_index = codes[index + 2]
+        return [index, nil] unless color_index
+
+        [index + 2, color_256(color_index)]
+      when 2
+        rgb = codes.values_at(index + 2, index + 3, index + 4)
+        return [index, nil] unless rgb.all? { |value| value.is_a?(Integer) && value.between?(0, 255) }
+
+        [index + 4, format("#%02x%02x%02x", *rgb)]
+      else
+        [index, nil]
+      end
+    end
+
+    def color_256(index)
+      return nil unless index.is_a?(Integer) && index.between?(0, 255)
+
+      if index < 16
+        standard_colors[index]
+      elsif index < 232
+        color_cube(index - 16)
+      else
+        gray = (index - 232) * 10 + 8
+        format("#%02x%02x%02x", gray, gray, gray)
+      end
+    end
+
+    def standard_colors
+      %i[
+        black red green yellow blue magenta cyan white
+        bright_black bright_red bright_green bright_yellow
+        bright_blue bright_magenta bright_cyan bright_white
+      ]
+    end
+
+    def color_cube(index)
+      r = XTERM_COLOR_STEPS[index / 36]
+      g = XTERM_COLOR_STEPS[(index % 36) / 6]
+      b = XTERM_COLOR_STEPS[index % 6]
+      format("#%02x%02x%02x", r, g, b)
+    end
+  end
+end

data/lib/shellfie/ansi_line_buffer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Shellfie
+  class AnsiLineBuffer
+    def initialize
+      @cells = []
+      @column = 0
+      @pending_escape = +""
+    end
+
+    def write_escape(sequence)
+      @pending_escape << sequence
+    end
+
+    def write_character(char)
+      case char
+      when "\r"
+        @column = 0
+      when "\b"
+        @column = [@column - 1, 0].max
+        @cells[@column] = nil
+      when "\a"
+        nil
+      else
+        @cells[@column] = "#{@pending_escape}#{char}"
+        @pending_escape = +""
+        @column += 1
+      end
+    end
+
+    def move(command, params)
+      amount = first_param(params, default: 1)
+      case command
+      when "C"
+        @column += amount
+      when "D"
+        @column = [@column - amount, 0].max
+      when "G"
+        @column = [amount - 1, 0].max
+      end
+    end
+
+    def position(params)
+      values = params.to_s.split(";")
+      column = values.length >= 2 ? Integer(values[1], exception: false) : 1
+      @column = [[column || 1, 1].max - 1, 0].max
+    end
+
+    def clear(command, params)
+      mode = first_param(params, default: 0)
+      command == "K" ? clear_line(mode) : clear_screen(mode)
+    end
+
+    def to_s
+      last = @cells.rindex { |cell| !cell.nil? }
+      return @pending_escape unless last
+
+      @cells[0..last].map { |cell| cell || " " }.join + @pending_escape
+    end
+
+    private
+
+    def first_param(params, default:)
+      value = Integer(params.to_s.split(";").first, exception: false)
+      value && value.positive? ? value : default
+    end
+
+    def clear_line(mode)
+      case mode
+      when 1
+        clear_range(0..@column)
+      when 2, 3
+        @cells.clear
+      else
+        @cells.slice!(@column..)
+      end
+    end
+
+    def clear_screen(mode)
+      mode.zero? ? clear_line(0) : clear_line(2)
+    end
+
+    def clear_range(range)
+      range.each { |index| @cells[index] = nil if index < @cells.length }
+    end
+  end
+end

data/lib/shellfie/ansi_normalizer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "ansi_line_buffer"
+
+module Shellfie
+  module AnsiNormalizer
+    ANSI_REGEX = /\e\[([0-9;]*)m/
+    OSC_REGEX = /\e\].*?(?:\a|\e\\)/
+    CSI_CONTROL_REGEX = /\e\[[0-9;?]*[A-Za-ln-z]/
+
+    module_function
+
+    def normalize(text)
+      text = text.gsub(OSC_REGEX, "")
+      text = apply_line_controls(text)
+      text.gsub(CSI_CONTROL_REGEX, "")
+    end
+
+    def apply_line_controls(text)
+      buffer = AnsiLineBuffer.new
+      scanner = StringScanner.new(text)
+
+      until scanner.eos?
+        if scanner.scan(ANSI_REGEX)
+          buffer.write_escape(scanner.matched)
+          next
+        end
+
+        if scanner.scan(/\e\[([0-9;?]*)[JK]/)
+          buffer.clear(scanner.matched[-1], scanner[1])
+          next
+        end
+
+        if scanner.scan(/\e\[([0-9;?]*)[CDG]/)
+          buffer.move(scanner.matched[-1], scanner[1])
+          next
+        end
+
+        if scanner.scan(/\e\[([0-9;?]*)[Hf]/)
+          buffer.position(scanner[1])
+          next
+        end
+
+        buffer.write_character(scanner.getch)
+      end
+
+      buffer.to_s
+    end
+  end
+end