ukiryu 0.1.7 → 0.2.1

data/spec/ukiryu/tool/loader_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ukiryu::Tool::Loader do
+  describe '.extract_profile_data' do
+    # Make private class method accessible
+    before { Ukiryu::Tool::Loader.singleton_class.send(:public, :extract_profile_data) }
+
+    context 'with Hash profile' do
+      it 'extracts basic profile fields' do
+        profile = {
+          'name' => 'test_profile',
+          'display_name' => 'Test Profile',
+          'platforms' => ['windows'],
+          'shells' => ['powershell'],
+          'option_style' => 'single_dash_equals'
+        }
+
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:name]).to eq('test_profile')
+        expect(result[:display_name]).to eq('Test Profile')
+        expect(result[:platforms]).to eq(['windows'])
+        expect(result[:shells]).to eq(['powershell'])
+        expect(result[:option_style]).to eq('single_dash_equals')
+      end
+
+      it 'extracts inherits field from hash with symbol keys' do
+        profile = {
+          name: 'windows',
+          platforms: ['windows'],
+          shells: ['powershell'],
+          inherits: 'unix'
+        }
+
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:inherits]).to eq('unix')
+      end
+
+      it 'extracts inherits field from hash with string keys' do
+        profile = {
+          'name' => 'windows',
+          'platforms' => ['windows'],
+          'shells' => ['powershell'],
+          'inherits' => 'unix'
+        }
+
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:inherits]).to eq('unix')
+      end
+
+      it 'extracts executable_name field' do
+        profile = {
+          'name' => 'windows',
+          'executable_name' => 'gswin64c'
+        }
+
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:executable_name]).to eq('gswin64c')
+      end
+
+      it 'returns nil for missing inherits field' do
+        profile = {
+          'name' => 'standalone',
+          'platforms' => ['windows']
+        }
+
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:inherits]).to be_nil
+      end
+    end
+
+    context 'with object profile' do
+      it 'extracts fields from object with accessors' do
+        profile_class = Class.new do
+          attr_reader :name, :display_name, :platforms, :shells, :option_style, :inherits, :executable_name
+
+          def initialize
+            @name = 'object_profile'
+            @display_name = 'Object Profile'
+            @platforms = ['linux']
+            @shells = ['bash']
+            @option_style = 'double_dash_equals'
+            @inherits = 'base'
+            @executable_name = 'custom_exe'
+          end
+        end
+
+        profile = profile_class.new
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:name]).to eq('object_profile')
+        expect(result[:display_name]).to eq('Object Profile')
+        expect(result[:platforms]).to eq(['linux'])
+        expect(result[:shells]).to eq(['bash'])
+        expect(result[:option_style]).to eq('double_dash_equals')
+        expect(result[:inherits]).to eq('base')
+        expect(result[:executable_name]).to eq('custom_exe')
+      end
+
+      it 'returns nil for inherits when object does not respond to it' do
+        profile_class = Class.new do
+          attr_reader :name, :display_name, :platforms, :shells, :option_style
+
+          def initialize
+            @name = 'no_inherits'
+            @display_name = 'No Inherits'
+            @platforms = ['macos']
+            @shells = ['zsh']
+            @option_style = 'single_dash_space'
+          end
+        end
+
+        profile = profile_class.new
+        result = Ukiryu::Tool::Loader.extract_profile_data(profile)
+
+        expect(result[:inherits]).to be_nil
+      end
+    end
+  end
+
+  describe 'profile inheritance integration' do
+    # This tests the full flow: extract_profile_data -> PlatformProfile -> resolve_inheritance!
+    it 'preserves inherits field through the conversion process' do
+      Ukiryu::Tool::Loader.singleton_class.send(:public, :extract_profile_data)
+
+      # Create a minimal test that verifies the inherits field is preserved
+      profile_hash = {
+        'name' => 'windows',
+        'platforms' => ['windows'],
+        'shells' => ['powershell'],
+        'inherits' => 'unix'
+      }
+
+      extracted = Ukiryu::Tool::Loader.extract_profile_data(profile_hash)
+
+      # The inherits field should be preserved
+      expect(extracted[:inherits]).to eq('unix')
+
+      # This would be used by PlatformProfile.resolve_inheritance! to inherit commands
+    end
+  end
+end

data/spec/ukiryu/tool_index_spec.rb

@@ -66,18 +66,17 @@ RSpec.describe Ukiryu::ToolIndex do
 
   describe '#find_by_interface' do
     context 'when register path is nil and default is also nil' do
-      it 'returns nil' do
-        # Temporarily clear the default register path
-        original_path = Ukiryu::Register.default_register_path
-        Ukiryu::Register.default_register_path = nil
-
-        index = described_class.new(register_path: nil)
+      it 'returns nil when register cannot be found' do
+        # This test verifies behavior when no register is available
+        # In the new architecture, Register will always try to discover a register
+        # So this test now verifies that when explicitly given a nonexistent path,
+        # the find_by_interface returns nil
+
+        # Create an index with an explicit nonexistent path
+        index = described_class.new(register_path: '/nonexistent/register/path')
         metadata = index.find_by_interface(:ping)
 
         expect(metadata).to be_nil
-
-        # Restore the default register path
-        Ukiryu::Register.default_register_path = original_path
       end
     end
 
@@ -93,18 +92,12 @@ RSpec.describe Ukiryu::ToolIndex do
 
   describe '#all_tools' do
     context 'when register path is nil and default is also nil' do
-      it 'returns empty hash' do
-        # Temporarily clear the default register path
-        original_path = Ukiryu::Register.default_register_path
-        Ukiryu::Register.default_register_path = nil
-
-        index = described_class.new(register_path: nil)
+      it 'returns empty hash when register cannot be found' do
+        # Create an index with an explicit nonexistent path
+        index = described_class.new(register_path: '/nonexistent/register/path')
         tools = index.all_tools
 
         expect(tools).to eq({})
-
-        # Restore the default register path
-        Ukiryu::Register.default_register_path = original_path
       end
     end
 
@@ -165,4 +158,103 @@ RSpec.describe Ukiryu::ToolIndex do
       expect(index.instance_variable_get(:@interface_to_tools)).to eq(old_interface_to_tools)
     end
   end
+
+  describe '#select_latest_version_by_content' do
+    # Make private method accessible
+    before { Ukiryu::ToolIndex.send(:public, :select_latest_version_by_content) }
+
+    let(:temp_dir) { Dir.mktmpdir('ukiryu_version_test') }
+
+    after do
+      FileUtils.rm_rf(temp_dir)
+    end
+
+    it 'selects version from YAML content, not filename' do
+      # Create two files where filename and content version are SWAPPED
+      # File named "9.5.yaml" but contains version: '10.0'
+      # File named "10.0.yaml" but contains version: '9.5'
+      file_nine = File.join(temp_dir, '9.5.yaml')
+      file_ten = File.join(temp_dir, '10.0.yaml')
+
+      File.write(file_nine, "---\nversion: '10.0'\nname: test\n")
+      File.write(file_ten, "---\nversion: '9.5'\nname: test\n")
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([file_nine, file_ten])
+
+      # Should return content of file with version 10.0 (file_nine),
+      # NOT the file named "10.0.yaml" (file_ten)
+      expect(result).to include("version: '10.0'")
+    end
+
+    it 'selects the file with highest version from content' do
+      file1 = File.join(temp_dir, '1.0.yaml')
+      file2 = File.join(temp_dir, '2.0.yaml')
+      file3 = File.join(temp_dir, '3.0.yaml')
+
+      File.write(file1, "---\nversion: '1.0'\nname: test\n")
+      File.write(file2, "---\nversion: '2.0'\nname: test\n")
+      File.write(file3, "---\nversion: '3.0'\nname: test\n")
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([file1, file2, file3])
+
+      expect(result).to include("version: '3.0'")
+    end
+
+    it 'handles Ghostscript 10.0 vs 9.5 case correctly' do
+      # This is the real-world case that caused the bug
+      file_ten = File.join(temp_dir, '10.0.yaml')
+      file_nine = File.join(temp_dir, '9.5.yaml')
+
+      File.write(file_ten, "---\nversion: '10.0'\nname: ghostscript\nimplements: ghostscript/1.0\n")
+      File.write(file_nine, "---\nversion: '9.5'\nname: ghostscript\nimplements: ghostscript/1.0\n")
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([file_nine, file_ten])
+
+      expect(result).to include("version: '10.0'")
+    end
+
+    it 'returns nil for empty file list' do
+      index = described_class.new(register_path: '/dummy')
+      expect(index.select_latest_version_by_content([])).to be_nil
+    end
+
+    it 'returns content of single file' do
+      file = File.join(temp_dir, '1.0.yaml')
+      File.write(file, "---\nversion: '1.0'\nname: test\n")
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([file])
+
+      expect(result).to include("version: '1.0'")
+    end
+
+    it 'skips files without version field' do
+      file_with_version = File.join(temp_dir, 'with_version.yaml')
+      file_without_version = File.join(temp_dir, 'no_version.yaml')
+
+      File.write(file_with_version, "---\nversion: '2.0'\nname: test\n")
+      File.write(file_without_version, "---\nname: test\n") # No version field
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([file_with_version, file_without_version])
+
+      expect(result).to include("version: '2.0'")
+    end
+
+    it 'skips files that cannot be parsed' do
+      valid_file = File.join(temp_dir, 'valid.yaml')
+      invalid_file = File.join(temp_dir, 'invalid.yaml')
+
+      File.write(valid_file, "---\nversion: '1.0'\nname: test\n")
+      File.write(invalid_file, 'this is not valid yaml [[')
+
+      index = described_class.new(register_path: '/dummy')
+      result = index.select_latest_version_by_content([valid_file, invalid_file])
+
+      expect(result).to include("version: '1.0'")
+    end
+  end
 end

data/spec/ukiryu/tools/ghostscript_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Ghostscript Tool Profile' do
+  include ToolHelper
+
+  before(:each) do
+    @temp_dir = create_temp_dir
+  end
+
+  after(:each) do
+    # Clean up temp directory
+    FileUtils.rm_rf(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+  end
+
+  # Create a simple EPS file for testing
+  # @param path [String] the path to create the EPS file at
+  def create_test_eps(path)
+    eps_content = <<~EPS
+      %!PS-Adobe-3.0 EPSF-3.0
+      %%BoundingBox: 0 0 100 100
+      %%EndComments
+      newpath
+      0 0 moveto
+      100 0 lineto
+      100 100 lineto
+      0 100 lineto
+      closepath
+      0 setgray
+      fill
+      showpage
+      %%EOF
+    EPS
+    File.write(path, eps_content)
+    path
+  end
+
+  describe 'tool availability' do
+    it 'detects Ghostscript on the system' do
+      skip_unless_tool_available(:ghostscript)
+
+      tool = get_tool(:ghostscript)
+      expect(tool.available?).to be true
+      # Ghostscript executable names vary by platform
+      # Unix: gs, ghostscript
+      # Windows: gswin64c, gswin32c
+      expect(tool.executable).to match(/gs|ghostscript/i)
+    end
+  end
+
+  describe 'convert command' do
+    before(:each) { skip_unless_tool_available(:ghostscript) }
+
+    it 'converts EPS to PDF with -sDEVICE=pdfwrite' do
+      input = File.join(@temp_dir, 'input.eps')
+      output = File.join(@temp_dir, 'output.pdf')
+
+      create_test_eps(input)
+
+      tool = get_tool(:ghostscript)
+      result = tool.execute(:convert,
+                            execution_timeout: 60,
+                            inputs: [input],
+                            device: :pdfwrite,
+                            output: output,
+                            batch: true,
+                            no_pause: true,
+                            quiet: true)
+
+      expect(result.success?).to be true
+      expect(result.exit_code).to eq(0)
+      expect(File.exist?(output)).to be true
+      # PDF should be at least 100 bytes (minimal valid PDF)
+      expect(File.size(output)).to be > 100
+    end
+
+    it 'handles -sDEVICE=pdfwrite style arguments correctly on all shells' do
+      # This test specifically verifies that the -sDEVICE=pdfwrite argument
+      # is preserved correctly on ALL shells, including PowerShell.
+      #
+      # On Windows PowerShell, arguments starting with - can be stripped by
+      # PowerShell's parameter binder. This test ensures the fix works by
+      # verifying the command succeeds and produces valid output.
+      input = File.join(@temp_dir, 'test.eps')
+      output = File.join(@temp_dir, 'test.pdf')
+
+      create_test_eps(input)
+
+      tool = get_tool(:ghostscript)
+
+      # Execute the command - if the -sDEVICE prefix was stripped,
+      # Ghostscript would fail with an error about unknown device
+      result = tool.execute(:convert,
+                            execution_timeout: 60,
+                            inputs: [input],
+                            device: :pdfwrite,
+                            output: output,
+                            batch: true,
+                            no_pause: true,
+                            quiet: true)
+
+      expect(result.success?).to be true
+      expect(File.exist?(output)).to be true
+      expect(File.size(output)).to be > 100
+    end
+
+    it 'converts with EPS crop option' do
+      input = File.join(@temp_dir, 'cropped.eps')
+      output = File.join(@temp_dir, 'cropped.pdf')
+
+      create_test_eps(input)
+
+      tool = get_tool(:ghostscript)
+      result = tool.execute(:convert,
+                            execution_timeout: 60,
+                            inputs: [input],
+                            device: :pdfwrite,
+                            output: output,
+                            batch: true,
+                            no_pause: true,
+                            quiet: true,
+                            eps_crop: true)
+
+      expect(result.success?).to be true
+      expect(File.exist?(output)).to be true
+    end
+
+    it 'handles multiple dash-prefixed options correctly' do
+      # Test multiple options that start with dashes
+      # All should be preserved on all shells including PowerShell
+      input = File.join(@temp_dir, 'multi.eps')
+      output = File.join(@temp_dir, 'multi.pdf')
+
+      create_test_eps(input)
+
+      tool = get_tool(:ghostscript)
+
+      result = tool.execute(:convert,
+                            execution_timeout: 60,
+                            inputs: [input],
+                            device: :pdfwrite,
+                            output: output,
+                            batch: true,
+                            no_pause: true,
+                            quiet: true,
+                            safer: true)
+
+      expect(result.success?).to be true
+      expect(File.exist?(output)).to be true
+    end
+
+    it 'handles path with spaces' do
+      # Create subdirectory with space in name
+      subdir = File.join(@temp_dir, 'sub dir')
+      Dir.mkdir(subdir)
+      input = File.join(subdir, 'space test.eps')
+      output = File.join(subdir, 'space test.pdf')
+
+      create_test_eps(input)
+
+      tool = get_tool(:ghostscript)
+      result = tool.execute(:convert,
+                            execution_timeout: 60,
+                            inputs: [input],
+                            device: :pdfwrite,
+                            output: output,
+                            batch: true,
+                            no_pause: true,
+                            quiet: true)
+
+      expect(result.success?).to be true
+      expect(File.exist?(output)).to be true
+    end
+  end
+
+  describe 'PowerShell-specific argument handling' do
+    # These tests verify the fix for PowerShell parameter binding
+    # which was stripping the -sDEVICE prefix from arguments
+    #
+    # PowerShell Core (pwsh) is cross-platform and available on Windows, macOS, and Linux.
+    # These tests can run on any platform with PowerShell and Ghostscript installed.
+    #
+    # BUG FIX: PowerShell was not quoting dash-prefixed arguments,
+    # causing PowerShell's parameter binder to strip the prefix.
+    # Example: -sDEVICE=pdfwrite became =pdfwrite
+    # See: lib/ukiryu/shell/powershell.rb
+
+    before(:each) do
+      skip_unless_tool_available(:ghostscript)
+      # Skip if PowerShell is not available on this system
+      skip 'PowerShell (pwsh) is not available' unless system('which pwsh > /dev/null 2>&1')
+    end
+
+    it 'preserves -sDEVICE=pdfwrite when forced to PowerShell shell' do
+      # Set test shell to PowerShell
+      original_test_shell = ENV['UKIRYU_TEST_SHELL']
+      ENV['UKIRYU_TEST_SHELL'] = 'powershell'
+
+      # Use the fixture register which has PowerShell in the shells list
+      fixture_register = File.expand_path('../../fixtures/register', __dir__)
+
+      begin
+        # Clear shell and tool caches to force reload with PowerShell
+        Ukiryu::Shell.reset
+        Ukiryu::Tool.clear_cache
+
+        # Set register path programmatically
+        Ukiryu::Register.default_register_path = fixture_register
+
+        input = File.join(@temp_dir, 'ps_test.eps')
+        output = File.join(@temp_dir, 'ps_test.pdf')
+
+        create_test_eps(input)
+
+        tool = Ukiryu::Tool.get('ghostscript')
+
+        # Verify PowerShell is being used
+        expect(Ukiryu::Shell.detect).to eq(:powershell)
+
+        result = tool.execute(:convert,
+                              execution_timeout: 60,
+                              inputs: [input],
+                              device: :pdfwrite,
+                              output: output,
+                              batch: true,
+                              no_pause: true,
+                              quiet: true)
+
+        expect(result.success?).to be true
+        expect(File.exist?(output)).to be true
+        expect(File.size(output)).to be > 100
+      ensure
+        # Restore original environment
+        ENV['UKIRYU_TEST_SHELL'] = original_test_shell if original_test_shell
+        ENV.delete('UKIRYU_TEST_SHELL') unless original_test_shell
+        Ukiryu::Shell.reset
+        Ukiryu::Tool.clear_cache
+      end
+    end
+  end
+end

data/spec/ukiryu/tools/imagemagick_spec.rb

@@ -112,7 +112,8 @@ RSpec.describe 'ImageMagick Tool Profile' do
       create_test_image(input)
 
       tool = get_tool(:imagemagick)
-      result = tool.execute(:convert, execution_timeout: 30, inputs: [input], output: output, resize: '75x75', quality: 85, strip: true)
+      result = tool.execute(:convert, execution_timeout: 30, inputs: [input], output: output, resize: '75x75',
+                                      quality: 85, strip: true)
 
       expect(result.success?).to be true
       expect(File.exist?(output)).to be true

data/spec/ukiryu/tools/inkscape_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe 'Inkscape Tool Profile' do
 
   describe 'tool availability' do
     it 'detects Inkscape on the system' do
-      skip_unless_tool_available(:inkscape)
+      raise 'Inkscape is not available on this system - tests must not skip, Inkscape must be installed' unless tool_available?(:inkscape)
 
       tool = get_tool(:inkscape)
       expect(tool.available?).to be true
@@ -24,7 +24,9 @@ RSpec.describe 'Inkscape Tool Profile' do
   end
 
   describe 'export command' do
-    before(:each) { skip_unless_tool_available(:inkscape) }
+    before(:each) do
+      raise 'Inkscape is not available on this system - tests must not skip, Inkscape must be installed' unless tool_available?(:inkscape)
+    end
 
     it 'exports SVG to PNG' do
       input = File.join(@temp_dir, 'input.svg')