shellfie 0.1.0 → 1.0.0

data/lib/shellfie/ansi_parser.rb

@@ -1,61 +1,40 @@
 # frozen_string_literal: true
 
 require "strscan"
+require_relative "ansi_colors"
+require_relative "ansi_normalizer"
 
 module Shellfie
-  Segment = Struct.new(:text, :foreground, :background, :bold, :italic, :underline, keyword_init: true)
+  Segment = Struct.new(
+    :text,
+    :foreground,
+    :background,
+    :bold,
+    :italic,
+    :underline,
+    :dim,
+    :reverse,
+    :strikethrough,
+    :overline,
+    keyword_init: true
+  )
 
   class AnsiParser
     ANSI_REGEX = /\e\[([0-9;]*)m/
 
-    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
-
-    def initialize
+    def initialize(state_mode: :persistent)
+      @state_mode = state_mode.to_sym
       reset_state
     end
 
     def parse(text)
+      reset_state if @state_mode == :line
+
       segments = []
-      scanner = StringScanner.new(text)
+      scanner = StringScanner.new(AnsiNormalizer.normalize(text.to_s))
       current_text = +""
 
-      while !scanner.eos?
+      until scanner.eos?
         if scanner.scan(ANSI_REGEX)
           unless current_text.empty?
             segments << create_segment(current_text)
@@ -79,6 +58,10 @@ module Shellfie
       @bold = false
       @italic = false
       @underline = false
+      @dim = false
+      @reverse = false
+      @strikethrough = false
+      @overline = false
     end
 
     def create_segment(text)
@@ -88,14 +71,18 @@ module Shellfie
         background: @background,
         bold: @bold,
         italic: @italic,
-        underline: @underline
+        underline: @underline,
+        dim: @dim,
+        reverse: @reverse,
+        strikethrough: @strikethrough,
+        overline: @overline
       )
     end
 
     def process_codes(codes_str)
       return reset_state if codes_str.empty?
 
-      codes = codes_str.split(";").map(&:to_i)
+      codes = codes_str.split(";").map { |code| code.empty? ? 0 : code.to_i }
       i = 0
 
       while i < codes.length
@@ -106,69 +93,48 @@ module Shellfie
           reset_state
         when 1
           @bold = true
+        when 2
+          @dim = true
         when 3
           @italic = true
         when 4
           @underline = true
+        when 7
+          @reverse = true
+        when 9
+          @strikethrough = true
         when 22
           @bold = false
+          @dim = false
         when 23
           @italic = false
         when 24
           @underline = false
+        when 27
+          @reverse = false
+        when 29
+          @strikethrough = false
         when 30..37, 90..97
-          @foreground = COLORS[code]
+          @foreground = AnsiColors::COLORS[code]
         when 38
-          i, @foreground = parse_extended_color(codes, i)
+          i, @foreground = AnsiColors.parse_extended_color(codes, i)
         when 39
           @foreground = nil
         when 40..47, 100..107
-          @background = BG_COLORS[code]
+          @background = AnsiColors::BG_COLORS[code]
         when 48
-          i, @background = parse_extended_color(codes, i)
+          i, @background = AnsiColors.parse_extended_color(codes, i)
         when 49
           @background = nil
+        when 53
+          @overline = true
+        when 55
+          @overline = false
         end
 
         i += 1
       end
     end
 
-    def parse_extended_color(codes, i)
-      return [i, nil] if codes[i + 1].nil?
-
-      case codes[i + 1]
-      when 5
-        color_index = codes[i + 2]
-        [i + 2, color_256(color_index)]
-      when 2
-        r, g, b = codes[i + 2], codes[i + 3], codes[i + 4]
-        [i + 4, format("#%02x%02x%02x", r, g, b)]
-      else
-        [i, nil]
-      end
-    end
-
-    def color_256(index)
-      return nil unless index
-
-      if index < 16
-        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
-        ]
-        standard_colors[index]
-      elsif index < 232
-        index -= 16
-        r = (index / 36) * 51
-        g = ((index % 36) / 6) * 51
-        b = (index % 6) * 51
-        format("#%02x%02x%02x", r, g, b)
-      else
-        gray = (index - 232) * 10 + 8
-        format("#%02x%02x%02x", gray, gray, gray)
-      end
-    end
   end
 end

data/lib/shellfie/cli.rb

@@ -2,13 +2,19 @@
 
 require "optparse"
 require_relative "../shellfie"
+require_relative "cli_generate"
+require_relative "cli_info"
+require_relative "dependency_checker"
 
 module Shellfie
   class CLI
-    COMMANDS = %w[generate init themes validate version help].freeze
+    include CLIGenerate
+    include CLIInfo
+
+    COMMANDS = %w[generate init themes validate inspect doctor version help].freeze
 
     def initialize(args)
-      @args = args
+      @args = args.dup
       @options = {}
     end
 
@@ -26,190 +32,31 @@ module Shellfie
         run_themes
       when "validate"
         run_validate
+      when "inspect"
+        run_inspect
+      when "doctor"
+        run_doctor
       when "version", "-v", "--version"
         run_version
       when "help", "-h", "--help"
         show_help
       else
-        puts "Unknown command: #{command}"
-        puts "Run 'shellfie help' for usage information."
+        warn_error "Unknown command: #{command}"
+        warn_error "Run 'shellfie help' for usage information."
         exit 1
       end
     rescue Shellfie::Error => e
-      puts "Error: #{e.message}"
+      warn_error "Error: #{e.message}"
       exit determine_exit_code(e)
+    rescue OptionParser::ParseError => e
+      warn_error "Error: #{e.message}"
+      exit 1
     end
 
     private
 
-    def run_generate
-      parser = OptionParser.new do |opts|
-        opts.banner = "Usage: shellfie generate INPUT_FILE [options]"
-
-        opts.on("-o", "--output PATH", "Output file path (required)") do |path|
-          @options[:output] = path
-        end
-
-        opts.on("-t", "--theme NAME", "Override theme (macos, ubuntu, windows)") do |theme|
-          @options[:theme] = theme
-        end
-
-        opts.on("-a", "--animate", "Generate animated GIF") do
-          @options[:animate] = true
-        end
-
-        opts.on("-s", "--scale FACTOR", "Output scale (1, 2, 3)") do |scale|
-          @options[:scale] = scale.to_i
-        end
-
-        opts.on("-w", "--width PIXELS", Integer, "Override width") do |width|
-          @options[:width] = width
-        end
-
-        opts.on("--no-shadow", "Disable shadow effect") do
-          @options[:shadow] = false
-        end
-
-        opts.on("--transparent", "Transparent background") do
-          @options[:transparent] = true
-        end
-
-        opts.on("--no-header", "Disable window header (headless mode)") do
-          @options[:headless] = true
-        end
-      end
-
-      parser.parse!(@args)
-
-      input_file = @args.shift
-      raise ConfigError, "Input file is required" unless input_file
-      raise ConfigError, "Output file is required (use -o option)" unless @options[:output]
-
-      config = Parser.parse(input_file)
-
-      if @options[:theme] || @options[:width] || @options[:headless]
-        config = Config.new(
-          theme: @options[:theme] || config.theme,
-          title: config.title,
-          window: config.window.merge(@options[:width] ? { width: @options[:width] } : {}),
-          font: config.font,
-          lines: config.lines,
-          animation: config.animation,
-          frames: config.frames,
-          headless: @options[:headless] || config.headless
-        )
-      end
-
-      if @options[:animate] || config.animated?
-        generator = GifGenerator.new(config)
-        output = generator.generate(
-          @options[:output],
-          scale: @options[:scale] || 1,
-          shadow: @options[:shadow] != false
-        )
-      else
-        renderer = Renderer.new(config)
-        output = renderer.render(
-          @options[:output],
-          scale: @options[:scale] || 1,
-          shadow: @options[:shadow] != false,
-          transparent: @options[:transparent] || false
-        )
-      end
-
-      puts "Generated: #{output}"
-    end
-
-    def run_init
-      sample_config = <<~YAML
-        # Shellfie configuration file
-        theme: macos
-        title: "Terminal — zsh"
-
-        window:
-          width: 600
-          padding: 20
-
-        lines:
-          - prompt: "$ "
-            command: "gem install shellfie"
-
-          - output: |
-              Fetching shellfie-#{VERSION}.gem
-              Successfully installed shellfie-#{VERSION}
-              1 gem installed
-
-          - prompt: "$ "
-            command: "shellfie --version"
-
-          - output: "shellfie #{VERSION}"
-      YAML
-
-      puts sample_config
-    end
-
-    def run_themes
-      puts "Available themes:"
-      puts
-      puts "  macos     - macOS Terminal style (red/yellow/green buttons, left side)"
-      puts "  ubuntu    - Ubuntu Terminal style (buttons on right side)"
-      puts "  windows   - Windows Terminal style (square corners, icons)"
-      puts
-      puts "Use: shellfie generate config.yml -o output.png -t THEME_NAME"
-    end
-
-    def run_validate
-      input_file = @args.shift
-      raise ConfigError, "Input file is required" unless input_file
-
-      config = Parser.parse(input_file)
-      puts "✓ Configuration is valid"
-      puts "  Theme: #{config.theme}"
-      puts "  Title: #{config.title}"
-      puts "  Lines: #{config.lines.size}"
-      puts "  Mode: #{config.animated? ? "animated" : "static"}"
-    end
-
-    def run_version
-      puts "shellfie #{VERSION}"
-    end
-
-    def show_help
-      puts <<~HELP
-        Shellfie - Terminal screenshot-style image generator
-
-        Usage: shellfie <command> [options]
-               shf <command> [options]
-
-        Commands:
-          generate    Generate image from configuration file
-          init        Output sample configuration
-          themes      List available themes
-          validate    Validate configuration file
-          version     Show version
-          help        Show this help
-
-        Generate Options:
-          -o, --output PATH      Output file path (required)
-          -t, --theme NAME       Override theme (macos, ubuntu, windows)
-          -a, --animate          Generate animated GIF
-          -s, --scale FACTOR     Output scale (1, 2, 3)
-          -w, --width PIXELS     Override width
-          --no-shadow            Disable shadow effect
-          --no-header            Disable window header (headless mode)
-          --transparent          Transparent background
-
-        Examples:
-          shellfie generate config.yml -o terminal.png
-          shellfie generate config.yml -o demo.gif --animate
-          shellfie generate config.yml -o retina.png --scale 2
-          shellfie init > my-config.yml
-          shellfie themes
-
-          # Short form
-          shf generate config.yml -o terminal.png
-          shf init > config.yml
-      HELP
+    def warn_error(message)
+      $stderr.puts message
     end
 
     def determine_exit_code(error)
@@ -220,6 +67,8 @@ module Shellfie
         3
       when DependencyError
         4
+      when FileSystemError
+        5
       else
         1
       end

data/lib/shellfie/cli_generate.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+
+module Shellfie
+  module CLIGenerate
+    ANIMATED_FORMATS = %w[gif webp apng].freeze
+    STATIC_FORMATS = %w[png svg webp].freeze
+    SUPPORTED_FORMATS = %w[png gif svg webp apng].freeze
+
+    private
+
+    def run_generate
+      build_generate_parser.parse!(@args)
+      input_files = expand_input_paths(@args)
+      raise ConfigError, "Input file is required" if input_files.empty?
+      raise ConfigError, "Output file is required (use -o option)" unless @options[:output]
+      raise ConfigError, "stdout output supports only one input file" if @options[:output] == "-" && input_files.size > 1
+      raise ConfigError, "--format is required when writing to stdout" if @options[:output] == "-" && !@options[:format]
+      input_files.each do |input_file|
+        config = apply_overrides(Parser.parse(input_file))
+        animate = animation_output?(config)
+        format = output_format_for(@options[:output], animate)
+        output_path = output_path_for(input_file, format, multiple: input_files.size > 1)
+        validate_output_mode!(format, animate)
+        ensure_output_writable!(output_path)
+        write_rendered_output(config, output_path, animate: animate, format: format)
+      end
+    end
+
+    def build_generate_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: shellfie generate INPUT_FILE [options]"
+        opts.on("-o", "--output PATH", "Output file path (required)") { |path| @options[:output] = path }
+        opts.on("-t", "--theme NAME", "Override theme (macos, ubuntu, windows)") { |theme| @options[:theme] = theme }
+        opts.on("-a", "--animate", "Generate animated GIF") { @options[:animate] = true }
+        opts.on("-s", "--scale FACTOR", "Output scale (1, 2, 3)") { |scale| @options[:scale] = parse_scale(scale) }
+        opts.on("-w", "--width PIXELS", Integer, "Override width") { |width| @options[:width] = width }
+        opts.on("--fps FPS", Integer, "Typing speed override for animations") { |fps| @options[:fps] = parse_fps(fps) }
+        opts.on("--overflow MODE", "Line overflow mode (clip, wrap, scroll)") { |mode| @options[:overflow] = mode }
+        opts.on("--wrap", "Wrap long lines") { @options[:wrap] = true }
+        opts.on("--no-wrap", "Clip long lines") { @options[:wrap] = false }
+        opts.on("--exact-size", "Make output canvas match the configured window size") { @options[:exact_size] = true }
+        opts.on("--no-shadow", "Disable shadow effect") { @options[:shadow] = false }
+        opts.on("--transparent", "Transparent background") { @options[:transparent] = true }
+        opts.on("--no-header", "Disable window header (headless mode)") { @options[:headless] = true }
+        opts.on("--format FORMAT", "Output format (png, gif, svg, webp, apng)") { |format| @options[:format] = parse_format(format) }
+        opts.on("--force", "Overwrite existing output files") { @options[:force] = true }
+        opts.on("--quiet", "Suppress non-error output") { @options[:quiet] = true }
+        opts.on("--verbose", "Print extra progress information") { @options[:verbose] = true }
+      end
+    end
+
+    def write_rendered_output(config, output_path, animate:, format:)
+      result = animate ? generate_animation(config, output_path, format) : generate_static_image(config, output_path, format)
+      if output_path == "-"
+        $stdout.binmode
+        $stdout.write(result)
+      else
+        puts "Generated: #{result}" unless @options[:quiet]
+      end
+    end
+
+    def generate_animation(config, output_path, format)
+      warn_verbose "Rendering animation to #{output_path}"
+      GifGenerator.new(config).generate(
+        output_path,
+        scale: @options[:scale] || 1,
+        shadow: @options[:shadow] != false,
+        transparent: @options[:transparent] || false,
+        format: format
+      )
+    end
+
+    def generate_static_image(config, output_path, format)
+      warn_verbose "Rendering image to #{output_path}"
+      Renderer.new(config).render(
+        output_path,
+        scale: @options[:scale] || 1,
+        shadow: @options[:shadow] != false,
+        transparent: @options[:transparent] || false,
+        format: format
+      )
+    end
+
+    def apply_overrides(config)
+      window_overrides = build_window_overrides
+      animation_overrides = build_animation_overrides
+      return config if @options.values_at(:theme, :headless).all?(&:nil?) &&
+                       window_overrides.empty? &&
+                       animation_overrides.empty?
+
+      options = config.to_h.merge(
+        theme: @options[:theme] || config.theme,
+        window: config.window.merge(window_overrides),
+        animation: config.animation.merge(animation_overrides),
+        lines: config.lines,
+        frames: config.frames,
+        headless: @options[:headless] || config.headless
+      )
+      Config.new(options)
+    end
+
+    def build_window_overrides
+      {}.tap do |overrides|
+        overrides[:width] = @options[:width] if @options[:width]
+        overrides[:overflow] = @options[:overflow] if @options[:overflow]
+        overrides[:wrap] = @options[:wrap] unless @options[:wrap].nil?
+        overrides[:exact_size] = true if @options[:exact_size]
+      end
+    end
+
+    def build_animation_overrides
+      {}.tap do |overrides|
+        overrides[:typing_speed] = (1_000.0 / @options[:fps]).round if @options[:fps]
+      end
+    end
+
+    def parse_scale(value)
+      scale = Integer(value, exception: false)
+      return scale if [1, 2, 3].include?(scale)
+      raise ValidationError, "scale must be 1, 2, or 3"
+    end
+
+    def parse_fps(value)
+      fps = Integer(value, exception: false)
+      return fps if fps && fps.between?(1, 60)
+      raise ValidationError, "fps must be between 1 and 60"
+    end
+
+    def parse_format(value)
+      format = value.to_s.downcase
+      return format if SUPPORTED_FORMATS.include?(format)
+      raise ValidationError, "format must be one of: #{SUPPORTED_FORMATS.join(", ")}"
+    end
+
+    def validate_output_mode!(format, animate)
+      if animate && ANIMATED_FORMATS.include?(format)
+        return
+      elsif !animate && STATIC_FORMATS.include?(format)
+        return
+      end
+
+      mode = animate ? "animated" : "static"
+      raise ConfigError, "#{mode} output does not support .#{format}"
+    end
+
+    def ensure_output_writable!(path)
+      return if path == "-"
+
+      directory = File.dirname(path)
+      FileUtils.mkdir_p(directory) unless directory == "." || Dir.exist?(directory)
+      return if @options[:force] || !File.exist?(path)
+
+      raise FileSystemError, "Output file already exists: #{path} (use --force to overwrite)"
+    end
+
+    def expand_input_paths(args)
+      args.flat_map do |path|
+        next path if path == "-"
+
+        matches = path.match?(/[*?\[]/) ? Dir.glob(path) : [path]
+        matches.sort
+      end
+    end
+
+    def animation_output?(config)
+      return true if ANIMATED_FORMATS.include?(@options[:format])
+
+      @options[:animate] || config.animated?
+    end
+
+    def output_format_for(path, animate)
+      return @options[:format] if @options[:format]
+      return animate ? "gif" : "png" if path == "-" || batch_directory?(path)
+
+      extension = File.extname(path).delete_prefix(".").downcase
+      extension.empty? ? (animate ? "gif" : "png") : extension
+    end
+
+    def output_path_for(input_file, format, multiple:)
+      return @options[:output] if @options[:output] == "-"
+      return @options[:output] unless multiple || batch_directory?(@options[:output])
+
+      File.join(@options[:output], "#{File.basename(input_file, File.extname(input_file))}.#{format}")
+    end
+
+    def batch_directory?(path)
+      path.end_with?(File::SEPARATOR) || Dir.exist?(path)
+    end
+
+    def warn_verbose(message)
+      $stderr.puts message if @options[:verbose] && !@options[:quiet]
+    end
+  end
+end