ukiryu 0.1.7 → 0.2.1

data/spec/spec_helper.rb

@@ -8,7 +8,7 @@ require 'timeout'
 require 'ukiryu'
 
 # Require all support files
-Dir[File.join(__dir__, "support", "**", "*.rb")].each { |f| require f }
+Dir[File.join(__dir__, 'support', '**', '*.rb')].sort.each { |f| require f }
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
@@ -40,12 +40,12 @@ RSpec.configure do |config|
     # Set up test register path if UKIRYU_REGISTER is not already set
     unless ENV['UKIRYU_REGISTER']
       test_register = File.expand_path('fixtures/register', __dir__)
-      if Dir.exist?(test_register)
-        ENV['UKIRYU_REGISTER'] = test_register
-        Ukiryu::Register.default_register_path = test_register
-      end
+      ENV['UKIRYU_REGISTER'] = test_register if Dir.exist?(test_register)
     end
 
+    # Reset the default register to pick up the test register
+    Ukiryu::Register.reset_default
+
     # Reset ToolIndex to pick up the new register path
     Ukiryu::ToolIndex.reset
 
@@ -59,11 +59,15 @@ RSpec.configure do |config|
   # Reset singleton state before each test to prevent pollution
   config.before(:each) do
     Ukiryu::Config.reset!
-    Ukiryu::Register.reset_version_cache
+    Ukiryu::Register.reset_default
     Ukiryu::ToolIndex.reset
     Ukiryu::Tool.clear_cache
     Ukiryu::Runtime.instance.reset!
     Ukiryu::Tools::Generator.clear_cache
+    Ukiryu::Shell.reset
+
+    # Clean up test shell environment variable that may be left by other tests
+    ENV.delete('UKIRYU_TEST_SHELL')
 
     # Remove generated tool classes from Tools namespace
     Ukiryu::Tools.constants.each do |const|

data/spec/support/tool_helper.rb

@@ -15,6 +15,8 @@ module ToolHelper
   def tool_available?(name)
     tool = get_tool(name)
     tool.available?
+  rescue Ukiryu::Errors::ToolNotFoundError
+    false
   end
 
   # Get tool version if available

data/spec/ukiryu/definition/loader_spec.rb

@@ -174,8 +174,8 @@ RSpec.describe Ukiryu::Definition::Loader do
   end
 
   describe '.profile_cache' do
-    it 'returns a hash' do
-      expect(described_class.profile_cache).to be_a(Hash)
+    it 'returns a bounded cache' do
+      expect(described_class.profile_cache).to be_a(Ukiryu::Cache)
     end
 
     it 'returns same cache on multiple calls' do

data/spec/ukiryu/executor_spec.rb

@@ -152,7 +152,8 @@ RSpec.describe Ukiryu::Executor do
         # Use platform-appropriate command that exits with specific code
         result = if Ukiryu::Platform.windows?
                    # Windows: PowerShell supports exit codes
-                   executor.execute('powershell', ['-Command', 'exit 42'], allow_failure: true, shell: :powershell, timeout: 30)
+                   executor.execute('powershell', ['-Command', 'exit 42'], allow_failure: true, shell: :powershell,
+                                                                           timeout: 30)
                  else
                    executor.execute('sh', ['-c', 'exit 42'], allow_failure: true, shell: shell_symbol, timeout: 30)
                  end
@@ -215,7 +216,8 @@ RSpec.describe Ukiryu::Executor do
         # Use echo as a cross-platform command that always works
         result = if Ukiryu::Platform.windows?
                    # On Windows with PowerShell, use echo command via PowerShell
-                   executor.execute('powershell', ['-Command', 'echo test'], allow_failure: true, shell: :powershell, timeout: 90)
+                   executor.execute('powershell', ['-Command', 'echo test'], allow_failure: true, shell: :powershell,
+                                                                             timeout: 90)
                  else
                    executor.execute('echo', ['test'], allow_failure: true, shell: shell_symbol, timeout: 90)
                  end
@@ -415,7 +417,8 @@ RSpec.describe Ukiryu::Executor do
     end
 
     it 'handles commands with special characters in arguments' do
-      result = executor.execute('echo', ['hello "quoted" test\'s'], allow_failure: true, shell: shell_symbol, timeout: 90)
+      result = executor.execute('echo', ['hello "quoted" test\'s'], allow_failure: true, shell: shell_symbol,
+                                                                    timeout: 90)
 
       expect(result.stdout.strip).to include('hello')
     end

data/spec/ukiryu/models/execution_report_spec.rb

@@ -77,9 +77,10 @@ RSpec.describe Ukiryu::Models::ExecutionReport do
         # In Docker/CI, may be 0 or an actual value
         expect(stage.memory_after).to be_a(Integer)
         expect(stage.memory_after).to be >= 0
-        # If memory detection works, memory_after should be >= memory_before
-        expect(stage.memory_after).to be >= stage.memory_before if stage.memory_before > 0
+        # Memory delta is calculated (may be negative due to GC)
         expect(stage.memory_delta).to be_a(Integer)
+        # Verify delta calculation is correct
+        expect(stage.memory_delta).to eq(stage.memory_after - stage.memory_before)
       end
 
       it 'marks the stage as successful by default' do

data/spec/ukiryu/models/semantic_version_spec.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'ukiryu/models/semantic_version'
+
+RSpec.describe Ukiryu::Models::SemanticVersion do
+  describe '.parse' do
+    it 'parses simple version' do
+      expect(described_class.parse('10.0')).to eq([10, 0])
+    end
+
+    it 'parses three-part version' do
+      expect(described_class.parse('1.2.3')).to eq([1, 2, 3])
+    end
+
+    it 'parses single number version' do
+      expect(described_class.parse('5')).to eq([5])
+    end
+
+    it 'handles nil' do
+      expect(described_class.parse(nil)).to eq([0])
+    end
+
+    it 'handles empty string' do
+      expect(described_class.parse('')).to eq([0])
+    end
+
+    it 'handles non-numeric parts as 0' do
+      expect(described_class.parse('1.alpha.3')).to eq([1, 0, 3])
+    end
+  end
+
+  describe '.compare' do
+    it 'returns 1 when first version is greater' do
+      expect(described_class.compare('10.0', '9.5')).to eq(1)
+    end
+
+    it 'returns -1 when first version is lesser' do
+      expect(described_class.compare('9.5', '10.0')).to eq(-1)
+    end
+
+    it 'returns 0 when versions are equal' do
+      expect(described_class.compare('10.0', '10.0')).to eq(0)
+    end
+
+    it 'handles different segment counts' do
+      expect(described_class.compare('10.0.1', '10.0')).to eq(1)
+    end
+
+    it 'handles single vs multi-part versions' do
+      expect(described_class.compare('10', '9.5')).to eq(1)
+    end
+  end
+
+  describe '#initialize' do
+    it 'stores original string' do
+      version = described_class.new('10.0')
+      expect(version.original).to eq('10.0')
+    end
+
+    it 'parses segments' do
+      version = described_class.new('10.0.5')
+      expect(version.segments).to eq([10, 0, 5])
+    end
+
+    it 'handles integer input' do
+      version = described_class.new(10)
+      expect(version.segments).to eq([10])
+    end
+
+    it 'handles nil input' do
+      version = described_class.new(nil)
+      expect(version.segments).to eq([0])
+    end
+  end
+
+  describe '#<=>' do
+    it 'compares 10.0 > 9.5 (the critical bug case)' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('9.5')
+      expect(v1 <=> v2).to eq(1)
+    end
+
+    it 'compares 9.5 < 10.0' do
+      v1 = described_class.new('9.5')
+      v2 = described_class.new('10.0')
+      expect(v1 <=> v2).to eq(-1)
+    end
+
+    it 'compares equal versions as 0' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('10.0')
+      expect(v1 <=> v2).to eq(0)
+    end
+
+    it 'compares 1.10.0 > 1.9.9' do
+      v1 = described_class.new('1.10.0')
+      v2 = described_class.new('1.9.9')
+      expect(v1 <=> v2).to eq(1)
+    end
+
+    it 'compares with string' do
+      version = described_class.new('10.0')
+      expect(version <=> '9.5').to eq(1)
+    end
+
+    it 'compares with integer' do
+      version = described_class.new('10.0')
+      expect(version <=> 9).to eq(1)
+    end
+
+    it 'returns nil for non-comparable' do
+      version = described_class.new('10.0')
+      expect(version <=> Object.new).to be_nil
+    end
+  end
+
+  describe '#==' do
+    it 'returns true for equal versions' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('10.0')
+      expect(v1 == v2).to be true
+    end
+
+    it 'returns true for equivalent versions with different segment counts' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('10.0.0')
+      expect(v1 == v2).to be true
+    end
+
+    it 'returns false for different versions' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('9.5')
+      expect(v1 == v2).to be false
+    end
+
+    it 'compares with string' do
+      version = described_class.new('10.0')
+      expect(version == '10.0').to be true
+    end
+  end
+
+  describe '#>' do
+    it 'returns true when greater' do
+      expect(described_class.new('10.0')).to be > described_class.new('9.5')
+    end
+
+    it 'returns false when equal' do
+      expect(described_class.new('10.0')).not_to be > described_class.new('10.0')
+    end
+
+    it 'returns false when lesser' do
+      expect(described_class.new('9.5')).not_to be > described_class.new('10.0')
+    end
+  end
+
+  describe '#<' do
+    it 'returns true when lesser' do
+      expect(described_class.new('9.5')).to be < described_class.new('10.0')
+    end
+
+    it 'returns false when equal' do
+      expect(described_class.new('10.0')).not_to be < described_class.new('10.0')
+    end
+  end
+
+  describe '#>=' do
+    it 'returns true when greater' do
+      expect(described_class.new('10.0')).to be >= described_class.new('9.5')
+    end
+
+    it 'returns true when equal' do
+      expect(described_class.new('10.0')).to be >= described_class.new('10.0')
+    end
+
+    it 'returns false when lesser' do
+      expect(described_class.new('9.5')).not_to be >= described_class.new('10.0')
+    end
+  end
+
+  describe '#<=' do
+    it 'returns true when lesser' do
+      expect(described_class.new('9.5')).to be <= described_class.new('10.0')
+    end
+
+    it 'returns true when equal' do
+      expect(described_class.new('10.0')).to be <= described_class.new('10.0')
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns version string' do
+      version = described_class.new('10.0.5')
+      expect(version.to_s).to eq('10.0.5')
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns inspect string' do
+      version = described_class.new('10.0')
+      expect(version.inspect).to eq('#<Ukiryu::Models::SemanticVersion 10.0>')
+    end
+  end
+
+  describe '#hash and #eql?' do
+    it 'can be used as hash key' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('10.0')
+      v3 = described_class.new('9.5')
+
+      hash = { v1 => 'first', v3 => 'second' }
+
+      expect(hash[v2]).to eq('first')
+      expect(hash[v3]).to eq('second')
+    end
+
+    it 'eql? returns true for equal versions' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('10.0')
+      expect(v1.eql?(v2)).to be true
+    end
+
+    it 'eql? returns false for different versions' do
+      v1 = described_class.new('10.0')
+      v2 = described_class.new('9.5')
+      expect(v1.eql?(v2)).to be false
+    end
+  end
+
+  describe 'Comparable integration' do
+    it 'works with Array#max' do
+      versions = [
+        described_class.new('9.5'),
+        described_class.new('10.0'),
+        described_class.new('8.0')
+      ]
+      expect(versions.max.to_s).to eq('10.0')
+    end
+
+    it 'works with Array#sort' do
+      versions = [
+        described_class.new('9.5'),
+        described_class.new('10.0'),
+        described_class.new('8.0')
+      ]
+      expect(versions.sort.map(&:to_s)).to eq(['8.0', '9.5', '10.0'])
+    end
+
+    it 'works with Array#min' do
+      versions = [
+        described_class.new('9.5'),
+        described_class.new('10.0'),
+        described_class.new('8.0')
+      ]
+      expect(versions.min.to_s).to eq('8.0')
+    end
+  end
+
+  describe 'real-world Ghostscript case' do
+    it 'correctly selects 10.0 over 9.5' do
+      v10 = described_class.new('10.0')
+      v95 = described_class.new('9.5')
+
+      # This was the bug: alphabetical sort would select 9.5 over 10.0
+      # because '9' > '1' in ASCII
+      expect([v95, v10].max).to eq(v10)
+    end
+
+    it 'demonstrates the bug with string comparison' do
+      # Show why string comparison is wrong
+      filenames = ['9.5.yaml', '10.0.yaml']
+
+      # WRONG: alphabetical max gives '9.5.yaml' (because '9' > '1')
+      alphabetical_max = filenames.max
+      expect(alphabetical_max).to eq('9.5.yaml')
+
+      # CORRECT: semantic version comparison gives '10.0.yaml'
+      semantic_max = filenames.max_by do |f|
+        described_class.new(File.basename(f, '.yaml'))
+      end
+      expect(semantic_max).to eq('10.0.yaml')
+    end
+  end
+end

data/spec/ukiryu/shell/powershell_integration_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'PowerShell Integration Tests', if: system('which pwsh > /dev/null 2>&1') do
+  let(:shell) { Ukiryu::Shell::PowerShell.new }
+  let(:env) { Ukiryu::Environment.system }
+
+  describe '#execute_command' do
+    context 'with dash-prefixed arguments (prefix stripping prevention)' do
+      it 'preserves -sDEVICE=pdfwrite style arguments' do
+        result = shell.execute_command('echo', ['-sDEVICE=pdfwrite', 'input.eps'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        # The full argument should be present (not stripped to just =pdfwrite)
+        expect(result[:stdout]).to include('-sDEVICE=pdfwrite')
+      end
+
+      it 'preserves multiple dash-prefixed arguments' do
+        args = ['-sDEVICE=pdfwrite', '-sOutputFile=output.pdf', '-dBATCH']
+        result = shell.execute_command('echo', args, env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout]).to include('-sDEVICE=pdfwrite')
+        expect(result[:stdout]).to include('-sOutputFile=output.pdf')
+        expect(result[:stdout]).to include('-dBATCH')
+      end
+
+      it 'preserves -resize style arguments' do
+        result = shell.execute_command('echo', ['-resize', '50x50'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout]).to include('-resize')
+      end
+    end
+
+    context 'with single quotes in arguments' do
+      it 'correctly escapes single quotes by doubling them' do
+        result = shell.execute_command('echo', ["it's a test"], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout].strip).to eq("it's a test")
+      end
+
+      it 'handles multiple single quotes' do
+        result = shell.execute_command('echo', ["it's a test's value"], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout].strip).to eq("it's a test's value")
+      end
+    end
+
+    context 'with special characters in arguments' do
+      it 'handles dollar signs (escaped in double quotes)' do
+        result = shell.execute_command('echo', ['$VAR'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        # Dollar signs are escaped with backtick in double-quoted strings
+        expect(result[:stdout].strip).to eq('$VAR')
+      end
+
+      it 'handles backticks (escaped in double quotes)' do
+        result = shell.execute_command('echo', ['`hello`'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        # Backticks are escaped with backtick in double-quoted strings
+        expect(result[:stdout].strip).to eq('`hello`')
+      end
+
+      it 'handles arguments with spaces' do
+        result = shell.execute_command('echo', ['hello world'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout].strip).to eq('hello world')
+      end
+
+      it 'handles semicolons safely' do
+        result = shell.execute_command('echo', ['hello;world'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout].strip).to eq('hello;world')
+      end
+    end
+
+    context 'with executable paths' do
+      it 'handles paths with spaces' do
+        # Use /bin/echo which is a simple command that exists
+        result = shell.execute_command('/bin/echo', ['test'], env, 30, nil)
+        expect(result[:status]).to eq(0)
+        expect(result[:stdout].strip).to eq('test')
+      end
+    end
+  end
+
+  describe '#join' do
+    context 'with dash-prefixed arguments' do
+      it 'quotes arguments starting with dash with double quotes' do
+        cmd = shell.join('gs', '-sDEVICE=pdfwrite', 'input.eps', 'output.pdf')
+        expect(cmd).to include('"-sDEVICE=pdfwrite"')
+      end
+
+      it 'quotes multiple dash-prefixed arguments' do
+        cmd = shell.join('gs', '-sDEVICE=pdfwrite', '-dBATCH', 'input.eps')
+        expect(cmd).to include('"-sDEVICE=pdfwrite"')
+        expect(cmd).to include('"-dBATCH"')
+      end
+    end
+
+    context 'with arguments containing special characters' do
+      it 'quotes and escapes arguments with dollar signs' do
+        cmd = shell.join('echo', '$VAR')
+        # Dollar sign is escaped with backtick in double-quoted strings
+        expect(cmd).to include('"`$VAR"')
+      end
+
+      it 'quotes arguments with spaces' do
+        cmd = shell.join('echo', 'hello world')
+        expect(cmd).to include('"hello world"')
+      end
+    end
+
+    context 'with simple arguments' do
+      it 'does not quote simple arguments' do
+        cmd = shell.join('echo', 'hello', 'world')
+        expect(cmd).to eq('echo hello world')
+      end
+    end
+
+    context 'with executable paths containing spaces' do
+      it 'quotes the executable path' do
+        cmd = shell.join('/path with space/gs', '-sDEVICE=pdfwrite')
+        expect(cmd).to include('"/path with space/gs"')
+        expect(cmd).to include('"-sDEVICE=pdfwrite"')
+      end
+    end
+  end
+
+  describe '#execute_command_with_stdin' do
+    it 'passes stdin data correctly' do
+      result = shell.execute_command_with_stdin('cat', [], env, 30, nil, 'hello from stdin')
+      expect(result[:status]).to eq(0)
+      expect(result[:stdout].strip).to eq('hello from stdin')
+    end
+
+    it 'preserves dash-prefixed arguments with stdin' do
+      # Use /bin/echo instead of 'echo' because PowerShell's echo alias (Write-Output)
+      # doesn't handle stdin piping correctly on Unix
+      result = shell.execute_command_with_stdin('/bin/echo', ['-sDEVICE=pdfwrite'], env, 30, nil, '')
+      expect(result[:status]).to eq(0)
+      expect(result[:stdout]).to include('-sDEVICE=pdfwrite')
+    end
+  end
+
+  describe 'real-world Ghostscript command simulation' do
+    it 'formats Ghostscript-style command correctly' do
+      # Simulate the command Vectory would run
+      args = [
+        '-sDEVICE=pdfwrite',
+        '-sOutputFile=output.pdf',
+        '-dBATCH',
+        '-dNOPAUSE',
+        'input.ps'
+      ]
+      result = shell.execute_command('echo', args, env, 30, nil)
+
+      expect(result[:status]).to eq(0)
+      expect(result[:stdout]).to include('-sDEVICE=pdfwrite')
+      expect(result[:stdout]).to include('-sOutputFile=output.pdf')
+      expect(result[:stdout]).to include('-dBATCH')
+      expect(result[:stdout]).to include('-dNOPAUSE')
+      expect(result[:stdout]).to include('input.ps')
+    end
+  end
+end