ukiryu 0.1.6 → 0.2.0

data/lib/ukiryu/type.rb

@@ -78,7 +78,10 @@ module Ukiryu
         raise Ukiryu::Errors::ValidationError, 'File path cannot be empty' if value.empty?
 
         # Check if file exists (only if require_existing is true)
-        raise Ukiryu::Errors::ValidationError, "File not found: #{value}" if options[:require_existing] && !File.exist?(value)
+        if options[:require_existing] && !File.exist?(value)
+          raise Ukiryu::Errors::ValidationError,
+                "File not found: #{value}"
+        end
 
         value
       end
@@ -108,7 +111,10 @@ module Ukiryu
 
         if options[:range]
           min, max = options[:range]
-          raise Ukiryu::Errors::ValidationError, "Integer #{integer} out of range [#{min}, #{max}]" if integer < min || integer > max
+          if integer < min || integer > max
+            raise Ukiryu::Errors::ValidationError,
+                  "Integer #{integer} out of range [#{min}, #{max}]"
+          end
         end
 
         if options[:min] && integer < options[:min]
@@ -136,7 +142,10 @@ module Ukiryu
 
         if options[:range]
           min, max = options[:range]
-          raise Ukiryu::Errors::ValidationError, "Float #{float} out of range [#{min}, #{max}]" if float < min || float > max
+          if float < min || float > max
+            raise Ukiryu::Errors::ValidationError,
+                  "Float #{float} out of range [#{min}, #{max}]"
+          end
         end
 
         float
@@ -203,7 +212,10 @@ module Ukiryu
 
       # Validate hash type
       def validate_hash(value, options)
-        raise Ukiryu::Errors::ValidationError, "Hash expected, got #{value.class}: #{value.inspect}" unless value.is_a?(Hash)
+        unless value.is_a?(Hash)
+          raise Ukiryu::Errors::ValidationError,
+                "Hash expected, got #{value.class}: #{value.inspect}"
+        end
 
         if options[:keys]
           unknown_keys = value.keys - options[:keys]
@@ -218,19 +230,17 @@ module Ukiryu
 
       # Validate array type
       def validate_array(value, options)
-        # Debug logging for Ruby 4.0 CI
-        if ENV['UKIRYU_DEBUG_EXECUTABLE']
-          warn "[UKIRYU DEBUG Type.validate_array] value.class: #{value.class}"
-          warn "[UKIRYU DEBUG Type.validate_array] value.inspect: #{value.inspect}"
-          warn "[UKIRYU DEBUG Type.validate_array] options: #{options.inspect}"
-        end
+        # Debug logging for executable discovery
+        Logger.debug("Type.validate_array value.class: #{value.class}", category: :executable)
+        Logger.debug("Type.validate_array value.inspect: #{value.inspect}", category: :executable)
+        Logger.debug("Type.validate_array options: #{options.inspect}", category: :executable)
 
         array = value.is_a?(Array) ? value : [value]
 
-        if ENV['UKIRYU_DEBUG_EXECUTABLE']
-          warn "[UKIRYU DEBUG Type.validate_array] after conversion, array.class: #{array.class}"
-          warn "[UKIRYU DEBUG Type.validate_array] after conversion, array.inspect: #{array.inspect}"
-        end
+        Logger.debug("Type.validate_array after conversion, array.class: #{array.class}",
+                     category: :executable)
+        Logger.debug("Type.validate_array after conversion, array.inspect: #{array.inspect}",
+                     category: :executable)
 
         if options[:min] && array.size < options[:min]
           raise Ukiryu::Errors::ValidationError,
@@ -259,7 +269,8 @@ module Ukiryu
         # Validate element type if specified
         array = array.map { |v| validate(v, options[:of], options) } if options[:of]
 
-        warn "[UKIRYU DEBUG Type.validate_array] returning array.inspect: #{array.inspect}" if ENV['UKIRYU_DEBUG_EXECUTABLE']
+        Logger.debug("Type.validate_array returning array.inspect: #{array.inspect}",
+                     category: :executable)
 
         array
       end

data/lib/ukiryu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ukiryu
-  VERSION = '0.1.6'
+  VERSION = '0.2.0'
 end

data/lib/ukiryu.rb

@@ -46,11 +46,11 @@ module Ukiryu
   # Internal Tool implementation classes - lazy load with autoload
   autoload :CommandBuilder, 'ukiryu/command_builder'
   autoload :Cache, 'ukiryu/cache'
+  autoload :CacheRegistry, 'ukiryu/cache_registry'
   autoload :ExecutableLocator, 'ukiryu/executable_locator'
   autoload :VersionDetector, 'ukiryu/version_detector'
   autoload :ToolIndex, 'ukiryu/tool_index'
   autoload :ManPageParser, 'ukiryu/man_page_parser'
-  autoload :RegisterAutoManager, 'ukiryu/register_auto_manager'
 
   # Model classes - lazy load with autoload (these are directly under Ukiryu namespace)
   autoload :ToolMetadata, 'ukiryu/models/tool_metadata'

data/spec/fixtures/profiles/ghostscript_10.0.yaml

@@ -7,6 +7,8 @@ homepage: https://www.ghostscript.com/
 version: '10.0'
 aliases:
 - gs
+- gswin64c
+- gswin32c
 version_detection:
   command: "--version"
   pattern: "(\\d+\\.\\d+)"
@@ -18,6 +20,7 @@ search_paths:
   - "/usr/bin/gs"
   windows:
   - "C:/Program Files/gs/gs*/bin/gswin64c.exe"
+  - "C:/Program Files/gs/gs*/bin/gswin32c.exe"
 profiles:
 - name: unix
   display_name: Ghostscript on Unix
@@ -67,3 +70,50 @@ profiles:
       default: true
       assignment_delimiter: none
     name: convert
+- name: windows
+  display_name: Ghostscript on Windows
+  platforms:
+  - windows
+  shells:
+  - powershell
+  - cmd
+  version: ">= 9.0"
+  option_style: single_dash_equals
+  commands:
+  - description: Convert PostScript or PDF to other formats
+    usage: gswin64c [options] input-file
+    arguments:
+    - name: inputs
+      type: file
+      variadic: true
+      min: 1
+      position: last
+      description: Input file(s) to process
+    options:
+    - name: device
+      type: string
+      cli: "-sDEVICE"
+      description: Output device (e.g., png16m, jpeg, pdfwrite)
+      assignment_delimiter: equals
+    - name: output
+      type: file
+      cli: "-sOutputFile"
+      description: Output file path
+      assignment_delimiter: equals
+    - name: resolution
+      type: string
+      cli: "-r"
+      description: Resolution (e.g., 150, 300, or 600x600)
+      assignment_delimiter: auto
+    flags:
+    - name: quiet
+      cli: "-q"
+      description: Quiet mode
+      default: false
+      assignment_delimiter: none
+    - name: batch
+      cli: "-dBATCH"
+      description: Batch mode
+      default: true
+      assignment_delimiter: none
+    name: convert

data/spec/fixtures/register/tools/ghostscript/default/10.0.yaml

@@ -6,10 +6,15 @@ homepage: https://www.ghostscript.com/
 version: '1.0'
 aliases:
 - gs
+- gswin64c
+- gswin32c
 version_detection:
   command: "--version"
   pattern: "(\\d+\\.\\d+)"
 search_paths:
+  windows:
+  - "C:/Program Files/gs/gs*/bin/gswin64c.exe"
+  - "C:/Program Files/gs/gs*/bin/gswin32c.exe"
 implements: ghostscript/1.0
 profiles:
 - name: unix
@@ -21,6 +26,7 @@ profiles:
   - zsh
   - sh
   - fish
+  - powershell
   option_style: single_dash_space
   executable_name: ghostscript
   commands:

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