ruby_spriter 0.6.5 → 0.6.7

data/lib/ruby_spriter/utils/file_helper.rb

@@ -51,6 +51,31 @@ module RubySpriter
           validate_exists!(path)
           raise ValidationError, "File not readable: #{path}" unless File.readable?(path)
         end
+
+        # Generate unique filename by adding timestamp if file exists
+        # @param path [String] Original file path
+        # @return [String] Unique file path (adds timestamp if original exists)
+        def unique_filename(path)
+          return path unless File.exist?(path)
+
+          dir = File.dirname(path)
+          ext = File.extname(path)
+          basename = File.basename(path, ext)
+          timestamp = Time.now.strftime('%Y%m%d_%H%M%S_%3N') # Include milliseconds
+
+          File.join(dir, "#{basename}_#{timestamp}#{ext}")
+        end
+
+        # Ensure output filename is unique based on overwrite option
+        # @param path [String] Desired output path
+        # @param overwrite [Boolean] If true, return original path; if false, make unique
+        # @return [String] Output path (unique if overwrite is false and file exists)
+        def ensure_unique_output(path, overwrite: false)
+          return path if overwrite
+          return path unless File.exist?(path)
+
+          unique_filename(path)
+        end
       end
     end
   end

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_DATE = '2025-10-23'
+  VERSION = '0.6.7'
+  VERSION_DATE = '2025-10-24'
   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'
@@ -25,6 +26,8 @@ require_relative 'ruby_spriter/metadata_manager'
 require_relative 'ruby_spriter/video_processor'
 require_relative 'ruby_spriter/gimp_processor'
 require_relative 'ruby_spriter/consolidator'
+require_relative 'ruby_spriter/compression_manager'
+require_relative 'ruby_spriter/batch_processor'
 
 # Load orchestration
 require_relative 'ruby_spriter/processor'

data/spec/ruby_spriter/batch_processor_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubySpriter::BatchProcessor do
+  let(:test_dir) { 'E:/test/videos' }
+  let(:output_dir) { 'E:/test/output' }
+  let(:video1) { File.join(test_dir, 'video1.mp4') }
+  let(:video2) { File.join(test_dir, 'video2.mp4') }
+  let(:video3) { File.join(test_dir, 'video3.mp4') }
+
+  let(:options) do
+    {
+      batch: true,
+      dir: test_dir,
+      columns: 4,
+      frame_count: 16,
+      max_width: 320,
+      overwrite: false,
+      debug: false
+    }
+  end
+
+  before do
+    # Mock file system
+    allow(Dir).to receive(:exist?).and_return(true)
+    allow(File).to receive(:exist?).and_return(true)
+    allow(File).to receive(:directory?).with(test_dir).and_return(true)
+    allow(Dir).to receive(:glob).with(File.join(test_dir, '*.mp4')).and_return([video1, video2, video3])
+  end
+
+  describe '#initialize' do
+    it 'raises error if directory does not exist' do
+      allow(File).to receive(:directory?).with(test_dir).and_return(false)
+
+      expect {
+        described_class.new(options)
+      }.to raise_error(RubySpriter::ValidationError, /Directory not found/)
+    end
+
+    it 'initializes with valid options' do
+      processor = described_class.new(options)
+      expect(processor.options).to eq(options)
+    end
+  end
+
+  describe '#find_videos' do
+    it 'finds all MP4 files in directory' do
+      processor = described_class.new(options)
+      videos = processor.find_videos
+
+      expect(videos).to eq([video1, video2, video3])
+    end
+
+    it 'raises error if no videos found' do
+      allow(Dir).to receive(:glob).with(File.join(test_dir, '*.mp4')).and_return([])
+
+      processor = described_class.new(options)
+
+      expect {
+        processor.find_videos
+      }.to raise_error(RubySpriter::ValidationError, /No MP4 files found/)
+    end
+  end
+
+  describe '#process' do
+    let(:video_processor_mock) { instance_double(RubySpriter::VideoProcessor) }
+
+    before do
+      allow(RubySpriter::VideoProcessor).to receive(:new).and_return(video_processor_mock)
+      allow(video_processor_mock).to receive(:create_spritesheet).and_return(
+        { output_file: 'output.png', columns: 4, rows: 4, frames: 16 }
+      )
+      allow(File).to receive(:exist?).and_return(false) # No existing files
+      allow(RubySpriter::Utils::FileHelper).to receive(:spritesheet_filename) do |video|
+        video.gsub('.mp4', '_spritesheet.png')
+      end
+    end
+
+    it 'processes all videos in directory' do
+      processor = described_class.new(options)
+
+      expect(video_processor_mock).to receive(:create_spritesheet).exactly(3).times
+
+      results = processor.process
+
+      expect(results[:processed_count]).to eq(3)
+      expect(results[:outputs].length).to eq(3)
+    end
+
+    it 'outputs to same directory by default' do
+      processor = described_class.new(options)
+
+      expected_output1 = File.join(test_dir, 'video1_spritesheet.png')
+      expect(video_processor_mock).to receive(:create_spritesheet).with(video1, expected_output1)
+
+      processor.process
+    end
+
+    it 'outputs to specified outputdir when provided' do
+      options_with_output = options.merge(outputdir: output_dir)
+      processor = described_class.new(options_with_output)
+
+      allow(File).to receive(:directory?).with(output_dir).and_return(true)
+
+      expected_output1 = File.join(output_dir, 'video1_spritesheet.png')
+      expect(video_processor_mock).to receive(:create_spritesheet).with(video1, expected_output1)
+
+      processor.process
+    end
+
+    it 'creates output directory if it does not exist' do
+      options_with_output = options.merge(outputdir: output_dir)
+      processor = described_class.new(options_with_output)
+
+      allow(File).to receive(:directory?).with(output_dir).and_return(false)
+      expect(FileUtils).to receive(:mkdir_p).with(output_dir)
+
+      processor.process
+    end
+
+    it 'enforces unique filenames unless overwrite is true' do
+      allow(File).to receive(:exist?).with(/video1_spritesheet\.png/).and_return(true)
+      allow(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output).and_call_original
+      allow(RubySpriter::Utils::FileHelper).to receive(:unique_filename).and_return('video1_spritesheet_20251024_123456_789.png')
+
+      processor = described_class.new(options)
+
+      expect(RubySpriter::Utils::FileHelper).to receive(:ensure_unique_output).at_least(:once)
+
+      processor.process
+    end
+
+    it 'continues processing after error in one video' do
+      processor = described_class.new(options)
+
+      allow(video_processor_mock).to receive(:create_spritesheet).and_raise(RubySpriter::ProcessingError, 'Test error')
+
+      results = processor.process
+
+      expect(results[:processed_count]).to eq(0)
+      expect(results[:errors].length).to eq(3)
+    end
+  end
+
+  describe '#consolidate_results' do
+    let(:spritesheet1) { File.join(test_dir, 'video1_spritesheet.png') }
+    let(:spritesheet2) { File.join(test_dir, 'video2_spritesheet.png') }
+    let(:spritesheet3) { File.join(test_dir, 'video3_spritesheet.png') }
+    let(:consolidator_mock) { instance_double(RubySpriter::Consolidator) }
+
+    before do
+      allow(RubySpriter::Consolidator).to receive(:new).and_return(consolidator_mock)
+      allow(consolidator_mock).to receive(:consolidate).and_return(
+        { output_file: 'consolidated.png', columns: 4, rows: 12, frames: 48 }
+      )
+    end
+
+    it 'consolidates all spritesheets when batch_consolidate is true' do
+      options_with_consolidate = options.merge(batch_consolidate: true)
+      processor = described_class.new(options_with_consolidate)
+
+      outputs = [spritesheet1, spritesheet2, spritesheet3]
+
+      expect(consolidator_mock).to receive(:consolidate) do |files, output|
+        expect(files).to eq(outputs)
+        expect(output).to include('batch_consolidated_spritesheet')
+        expect(output).to end_with('.png')
+      end
+
+      processor.consolidate_results(outputs)
+    end
+
+    it 'uses outputdir for consolidated file if specified' do
+      options_with_consolidate = options.merge(batch_consolidate: true, outputdir: output_dir)
+      processor = described_class.new(options_with_consolidate)
+
+      allow(File).to receive(:directory?).with(output_dir).and_return(true)
+
+      outputs = [spritesheet1, spritesheet2, spritesheet3]
+
+      expect(consolidator_mock).to receive(:consolidate) do |files, output|
+        expect(output).to start_with(output_dir)
+      end
+
+      processor.consolidate_results(outputs)
+    end
+
+    it 'does not consolidate when batch_consolidate is false' do
+      processor = described_class.new(options)
+
+      outputs = [spritesheet1, spritesheet2, spritesheet3]
+
+      expect(consolidator_mock).not_to receive(:consolidate)
+
+      result = processor.consolidate_results(outputs)
+      expect(result).to be_nil
+    end
+  end
+end