ruby_spriter 0.6.5 → 0.6.6

data/lib/ruby_spriter/utils/spritesheet_splitter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'fileutils'
+
+module RubySpriter
+  module Utils
+    # Splits a spritesheet into individual frame images
+    class SpritesheetSplitter
+      # Split spritesheet into individual frames
+      # @param spritesheet_file [String] Path to spritesheet PNG
+      # @param output_dir [String] Directory to save individual frames
+      # @param columns [Integer] Number of columns in grid
+      # @param rows [Integer] Number of rows in grid
+      # @param frames [Integer] Total number of frames to extract
+      def split_into_frames(spritesheet_file, output_dir, columns, rows, frames)
+        FileUtils.mkdir_p(output_dir)
+
+        OutputFormatter.header("Extracting Frames")
+        OutputFormatter.indent("Splitting spritesheet into #{frames} frames to disk...")
+        OutputFormatter.indent("Output directory: #{output_dir}")
+
+        # Get spritesheet dimensions
+        dimensions = get_image_dimensions(spritesheet_file)
+        tile_width = dimensions[:width] / columns
+        tile_height = dimensions[:height] / rows
+
+        # Extract each frame
+        spritesheet_basename = File.basename(spritesheet_file, '.*')
+
+        frames.times do |i|
+          frame_number = i + 1
+          row = i / columns
+          col = i % columns
+
+          x_offset = col * tile_width
+          y_offset = row * tile_height
+
+          frame_filename = "FR#{format('%03d', frame_number)}_#{spritesheet_basename}.png"
+          frame_path = File.join(output_dir, frame_filename)
+
+          extract_tile(spritesheet_file, frame_path, tile_width, tile_height, x_offset, y_offset)
+        end
+
+        OutputFormatter.indent("✅ Frames extracted successfully\n")
+      end
+
+      private
+
+      def get_image_dimensions(image_file)
+        cmd = [
+          'magick',
+          'identify',
+          '-format', '%wx%h',
+          PathHelper.quote_path(image_file)
+        ].join(' ')
+
+        stdout, stderr, status = Open3.capture3(cmd)
+
+        unless status.success?
+          raise ProcessingError, "Could not get image dimensions: #{stderr}"
+        end
+
+        width, height = stdout.strip.split('x').map(&:to_i)
+        { width: width, height: height }
+      end
+
+      def extract_tile(source_file, output_file, width, height, x_offset, y_offset)
+        cmd = [
+          'magick',
+          'convert',
+          PathHelper.quote_path(source_file),
+          '-crop', "#{width}x#{height}+#{x_offset}+#{y_offset}",
+          '+repage',
+          PathHelper.quote_path(output_file)
+        ].join(' ')
+
+        stdout, stderr, status = Open3.capture3(cmd)
+
+        unless status.success?
+          raise ProcessingError, "Could not extract frame: #{stderr}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_spriter/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RubySpriter
-  VERSION = '0.6.5'
+  VERSION = '0.6.6'
   VERSION_DATE = '2025-10-23'
   METADATA_VERSION = '0.6'
 end

data/lib/ruby_spriter/video_processor.rb

@@ -27,26 +27,26 @@ module RubySpriter
       rows = (frame_count.to_f / columns).ceil
 
       Utils::OutputFormatter.header("Creating Spritesheet")
-      
+
       temp_file = output_file.sub('.png', '_temp.png')
-      
+
       create_with_ffmpeg(video_file, temp_file, duration, columns, rows, frame_count)
-      
+
       # Embed metadata
       MetadataManager.embed(
-        temp_file, 
+        temp_file,
         output_file,
         columns: columns,
         rows: rows,
         frames: frame_count,
         debug: options[:debug]
       )
-      
+
       # Clean up temp file
       File.delete(temp_file) if File.exist?(temp_file)
-      
+
       file_size = File.size(output_file)
-      
+
       # Display results with Godot instructions
       display_spritesheet_results(output_file, file_size, columns, rows, frame_count)
 

data/lib/ruby_spriter.rb

@@ -15,6 +15,7 @@ require_relative 'ruby_spriter/version'
 require_relative 'ruby_spriter/utils/path_helper'
 require_relative 'ruby_spriter/utils/file_helper'
 require_relative 'ruby_spriter/utils/output_formatter'
+require_relative 'ruby_spriter/utils/spritesheet_splitter'
 
 # Load core components
 require_relative 'ruby_spriter/platform'

data/spec/ruby_spriter/cli_spec.rb

@@ -155,6 +155,32 @@ RSpec.describe RubySpriter::CLI do
         end.to raise_error(SystemExit)
       end
     end
+
+    describe '--overwrite flag' do
+      it 'sets overwrite option to true' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:overwrite]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--video', 'test.mp4', '--overwrite'])
+      end
+
+      it 'defaults to false when not specified' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:overwrite]).to be_nil
+          processor_double
+        end
+
+        described_class.start(['--video', 'test.mp4'])
+      end
+    end
   end
 
   describe '--image flag' do
@@ -425,6 +451,225 @@ RSpec.describe RubySpriter::CLI do
 
         described_class.start(['--image', fixture_with_meta, '--output', 'custom_output.png'])
       end
+
+      it 'works with --overwrite option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:remove_bg]).to eq(true)
+          expect(options[:overwrite]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--remove-bg', '--overwrite'])
+      end
+
+      it 'works with --overwrite and --output options combined' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:scale_percent]).to eq(50)
+          expect(options[:output]).to eq('custom.png')
+          expect(options[:overwrite]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--scale', '50', '--output', 'custom.png', '--overwrite'])
+      end
+    end
+
+    describe 'output filename behavior with processing' do
+      it 'generates unique filename by default when processing without --output' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock GimpProcessor to return a processed file
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('input-nobg-fuzzy_20251023_123456_789.png')
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          remove_bg: true,
+          overwrite: false
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+        allow(processor).to receive(:gimp_path).and_return('/usr/bin/gimp')
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return the uniquely-named file from GIMP processing
+        expect(result[:output_file]).to match(/-nobg-fuzzy.*\.png$/)
+      end
+
+      it 'overwrites output file when --overwrite is specified' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock GimpProcessor - with overwrite:true, it should return same filename
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('input-scaled-50pct.png')
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          scale_percent: 50,
+          overwrite: true
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+        allow(processor).to receive(:gimp_path).and_return('/usr/bin/gimp')
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return the base filename (no timestamp)
+        expect(result[:output_file]).to eq('input-scaled-50pct.png')
+      end
+
+      it 'generates unique output filename when --output is used without --overwrite' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock ensure_unique_output to verify it's called correctly
+        allow(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output) do |path, overwrite:|
+          expect(path).to eq('custom_output.png')
+          expect(overwrite).to eq(false)
+          'custom_output_20251023_123456_789.png'
+        end
+
+        # Mock GimpProcessor
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('temp-processed.png')
+
+        # Mock file operations
+        allow(FileUtils).to receive(:cp)
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          remove_bg: true,
+          output: 'custom_output.png',
+          overwrite: false
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+        allow(processor).to receive(:gimp_path).and_return('/usr/bin/gimp')
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return unique filename
+        expect(result[:output_file]).to match(/custom_output_\d{8}_\d{6}_\d{3}\.png$/)
+      end
+
+      it 'uses exact output filename when --output and --overwrite are both specified' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock ensure_unique_output to verify it's called with overwrite:true
+        allow(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output) do |path, overwrite:|
+          expect(path).to eq('exact_output.png')
+          expect(overwrite).to eq(true)
+          'exact_output.png'
+        end
+
+        # Mock GimpProcessor
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('temp-processed.png')
+
+        # Mock file operations
+        allow(FileUtils).to receive(:cp)
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          scale_percent: 50,
+          output: 'exact_output.png',
+          overwrite: true
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+        allow(processor).to receive(:gimp_path).and_return('/usr/bin/gimp')
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return exact filename (no timestamp)
+        expect(result[:output_file]).to eq('exact_output.png')
+      end
+
+      it 'generates unique filename when using --sharpen alone without --output' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock GimpProcessor to return a sharpened file
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('input-sharpened_20251023_123456_789.png')
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          sharpen: true,
+          overwrite: false
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return the uniquely-named sharpened file
+        expect(result[:output_file]).to match(/-sharpened.*\.png$/)
+      end
+
+      it 'overwrites sharpened file when --sharpen with --overwrite' do
+        # Mock all dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+
+        # Mock GimpProcessor - with overwrite:true, should return base filename
+        gimp_double = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_double)
+        allow(gimp_double).to receive(:process).and_return('input-sharpened.png')
+
+        processor = RubySpriter::Processor.new(
+          image: fixture_with_meta,
+          sharpen: true,
+          overwrite: true
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+
+        result = nil
+        expect { result = processor.run }.to output(/SUCCESS/).to_stdout
+
+        # Should return the base filename (no timestamp)
+        expect(result[:output_file]).to eq('input-sharpened.png')
+      end
     end
   end
 
@@ -763,6 +1008,19 @@ RSpec.describe RubySpriter::CLI do
 
         described_class.start(['--video', fixture_video, '--output', 'custom_spritesheet.png'])
       end
+
+      it 'works with --save-frames option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:save_frames]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--save-frames'])
+      end
     end
 
     describe 'preset configurations' do
@@ -1117,6 +1375,83 @@ RSpec.describe RubySpriter::CLI do
           '--debug'
         ])
       end
+
+      it 'works with --overwrite option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:overwrite]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--overwrite'])
+      end
+    end
+
+    describe 'default output filename behavior' do
+      it 'generates consolidated_spritesheet.png when no --output specified' do
+        # Mock all the dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output) do |path, overwrite:|
+          expect(path).to eq('consolidated_spritesheet.png')
+          expect(overwrite).to eq(false)
+          'consolidated_spritesheet.png'
+        end
+
+        consolidator_double = instance_double(RubySpriter::Consolidator)
+        allow(RubySpriter::Consolidator).to receive(:new).and_return(consolidator_double)
+        allow(consolidator_double).to receive(:consolidate).and_return({
+          output_file: 'consolidated_spritesheet.png',
+          columns: 2,
+          rows: 4,
+          frames: 8
+        })
+
+        processor = RubySpriter::Processor.new(
+          consolidate: [spritesheet_4x2, spritesheet_6x2],
+          overwrite: false
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+
+        # Capture output to suppress console messages
+        expect { processor.run }.to output(/SUCCESS/).to_stdout
+      end
+
+      it 'respects --overwrite flag with default filename' do
+        # Mock all the dependencies
+        allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+        allow(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output) do |path, overwrite:|
+          expect(path).to eq('consolidated_spritesheet.png')
+          expect(overwrite).to eq(true)
+          'consolidated_spritesheet.png'
+        end
+
+        consolidator_double = instance_double(RubySpriter::Consolidator)
+        allow(RubySpriter::Consolidator).to receive(:new).and_return(consolidator_double)
+        allow(consolidator_double).to receive(:consolidate).and_return({
+          output_file: 'consolidated_spritesheet.png',
+          columns: 2,
+          rows: 4,
+          frames: 8
+        })
+
+        processor = RubySpriter::Processor.new(
+          consolidate: [spritesheet_4x2, spritesheet_6x2],
+          overwrite: true
+        )
+
+        allow(processor).to receive(:check_dependencies!)
+        allow(processor).to receive(:setup_temp_directory)
+        allow(processor).to receive(:cleanup)
+
+        # Capture output to suppress console messages
+        expect { processor.run }.to output(/SUCCESS/).to_stdout
+      end
     end
   end
 
@@ -1138,5 +1473,33 @@ RSpec.describe RubySpriter::CLI do
         end.to raise_error(SystemExit)
       end
     end
+
+    describe '--split option' do
+      it 'parses split option with R:C format' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:split]).to eq('4:4')
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--split', '4:4'])
+      end
+    end
+
+    describe '--override-md option' do
+      it 'sets override_md option to true' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:override_md]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--split', '4:4', '--override-md'])
+      end
+    end
   end
 end