ruby_spriter 0.6.6 → 0.6.7.1

data/lib/ruby_spriter/compression_manager.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module RubySpriter
+  # Manages PNG compression with metadata preservation
+  class CompressionManager
+    # Compress PNG file using ImageMagick with maximum compression
+    # @param input_file [String] Source PNG file
+    # @param output_file [String] Destination PNG file
+    # @param debug [Boolean] Enable debug output
+    def self.compress(input_file, output_file, debug: false)
+      Utils::FileHelper.validate_readable!(input_file)
+
+      cmd = build_compression_command(input_file, output_file)
+
+      if debug
+        Utils::OutputFormatter.indent("DEBUG: Compression command: #{cmd}")
+      end
+
+      stdout, stderr, status = Open3.capture3(cmd)
+
+      unless status.success?
+        raise ProcessingError, "Failed to compress PNG: #{stderr}"
+      end
+
+      Utils::FileHelper.validate_exists!(output_file)
+    end
+
+    # Compress PNG file while preserving embedded metadata
+    # @param input_file [String] Source PNG file
+    # @param output_file [String] Destination PNG file
+    # @param debug [Boolean] Enable debug output
+    def self.compress_with_metadata(input_file, output_file, debug: false)
+      # Read metadata before compression
+      metadata = MetadataManager.read(input_file)
+
+      # Compress the file
+      temp_file = output_file.gsub('.png', '_compress_temp.png')
+      compress(input_file, temp_file, debug: debug)
+
+      # Re-embed metadata if it existed
+      if metadata
+        MetadataManager.embed(
+          temp_file,
+          output_file,
+          columns: metadata[:columns],
+          rows: metadata[:rows],
+          frames: metadata[:frames],
+          debug: debug
+        )
+
+        # Clean up temp file
+        FileUtils.rm_f(temp_file) if File.exist?(temp_file)
+      else
+        # No metadata, just move temp to output
+        FileUtils.mv(temp_file, output_file)
+      end
+    end
+
+    # Get compression statistics
+    # @param original_file [String] Original file path
+    # @param compressed_file [String] Compressed file path
+    # @return [Hash] Statistics including sizes and reduction percentage
+    def self.compression_stats(original_file, compressed_file)
+      original_size = File.size(original_file)
+      compressed_size = File.size(compressed_file)
+      saved_bytes = original_size - compressed_size
+      reduction_percent = (saved_bytes.to_f / original_size * 100.0)
+
+      {
+        original_size: original_size,
+        compressed_size: compressed_size,
+        saved_bytes: saved_bytes,
+        reduction_percent: reduction_percent
+      }
+    end
+
+    private_class_method def self.build_compression_command(input_file, output_file)
+      magick_cmd = Platform.imagemagick_convert_cmd
+
+      # Use maximum PNG compression settings:
+      # - compression-level=9: Maximum zlib compression
+      # - compression-filter=5: Paeth filter (best for most images)
+      # - compression-strategy=1: Filtered strategy
+      # - quality=95: High quality
+      # - strip: Remove all metadata (we'll re-add it later)
+      [
+        magick_cmd,
+        Utils::PathHelper.quote_path(input_file),
+        '-strip',
+        '-define', 'png:compression-level=9',
+        '-define', 'png:compression-filter=5',
+        '-define', 'png:compression-strategy=1',
+        '-quality', '95',
+        Utils::PathHelper.quote_path(output_file)
+      ].join(' ')
+    end
+  end
+end

data/lib/ruby_spriter/consolidator.rb

@@ -58,6 +58,39 @@ module RubySpriter
       }
     end
 
+    # Find all PNG files with spritesheet metadata in a directory
+    # @param directory [String] Directory path to scan
+    # @return [Array<String>] Sorted array of spritesheet file paths
+    def find_spritesheets_in_directory(directory)
+      # Validate directory exists
+      unless File.directory?(directory)
+        raise ValidationError, "Directory not found: #{directory}"
+      end
+
+      # Find all PNG files
+      pattern = File.join(directory, '*.png')
+      png_files = Dir.glob(pattern)
+
+      # Filter to only files with metadata
+      spritesheets = png_files.select do |file|
+        metadata = MetadataManager.read(file)
+        !metadata.nil?
+      end
+
+      # Validate we found at least one
+      if spritesheets.empty?
+        raise ValidationError, "No PNG files with spritesheet metadata found in directory: #{directory}"
+      end
+
+      # Validate we have at least 2
+      if spritesheets.length < 2
+        raise ValidationError, "Found only #{spritesheets.length} spritesheet, need at least 2 for consolidation"
+      end
+
+      # Sort alphabetically by filename
+      spritesheets.sort
+    end
+
     private
 
     def validate_files!(files)

data/lib/ruby_spriter/dependency_checker.rb

@@ -32,12 +32,23 @@ module RubySpriter
           linux: 'sudo apt install imagemagick',
           macos: 'brew install imagemagick'
         }
+      },
+      xvfb: {
+        command: 'xvfb-run --help',
+        pattern: /xvfb-run/i,
+        install: {
+          windows: 'Not required on Windows',
+          linux: 'sudo apt install xvfb',
+          macos: 'Not required on macOS'
+        },
+        optional_for: [:windows, :macos]  # Only required on Linux
       }
     }.freeze
 
     def initialize(verbose: false)
       @verbose = verbose
       @gimp_path = nil
+      @gimp_version = nil
     end
 
     # Check all dependencies
@@ -58,7 +69,7 @@ module RubySpriter
     # @return [Boolean] true if all dependencies are available
     def all_satisfied?
       results = check_all
-      results.all? { |_tool, status| status[:available] }
+      results.all? { |tool, status| status[:available] || status[:optional] }
     end
 
     # Print dependency status report
@@ -70,14 +81,31 @@ module RubySpriter
       puts "=" * 60
       
       results.each do |tool, status|
-        icon = status[:available] ? "✅" : "❌"
-        puts "\n#{icon} #{tool.to_s.upcase}"
-        
+        if status[:optional] && !status[:available]
+          icon = "⚪"
+          optional_text = " (Optional for #{Platform.current})"
+        else
+          icon = status[:available] ? "✅" : "❌"
+          optional_text = ""
+        end
+
+        puts "\n#{icon} #{tool.to_s.upcase}#{optional_text}"
+
         if status[:available]
-          puts "   Found: #{status[:path] || status[:version]}"
+          if tool == :gimp && status[:version]
+            version_str = "GIMP #{status[:version][:full]}"
+            puts "   Found: #{status[:path]}"
+            puts "   Version: #{version_str}"
+          else
+            puts "   Found: #{status[:path] || status[:version]}"
+          end
         else
-          puts "   Status: NOT FOUND"
-          puts "   Install: #{status[:install_cmd]}"
+          if status[:optional]
+            puts "   Status: NOT FOUND (not required for this platform)"
+          else
+            puts "   Status: NOT FOUND"
+            puts "   Install: #{status[:install_cmd]}"
+          end
         end
       end
       
@@ -87,9 +115,16 @@ module RubySpriter
     # Get the found GIMP executable path
     attr_reader :gimp_path
 
+    # Get the detected GIMP version info
+    attr_reader :gimp_version
+
     private
 
     def check_tool(tool, config)
+      # Check if this tool is optional for current platform
+      optional_platforms = config[:optional_for] || []
+      is_optional = optional_platforms.include?(Platform.current)
+
       stdout, stderr, status = Open3.capture3(config[:command])
       output = stdout + stderr
 
@@ -98,13 +133,15 @@ module RubySpriter
         {
           available: true,
           version: version,
-          install_cmd: nil
+          install_cmd: nil,
+          optional: is_optional
         }
       else
         {
           available: false,
           version: nil,
-          install_cmd: config[:install][Platform.current]
+          install_cmd: config[:install][Platform.current],
+          optional: is_optional
         }
       end
     rescue StandardError => e
@@ -112,7 +149,8 @@ module RubySpriter
       {
         available: false,
         version: nil,
-        install_cmd: config[:install][Platform.current]
+        install_cmd: config[:install][Platform.current],
+        optional: is_optional
       }
     end
 
@@ -121,32 +159,44 @@ module RubySpriter
       default_path = Platform.default_gimp_path
       if gimp_exists?(default_path)
         @gimp_path = default_path
-        return gimp_status(true, default_path)
+        @gimp_version = Platform.get_gimp_version(default_path)
+        return gimp_status(true, default_path, @gimp_version)
       end
 
       # Try alternative paths
       Platform.alternative_gimp_paths.each do |path|
         if gimp_exists?(path)
           @gimp_path = path
-          return gimp_status(true, path)
+          @gimp_version = Platform.get_gimp_version(path)
+          return gimp_status(true, path, @gimp_version)
         end
       end
 
       # Not found
-      gimp_status(false, nil)
+      gimp_status(false, nil, nil)
     end
 
     def gimp_exists?(path)
       return false if path.nil? || path.empty?
+
+      # Handle Flatpak GIMP
+      if path.start_with?('flatpak:')
+        flatpak_app = path.sub('flatpak:', '')
+        stdout, _stderr, status = Open3.capture3("flatpak list --app | grep #{flatpak_app}")
+        return status.success? && !stdout.strip.empty?
+      end
+
       File.exist?(path)
     end
 
-    def gimp_status(available, path)
-      {
+    def gimp_status(available, path, version)
+      status = {
         available: available,
         path: path,
         install_cmd: gimp_install_command
       }
+      status[:version] = version if version
+      status
     end
 
     def gimp_install_command