ruby_spriter 0.6.7.1 → 0.7.0.1

data/spec/ruby_spriter/video_processor_spec.rb

@@ -1,29 +1,346 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubySpriter::VideoProcessor do
-  describe '#create_spritesheet' do
-    let(:video_file) { 'test_video.mp4' }
-    let(:output_file) { 'spritesheet.png' }
-    let(:processor) { described_class.new(frame_count: 16, columns: 4) }
-
-    before do
-      allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
-      allow(File).to receive(:size).and_return(1000)
-      allow(File).to receive(:exist?).and_return(true)
-      allow(File).to receive(:delete)
-      allow(RubySpriter::MetadataManager).to receive(:embed)
-      allow(Open3).to receive(:capture3).and_return(['2.0', '', instance_double(Process::Status, success?: true)])
-    end
-
-    it 'creates spritesheet from video file' do
-      result = processor.create_spritesheet(video_file, output_file)
-
-      expect(result[:output_file]).to eq(output_file)
-      expect(result[:columns]).to eq(4)
-      expect(result[:rows]).to eq(4)
-      expect(result[:frames]).to eq(16)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../lib/ruby_spriter/cell_cleanup_processor'
+
+RSpec.describe RubySpriter::VideoProcessor do
+  describe '#create_spritesheet' do
+    let(:video_file) { 'test_video.mp4' }
+    let(:output_file) { 'spritesheet.png' }
+    let(:processor) { described_class.new(frame_count: 16, columns: 4) }
+
+    before do
+      allow(RubySpriter::Utils::FileHelper).to receive(:validate_readable!)
+      allow(File).to receive(:size).and_return(1000)
+      allow(File).to receive(:exist?).and_return(true)
+      allow(File).to receive(:delete)
+      allow(RubySpriter::MetadataManager).to receive(:embed)
+      allow(Open3).to receive(:capture3).and_return(['2.0', '', instance_double(Process::Status, success?: true)])
+    end
+
+    it 'creates spritesheet from video file' do
+      result = processor.create_spritesheet(video_file, output_file)
+
+      expect(result[:output_file]).to eq(output_file)
+      expect(result[:columns]).to eq(4)
+      expect(result[:rows]).to eq(4)
+      expect(result[:frames]).to eq(16)
+    end
+
+  end
+
+  describe '#process_with_background_removal' do
+    let(:video_processor) { described_class.new }
+    let(:temp_dir) { 'temp_test_dir' }
+    let(:video_path) { 'test_video.mp4' }
+    let(:output_path) { 'output_spritesheet.png' }
+
+    before do
+      allow(Dir).to receive(:mktmpdir).and_return(temp_dir)
+      allow(FileUtils).to receive(:rm_rf)
+
+      # Mock file operations for metadata embedding
+      allow(FileUtils).to receive(:mv)
+      allow(File).to receive(:delete)
+      allow(File).to receive(:exist?).and_return(true)
+    end
+
+    context 'when by_frame option is true' do
+      let(:options) do
+        {
+          by_frame: true,
+          remove_bg: true,
+          frames: 4,
+          columns: 2,
+          gimp_path: '/usr/bin/gimp'
+        }
+      end
+
+      it 'processes each frame individually with background removal' do
+        # Mock frame extraction
+        frame_files = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png']
+        allow(video_processor).to receive(:extract_frames).and_return(frame_files)
+
+        # Mock background removal for each frame
+        gimp_processor = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_processor)
+
+        # Expect .process() to be called for EACH frame (4 times)
+        # process() returns the output path (same as input for simplicity)
+        allow(gimp_processor).to receive(:process) do |input_path|
+          # Return the _nobg version of the input path
+          input_path.sub('.png', '_nobg.png')
+        end
+        expect(gimp_processor).to receive(:process).exactly(4).times
+
+        # Mock spritesheet assembly
+        allow(video_processor).to receive(:assemble_spritesheet_from_frames)
+
+        # Mock metadata
+        allow(RubySpriter::MetadataManager).to receive(:embed)
+
+        video_processor.process_with_background_removal(video_path, output_path, options)
+      end
+
+      it 'displays progress indicator for each frame' do
+        frame_files = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png']
+        allow(video_processor).to receive(:extract_frames).and_return(frame_files)
+
+        gimp_processor = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_processor)
+
+        # Mock .process() to return output path
+        allow(gimp_processor).to receive(:process) do |input_path|
+          input_path.sub('.png', '_nobg.png')
+        end
+
+        allow(video_processor).to receive(:assemble_spritesheet_from_frames)
+        allow(RubySpriter::MetadataManager).to receive(:embed)
+
+        # Verify progress messages are displayed (use regex that matches any frame number)
+        expect { video_processor.process_with_background_removal(video_path, output_path, options) }
+          .to output(/Processing frame \d+\/4.*Processing frame \d+\/4.*Processing frame \d+\/4.*Processing frame \d+\/4/m).to_stdout
+      end
+
+      it 'passes temp_dir in options to assemble_spritesheet_from_frames' do
+        allow(video_processor).to receive(:extract_frames).and_return(['frame_001.png'])
+        allow(video_processor).to receive(:process_frames_individually)
+        allow(RubySpriter::MetadataManager).to receive(:embed)
+
+        expect(video_processor).to receive(:assemble_spritesheet_from_frames) do |frames, output, opts|
+          expect(opts[:temp_dir]).to be_a(String)
+          expect(opts[:temp_dir]).to eq('temp_test_dir')
+        end
+
+        video_processor.process_with_background_removal(video_path, output_path, options)
+      end
+    end
+
+    context 'when by_frame option is false' do
+      let(:options) do
+        {
+          by_frame: false,
+          remove_bg: true,
+          frames: 4,
+          columns: 2,
+          gimp_path: '/usr/bin/gimp'
+        }
+      end
+
+      it 'processes the entire spritesheet at once (existing behavior)' do
+        # Mock frame extraction
+        frame_files = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png']
+        allow(video_processor).to receive(:extract_frames).and_return(frame_files)
+
+        # Mock spritesheet assembly
+        allow(video_processor).to receive(:assemble_spritesheet_from_frames)
+
+        # Mock background removal for spritesheet (called ONCE, not per frame)
+        gimp_processor = instance_double(RubySpriter::GimpProcessor)
+        allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_processor)
+
+        # Mock .process() to return the same path (no change)
+        allow(gimp_processor).to receive(:process).with(output_path).and_return(output_path)
+        expect(gimp_processor).to receive(:process).once
+
+        # Mock metadata
+        allow(RubySpriter::MetadataManager).to receive(:embed)
+
+        video_processor.process_with_background_removal(video_path, output_path, options)
+      end
+
+      context 'with cell cleanup enabled' do
+        let(:cleanup_options) do
+          {
+            by_frame: false,
+            remove_bg: true,
+            cleanup_cells: true,
+            frames: 4,
+            columns: 2,
+            gimp_path: '/usr/bin/gimp',
+            cell_cleanup_threshold: 15.0
+          }
+        end
+
+        it 'applies cell cleanup after background removal' do
+          # Mock frame extraction
+          frame_files = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png']
+          allow(video_processor).to receive(:extract_frames).and_return(frame_files)
+
+          # Mock spritesheet assembly
+          allow(video_processor).to receive(:assemble_spritesheet_from_frames)
+
+          # Mock GIMP processing
+          gimp_processor = instance_double(RubySpriter::GimpProcessor)
+          allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_processor)
+          allow(gimp_processor).to receive(:process).and_return(output_path)
+
+          # Mock cell cleanup
+          mock_cell_processor = instance_double(RubySpriter::CellCleanupProcessor)
+          expect(RubySpriter::CellCleanupProcessor).to receive(:new)
+            .with(cleanup_options)
+            .and_return(mock_cell_processor)
+          expect(mock_cell_processor).to receive(:cleanup_cells)
+            .with(output_path, cleanup_options)
+            .and_return({ processed: 4, cleaned: 2, skipped: 2 })
+
+          # Mock metadata
+          allow(RubySpriter::MetadataManager).to receive(:embed)
+
+          video_processor.process_with_background_removal(video_path, output_path, cleanup_options)
+        end
+
+        it 'skips cell cleanup when flag is false' do
+          # Mock frame extraction
+          frame_files = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png']
+          allow(video_processor).to receive(:extract_frames).and_return(frame_files)
+
+          # Mock spritesheet assembly
+          allow(video_processor).to receive(:assemble_spritesheet_from_frames)
+
+          # Mock GIMP processing
+          gimp_processor = instance_double(RubySpriter::GimpProcessor)
+          allow(RubySpriter::GimpProcessor).to receive(:new).and_return(gimp_processor)
+          allow(gimp_processor).to receive(:process).and_return(output_path)
+
+          # Should NOT instantiate CellCleanupProcessor
+          expect(RubySpriter::CellCleanupProcessor).not_to receive(:new)
+
+          # Mock metadata
+          allow(RubySpriter::MetadataManager).to receive(:embed)
+
+          no_cleanup_options = cleanup_options.merge(cleanup_cells: false)
+          video_processor.process_with_background_removal(video_path, output_path, no_cleanup_options)
+        end
+      end
+    end
+  end
+describe '#extract_frames' do
+  let(:video_processor) { described_class.new }
+  let(:video_file) { 'test_video.mp4' }
+  let(:temp_dir) { 'temp_frames' }
+  let(:options) { { frames: 16, max_width: 320, debug: false } }
+
+  before do
+    # Mock get_duration to return 2.0 seconds
+    allow(video_processor).to receive(:get_duration).and_return(2.0)
+
+    # Mock Open3.capture3 for FFmpeg execution
+    allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+  end
+
+  it 'extracts frames from video using FFmpeg' do
+    expect(Open3).to receive(:capture3) do |cmd|
+      expect(cmd).to include('ffmpeg')
+      expect(cmd).to include('-i')
+      expect(cmd).to include(video_file)
+      expect(cmd).to include('fps=8.0')  # 16 frames / 2.0 seconds
+      expect(cmd).to include('scale=320:-1')
+      expect(cmd).to include('-frames:v 16')
+      ['', '', double(success?: true)]
+    end
+
+    result = video_processor.send(:extract_frames, video_file, temp_dir, options)
+
+    expect(result).to be_an(Array)
+    expect(result.length).to eq(16)
+  end
+
+  it 'returns array of frame filenames' do
+    result = video_processor.send(:extract_frames, video_file, temp_dir, options)
+
+    expect(result).to eq([
+      'frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png',
+      'frame_005.png', 'frame_006.png', 'frame_007.png', 'frame_008.png',
+      'frame_009.png', 'frame_010.png', 'frame_011.png', 'frame_012.png',
+      'frame_013.png', 'frame_014.png', 'frame_015.png', 'frame_016.png'
+    ])
+  end
+
+  it 'raises ProcessingError if FFmpeg fails' do
+    allow(Open3).to receive(:capture3).and_return(['', 'FFmpeg error', double(success?: false)])
+
+    expect {
+      video_processor.send(:extract_frames, video_file, temp_dir, options)
+    }.to raise_error(RubySpriter::ProcessingError, /Failed to extract frames/)
+  end
+end
+describe '#assemble_spritesheet_from_frames' do
+  let(:video_processor) { described_class.new }
+  let(:frame_files) { ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png'] }
+  let(:output_path) { 'output_spritesheet.png' }
+  let(:temp_dir) { 'temp_frames' }
+  let(:options) { { columns: 2, temp_dir: temp_dir, debug: false } }
+
+  before do
+    # Mock Open3.capture3 for FFmpeg execution
+    allow(Open3).to receive(:capture3).and_return(['', '', double(success?: true)])
+
+    # Mock file validation
+    allow(RubySpriter::Utils::FileHelper).to receive(:validate_exists!)
+  end
+
+  it 'assembles frames into spritesheet using FFmpeg tile filter' do
+    expect(Open3).to receive(:capture3) do |cmd|
+      expect(cmd).to include('ffmpeg')
+      expect(cmd).to include('-i')
+      expect(cmd).to include('frame_%03d.png')
+      expect(cmd).to include('tile=2x2')  # 4 frames / 2 columns = 2 rows
+      expect(cmd).to include('-frames:v 1')
+      expect(cmd).to include(output_path)
+      ['', '', double(success?: true)]
+    end
+
+    video_processor.send(:assemble_spritesheet_from_frames, frame_files, output_path, options)
+  end
+
+  it 'calculates rows correctly from frame count and columns' do
+    # 4 frames / 2 columns = 2 rows
+    expect(Open3).to receive(:capture3) do |cmd|
+      expect(cmd).to include('tile=2x2')
+      ['', '', double(success?: true)]
+    end
+
+    video_processor.send(:assemble_spritesheet_from_frames, frame_files, output_path, options)
+  end
+
+  it 'handles non-evenly divisible frame counts with ceiling' do
+    # 5 frames / 2 columns = 2.5 → 3 rows (ceiling)
+    frame_files_odd = ['frame_001.png', 'frame_002.png', 'frame_003.png', 'frame_004.png', 'frame_005.png']
+
+    expect(Open3).to receive(:capture3) do |cmd|
+      expect(cmd).to include('tile=2x3')
+      ['', '', double(success?: true)]
+    end
+
+    video_processor.send(:assemble_spritesheet_from_frames, frame_files_odd, output_path, options)
+  end
+
+  it 'raises ProcessingError if FFmpeg fails' do
+    allow(Open3).to receive(:capture3).and_return(['', 'FFmpeg error', double(success?: false)])
+
+    expect {
+      video_processor.send(:assemble_spritesheet_from_frames, frame_files, output_path, options)
+    }.to raise_error(RubySpriter::ProcessingError, /Failed to assemble spritesheet/)
+  end
+
+it 'validates output file exists after assembly' do
+  expect(RubySpriter::Utils::FileHelper).to receive(:validate_exists!).with(output_path)
+
+  video_processor.send(:assemble_spritesheet_from_frames, frame_files, output_path, options)
+end
+
+it 'handles frame files with _nobg suffix' do
+  frame_files_nobg = ['frame_001_nobg.png', 'frame_002_nobg.png', 'frame_003_nobg.png', 'frame_004_nobg.png']
+
+  expect(Open3).to receive(:capture3) do |cmd|
+    expect(cmd).to include('frame_%03d_nobg.png')
+    expect(cmd).to include('tile=2x2')
+    ['', '', double(success?: true)]
+  end
+
+  video_processor.send(:assemble_spritesheet_from_frames, frame_files_nobg, output_path, options)
+end
+end
+
+end

data/spec/spec_helper.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-require 'simplecov'
-SimpleCov.start do
-  add_filter '/spec/'
-  add_filter '/vendor/'
-end
-
-require 'ruby_spriter'
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = '.rspec_status'
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  # Helpers for creating temp files in tests
-  config.before(:suite) do
-    $test_temp_dir = File.join(Dir.tmpdir, 'ruby_spriter_test')
-    FileUtils.mkdir_p($test_temp_dir)
-  end
-
-  config.after(:suite) do
-    FileUtils.rm_rf($test_temp_dir) if $test_temp_dir && File.exist?($test_temp_dir)
-  end
-
-  # Make test temp directory available to all specs
-  config.before(:each) do
-    @test_dir = File.join($test_temp_dir, "test_#{Time.now.to_i}_#{rand(10000)}")
-    FileUtils.mkdir_p(@test_dir)
-  end
-
-  config.after(:each) do
-    FileUtils.rm_rf(@test_dir) if @test_dir && File.exist?(@test_dir)
-  end
-end
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/vendor/'
+end
+
+require 'ruby_spriter'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # Helpers for creating temp files in tests
+  config.before(:suite) do
+    $test_temp_dir = File.join(Dir.tmpdir, 'ruby_spriter_test')
+    FileUtils.mkdir_p($test_temp_dir)
+  end
+
+  config.after(:suite) do
+    FileUtils.rm_rf($test_temp_dir) if $test_temp_dir && File.exist?($test_temp_dir)
+  end
+
+  # Make test temp directory available to all specs
+  config.before(:each) do
+    @test_dir = File.join($test_temp_dir, "test_#{Time.now.to_i}_#{rand(10000)}")
+    FileUtils.mkdir_p(@test_dir)
+  end
+
+  config.after(:each) do
+    FileUtils.rm_rf(@test_dir) if @test_dir && File.exist?(@test_dir)
+  end
+end

data/spec/unit/background_sampler_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'ruby_spriter/background_sampler'
+
+RSpec.describe RubySpriter::BackgroundSampler do
+  let(:image_path) { 'spec/fixtures/walk_north_sprite-sheet.png' }
+  let(:sample_offset) { 5 }
+  let(:sample_count) { 10 }
+  let(:max_rows) { 20 }
+
+  subject { described_class.new(image_path, sample_offset, sample_count, max_rows) }
+
+  describe '#initialize' do
+    it 'sets the image path' do
+      expect(subject.image_path).to eq(image_path)
+    end
+
+    it 'sets the sample offset' do
+      expect(subject.sample_offset).to eq(5)
+    end
+
+    it 'sets the sample count' do
+      expect(subject.sample_count).to eq(10)
+    end
+
+    it 'sets the max rows' do
+      expect(subject.max_rows).to eq(20)
+    end
+  end
+
+  describe '#collect_unique_colors' do
+    it 'returns an array of unique RGB color hashes' do
+      colors = subject.collect_unique_colors
+
+      expect(colors).to be_an(Array)
+      # May return fewer than sample_count if image has limited unique colors
+      expect(colors.length).to be > 0
+
+      colors.each do |color|
+        expect(color).to have_key(:r)
+        expect(color).to have_key(:g)
+        expect(color).to have_key(:b)
+        expect(color[:r]).to be_between(0, 255)
+        expect(color[:g]).to be_between(0, 255)
+        expect(color[:b]).to be_between(0, 255)
+      end
+    end
+
+    it 'collects up to the specified number of unique colors' do
+      colors = subject.collect_unique_colors
+
+      expect(colors.length).to be <= sample_count
+    end
+
+    it 'returns only unique colors (no duplicates)' do
+      colors = subject.collect_unique_colors
+
+      # Convert to strings for comparison
+      color_strings = colors.map { |c| "#{c[:r]},#{c[:g]},#{c[:b]}" }
+      expect(color_strings.uniq.length).to eq(colors.length)
+    end
+
+    it 'samples starting at offset pixels from edge' do
+      # Mock ImageMagick calls to verify coordinates
+      allow(Open3).to receive(:capture3) do |cmd|
+        # Extract x,y from command like: magick <path> -format "%[pixel:p{5,5}]" info:
+        if cmd =~ /pixel:p\{(\d+),(\d+)\}/
+          x = $1.to_i
+          y = $2.to_i
+
+          # Verify x and y are at least offset pixels from edge
+          expect(x).to be >= sample_offset
+          expect(y).to be >= sample_offset
+
+          # Return mock color
+          ["srgb(255,255,255)", "", double(success?: true)]
+        else
+          ["100 100", "", double(success?: true)]  # Dimensions
+        end
+      end
+
+      subject.collect_unique_colors
+    end
+
+    it 'moves to next row if not enough unique colors found in first row' do
+      # Create a sampler that needs more colors than available in one row
+      sampler = described_class.new(image_path, 5, 10, 20)
+
+      colors = sampler.collect_unique_colors
+
+      # Should have collected some colors (exact count depends on image)
+      expect(colors).to be_an(Array)
+      expect(colors.length).to be > 0
+
+      # All colors should be unique
+      color_strings = colors.map { |c| "#{c[:r]},#{c[:g]},#{c[:b]}" }
+      expect(color_strings.uniq.length).to eq(colors.length)
+    end
+  end
+
+  describe '#sample_pixel' do
+    it 'uses ImageMagick to get pixel color at specific coordinates' do
+      # Matches both 'magick' (Windows) and 'convert' (Unix)
+      expect(Open3).to receive(:capture3).with(/(magick|convert).*pixel:p\{10,10\}/).and_return(
+        ["srgb(128,64,32)", "", double(success?: true)]
+      )
+
+      color = subject.send(:sample_pixel, 10, 10)
+
+      expect(color).to eq({ r: 128, g: 64, b: 32 })
+    end
+
+    it 'returns nil if ImageMagick command fails' do
+      allow(Open3).to receive(:capture3).and_return(
+        ["", "error", double(success?: false)]
+      )
+
+      color = subject.send(:sample_pixel, 10, 10)
+
+      expect(color).to be_nil
+    end
+
+    it 'handles grayscale images' do
+      allow(Open3).to receive(:capture3).and_return(
+        ["gray(128)", "", double(success?: true)]
+      )
+
+      color = subject.send(:sample_pixel, 10, 10)
+
+      expect(color).to eq({ r: 128, g: 128, b: 128 })
+    end
+  end
+end

data/spec/unit/cell_cleanup_config_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require_relative '../../lib/ruby_spriter/cell_cleanup_config'
+
+RSpec.describe RubySpriter::CellCleanupConfig do
+  describe '#initialize' do
+    context 'with default options' do
+      it 'sets threshold to 15.0' do
+        config = described_class.new
+        expect(config.threshold).to eq(15.0)
+      end
+    end
+
+    context 'with custom threshold' do
+      it 'accepts valid custom threshold' do
+        config = described_class.new(cell_cleanup_threshold: 20.0)
+        expect(config.threshold).to eq(20.0)
+      end
+    end
+
+    context 'with invalid threshold' do
+      it 'raises error when threshold is too low' do
+        expect { described_class.new(cell_cleanup_threshold: 0.5) }
+          .to raise_error(RubySpriter::ValidationError, /between 1.0 and 50.0/)
+      end
+
+      it 'raises error when threshold is too high' do
+        expect { described_class.new(cell_cleanup_threshold: 55.0) }
+          .to raise_error(RubySpriter::ValidationError, /between 1.0 and 50.0/)
+      end
+    end
+  end
+end