ruby_spriter 0.6.6 → 0.6.7

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

data/spec/ruby_spriter/cli_spec.rb

@@ -77,6 +77,21 @@ RSpec.describe RubySpriter::CLI do
           expect { described_class.start(['-h']) }.to output(/Usage: ruby_spriter/).to_stdout
         end.to raise_error(SystemExit)
       end
+
+      it 'shows mode-specific help hints' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Get mode-specific help:')
+      end
     end
 
     describe '--version flag' do
@@ -676,6 +691,141 @@ RSpec.describe RubySpriter::CLI do
   describe '--video flag' do
     let(:fixture_video) { File.join(__dir__, '..', 'fixtures', 'test_video.mp4') }
 
+    describe 'context-sensitive help' do
+      it 'shows video mode help with --help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--video', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Video Mode')
+      end
+
+      it 'shows parent-child option hierarchy in video mode help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--video', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        # Check for parent options
+        expect(output.string).to include('-s, --scale PERCENT')
+        expect(output.string).to include('-r, --remove-bg')
+
+        # Check for child options with hierarchy marker
+        expect(output.string).to include('└─ Interpolation:')
+        expect(output.string).to include('└─ Sharpen radius')
+        expect(output.string).to include('└─ Use fuzzy select')
+        expect(output.string).to include('└─ Feather radius')
+        expect(output.string).to include('└─ Grow selection')
+
+        # Check that --order mentions BOTH requirement
+        expect(output.string).to match(/order.*BOTH.*--scale.*AND.*--remove-bg/i)
+      end
+
+      it 'shows --sharpen as standalone option in video mode help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--video', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        # --sharpen should be a standalone parent option (not indented under --scale)
+        expect(output.string).to match(/^  --sharpen\s+Apply unsharp mask/)
+
+        # --sharpen modifiers should be children under --sharpen
+        expect(output.string).to include('└─ Sharpen radius')
+        expect(output.string).to include('└─ Sharpen gain')
+        expect(output.string).to include('└─ Sharpen threshold')
+
+        # --interpolation should ONLY be under --scale (not under --sharpen)
+        lines = output.string.lines
+        sharpen_line_idx = lines.index { |l| l.include?('--sharpen') && l.include?('Apply unsharp mask') }
+        scale_line_idx = lines.index { |l| l.include?('--scale PERCENT') }
+        interpolation_line_idx = lines.index { |l| l.include?('└─ Interpolation') }
+
+        # Interpolation should come after scale, not after sharpen
+        expect(interpolation_line_idx).to be > scale_line_idx
+        expect(interpolation_line_idx).to be < sharpen_line_idx
+      end
+
+      it 'shows image mode help with --help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--image', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Image Mode')
+      end
+
+      it 'shows consolidate mode help with --help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--consolidate', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Consolidate Mode')
+      end
+
+      it 'shows batch mode help with --help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--batch', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Batch Mode')
+      end
+
+      it 'shows split mode help with --help' do
+        output = StringIO.new
+        $stdout = output
+
+        begin
+          described_class.start(['--split', '--help'])
+        rescue SystemExit
+          # Expected
+        ensure
+          $stdout = STDOUT
+        end
+
+        expect(output.string).to include('Split Mode')
+      end
+    end
+
     describe 'argument parsing' do
       it 'sets video option with --video flag' do
         processor_double = instance_double(RubySpriter::Processor)
@@ -1410,6 +1560,7 @@ RSpec.describe RubySpriter::CLI do
         })
 
         processor = RubySpriter::Processor.new(
+          consolidate_mode: true,
           consolidate: [spritesheet_4x2, spritesheet_6x2],
           overwrite: false
         )
@@ -1441,6 +1592,7 @@ RSpec.describe RubySpriter::CLI do
         })
 
         processor = RubySpriter::Processor.new(
+          consolidate_mode: true,
           consolidate: [spritesheet_4x2, spritesheet_6x2],
           overwrite: true
         )
@@ -1453,6 +1605,97 @@ RSpec.describe RubySpriter::CLI do
         expect { processor.run }.to output(/SUCCESS/).to_stdout
       end
     end
+
+    describe 'directory-based consolidation' do
+      let(:test_dir) { File.join(@test_dir, 'consolidate_dir') }
+
+      before do
+        FileUtils.mkdir_p(test_dir)
+        # Copy fixture spritesheets to test directory
+        FileUtils.cp(spritesheet_4x2, File.join(test_dir, 'sprite1.png'))
+        FileUtils.cp(spritesheet_6x2, File.join(test_dir, 'sprite2.png'))
+      end
+
+      it 'accepts --dir option with --consolidate' 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 be_nil
+          expect(options[:dir]).to eq(test_dir)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', '--dir', test_dir])
+      end
+
+      it 'validates directory exists' do
+        expect do
+          described_class.start(['--consolidate', '--dir', 'nonexistent_directory'])
+        end.to raise_error(RubySpriter::ValidationError, /Directory not found/)
+      end
+
+      it 'cannot use --dir with comma-separated file list' do
+        expect do
+          described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--dir', test_dir])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use --dir with comma-separated file list/)
+      end
+
+      it 'works with --output option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:dir]).to eq(test_dir)
+          expect(options[:output]).to eq('custom_output.png')
+          processor_double
+        end
+
+        described_class.start(['--consolidate', '--dir', test_dir, '--output', 'custom_output.png'])
+      end
+
+      it 'works with --outputdir option' do
+        output_dir = File.join(@test_dir, 'output')
+        FileUtils.mkdir_p(output_dir)
+
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:dir]).to eq(test_dir)
+          expect(options[:outputdir]).to eq(output_dir)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', '--dir', test_dir, '--outputdir', output_dir])
+      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[:dir]).to eq(test_dir)
+          expect(options[:overwrite]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', '--dir', test_dir, '--overwrite'])
+      end
+
+      it 'works with --max-compress option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:dir]).to eq(test_dir)
+          expect(options[:max_compress]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', '--dir', test_dir, '--max-compress'])
+      end
+    end
   end
 
   describe 'error handling' do
@@ -1501,5 +1744,149 @@ RSpec.describe RubySpriter::CLI do
         described_class.start(['--image', 'test.png', '--split', '4:4', '--override-md'])
       end
     end
+
+    describe '--extract option' do
+      it 'parses extract option with comma-separated frame numbers' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:extract]).to eq('1,2,4,5,8')
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--extract', '1,2,4,5,8'])
+      end
+
+      it 'allows duplicate frame numbers' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:extract]).to eq('1,1,2,2,3,3')
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--extract', '1,1,2,2,3,3'])
+      end
+
+      it 'cannot be used with --split' do
+        expect do
+          described_class.start(['--image', 'test.png', '--extract', '1,2,3', '--split', '4:4'])
+        end.to raise_error(RubySpriter::ValidationError, /--extract and --split are mutually exclusive/)
+      end
+    end
+
+    describe '--columns option' do
+      it 'parses columns option for extraction grid' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:columns]).to eq(3)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--extract', '1,2,3', '--columns', '3'])
+      end
+
+      it 'works without --extract (for future use)' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:columns]).to eq(5)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--columns', '5'])
+      end
+    end
+
+    describe '--save-frames option' do
+      it 'sets save_frames 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[:save_frames]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--extract', '1,2,3', '--save-frames'])
+      end
+
+      it 'can be used without --extract' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:save_frames]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--split', '4:4', '--save-frames'])
+      end
+    end
+
+    describe '--add-meta option' do
+      it 'parses add-meta 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[:add_meta]).to eq('4:4')
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--add-meta', '4:4'])
+      end
+
+      it 'cannot be combined with --scale' do
+        expect do
+          described_class.start(['--image', 'test.png', '--add-meta', '4:4', '--scale', '50'])
+        end.to raise_error(RubySpriter::ValidationError, /--add-meta cannot be combined with processing options/)
+      end
+
+      it 'cannot be combined with --remove-bg' do
+        expect do
+          described_class.start(['--image', 'test.png', '--add-meta', '4:4', '--remove-bg'])
+        end.to raise_error(RubySpriter::ValidationError, /--add-meta cannot be combined with processing options/)
+      end
+
+      it 'cannot be combined with --sharpen' do
+        expect do
+          described_class.start(['--image', 'test.png', '--add-meta', '4:4', '--sharpen'])
+        end.to raise_error(RubySpriter::ValidationError, /--add-meta cannot be combined with processing options/)
+      end
+    end
+
+    describe '--overwrite-meta option' do
+      it 'sets overwrite_meta 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_meta]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--add-meta', '4:4', '--overwrite-meta'])
+      end
+    end
+
+    describe '--frames option for partial grids' do
+      it 'parses frames option with integer value' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:frame_count]).to eq(14)
+          processor_double
+        end
+
+        described_class.start(['--image', 'test.png', '--add-meta', '4:4', '--frames', '14'])
+      end
+    end
   end
 end