kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/spec/binding/config_validation_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Configuration validation tests
+
 RSpec.describe 'Configuration Validation' do
   describe Kreuzberg::Config::Extraction do
     it 'accepts all valid parameters' do
@@ -234,102 +236,6 @@ RSpec.describe 'Configuration Validation' do
     end
   end
 
-  describe Kreuzberg::Config::ImagePreprocessing do
-    it 'has sensible defaults' do
-      config = described_class.new
-      expect(config.target_dpi).to eq(300)
-      expect(config.auto_rotate).to be true
-      expect(config.deskew).to be true
-      expect(config.denoise).to be false
-      expect(config.contrast_enhance).to be true
-      expect(config.binarization_method).to eq('otsu')
-      expect(config.invert_colors).to be false
-    end
-
-    it 'accepts custom values' do
-      config = described_class.new(
-        target_dpi: 600,
-        auto_rotate: false,
-        deskew: false,
-        denoise: true,
-        contrast_enhance: false,
-        binarization_method: 'sauvola',
-        invert_colors: true
-      )
-      expect(config.target_dpi).to eq(600)
-      expect(config.auto_rotate).to be false
-      expect(config.deskew).to be false
-      expect(config.denoise).to be true
-      expect(config.contrast_enhance).to be false
-      expect(config.binarization_method).to eq('sauvola')
-      expect(config.invert_colors).to be true
-    end
-
-    it 'validates binarization method via FFI' do
-      expect { described_class.new(binarization_method: 'otsu') }.not_to raise_error
-      expect { described_class.new(binarization_method: 'adaptive') }.not_to raise_error
-      expect { described_class.new(binarization_method: 'sauvola') }.not_to raise_error
-    end
-
-    it 'rejects invalid binarization methods' do
-      expect do
-        described_class.new(binarization_method: 'invalid_method')
-      end.to raise_error(ArgumentError, /Invalid binarization_method/)
-    end
-
-    it 'converts to hash correctly' do
-      config = described_class.new(
-        target_dpi: 500,
-        binarization_method: 'adaptive'
-      )
-      hash = config.to_h
-      expect(hash[:target_dpi]).to eq(500)
-      expect(hash[:binarization_method]).to eq('adaptive')
-      expect(hash[:auto_rotate]).to be true
-    end
-  end
-
-  describe Kreuzberg::Config::TokenReduction do
-    it 'has sensible defaults' do
-      config = described_class.new
-      expect(config.mode).to eq('off')
-      expect(config.preserve_important_words).to be true
-    end
-
-    it 'accepts custom values' do
-      config = described_class.new(
-        mode: 'aggressive',
-        preserve_important_words: false
-      )
-      expect(config.mode).to eq('aggressive')
-      expect(config.preserve_important_words).to be false
-    end
-
-    it 'validates token reduction levels via FFI' do
-      expect { described_class.new(mode: 'off') }.not_to raise_error
-      expect { described_class.new(mode: 'light') }.not_to raise_error
-      expect { described_class.new(mode: 'moderate') }.not_to raise_error
-      expect { described_class.new(mode: 'aggressive') }.not_to raise_error
-      expect { described_class.new(mode: 'maximum') }.not_to raise_error
-    end
-
-    it 'rejects invalid token reduction modes' do
-      expect do
-        described_class.new(mode: 'extreme')
-      end.to raise_error(ArgumentError, /Invalid token reduction mode/)
-    end
-
-    it 'converts to hash correctly' do
-      config = described_class.new(
-        mode: 'light',
-        preserve_important_words: true
-      )
-      hash = config.to_h
-      expect(hash[:mode]).to eq('light')
-      expect(hash[:preserve_important_words]).to be true
-    end
-  end
-
   describe 'config usage in extraction' do
     it 'works with OCR config' do
       path = create_test_file('OCR config test')
@@ -337,7 +243,7 @@ RSpec.describe 'Configuration Validation' do
         ocr: Kreuzberg::Config::OCR.new(backend: 'tesseract', language: 'eng')
       )
 
-      result = Kreuzberg.extract_file_sync(path: path, config: config)
+      result = Kreuzberg.extract_file_sync(path, config: config)
       expect(result).to be_a(Kreuzberg::Result)
     end
 
@@ -347,7 +253,7 @@ RSpec.describe 'Configuration Validation' do
         chunking: Kreuzberg::Config::Chunking.new(max_chars: 50)
       )
 
-      result = Kreuzberg.extract_file_sync(path: path, config: config)
+      result = Kreuzberg.extract_file_sync(path, config: config)
       expect(result).to be_a(Kreuzberg::Result)
     end
 
@@ -357,7 +263,7 @@ RSpec.describe 'Configuration Validation' do
         language_detection: Kreuzberg::Config::LanguageDetection.new(enabled: true)
       )
 
-      result = Kreuzberg.extract_file_sync(path: path, config: config)
+      result = Kreuzberg.extract_file_sync(path, config: config)
       expect(result).to be_a(Kreuzberg::Result)
     end
 
@@ -370,7 +276,7 @@ RSpec.describe 'Configuration Validation' do
         language_detection: { enabled: false }
       )
 
-      result = Kreuzberg.extract_file_sync(path: path, config: config)
+      result = Kreuzberg.extract_file_sync(path, config: config)
       expect(result).to be_a(Kreuzberg::Result)
     end
   end

data/spec/binding/error_handling_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Error handling and exception mapping tests
+
 RSpec.describe 'Error Handling' do
   let(:nested_ocr_result) do
     {
@@ -32,362 +34,163 @@ RSpec.describe 'Error Handling' do
     }
   end
 
-  describe 'invalid configuration handling' do
-    it 'raises error for negative max_chars in chunking' do
-      # rubocop:disable Style/MultilineBlockChain
-      expect do
-        Kreuzberg::Config::Extraction.new(
-          chunking: Kreuzberg::Config::Chunking.new(max_chars: -100)
-        )
-      end.to raise_error do |error|
-        expect(error).to be_a(StandardError)
-        expect(error.message.downcase).to match(/negative|invalid|positive|max_chars/)
-      end
-      # rubocop:enable Style/MultilineBlockChain
-    end
-
-    it 'raises error for negative max_overlap in chunking' do
-      # rubocop:disable Style/MultilineBlockChain
-      expect do
-        Kreuzberg::Config::Chunking.new(max_overlap: -50)
-      end.to raise_error do |error|
-        expect(error).to be_a(StandardError)
-        expect(error.message.downcase).to match(/negative|invalid|overlap/)
-      end
-      # rubocop:enable Style/MultilineBlockChain
-    end
-
-    it 'raises ArgumentError for invalid OCR config type' do
-      # rubocop:disable Style/MultilineBlockChain
-      expect do
-        Kreuzberg::Config::Extraction.new(ocr: 'invalid_string')
-      end.to raise_error(ArgumentError) do |error|
-        expect(error.message).to include('Expected')
-        expect(error.message).to include('OCR')
-      end
-      # rubocop:enable Style/MultilineBlockChain
-    end
-
-    it 'raises ArgumentError for invalid chunking config type' do
+  describe 'file not found errors' do
+    it 'raises error for non-existent file' do
       expect do
-        Kreuzberg::Config::Extraction.new(chunking: 123)
-      end.to raise_error(ArgumentError)
-    end
-
-    it 'raises ArgumentError for invalid language_detection config' do
-      expect do
-        Kreuzberg::Config::Extraction.new(language_detection: [])
-      end.to raise_error(ArgumentError)
-    end
-
-    it 'raises ArgumentError for invalid pdf_options config' do
-      expect do
-        Kreuzberg::Config::Extraction.new(pdf_options: 'invalid_string')
-      end.to raise_error(ArgumentError)
-    end
-
-    it 'provides descriptive error messages for config validation' do
-      error = nil
-      begin
-        Kreuzberg::Config::Extraction.new(ocr: 12_345)
-      rescue ArgumentError => e
-        error = e
-      end
-
-      expect(error).not_to be_nil
-      expect(error.message).to be_a(String)
-      expect(error.message).not_to be_empty
-    end
-  end
-
-  describe 'file not found and corrupted files' do
-    it 'raises error for non-existent file with meaningful message' do
-      # rubocop:disable Style/MultilineBlockChain
-      expect do
-        Kreuzberg.extract_file_sync(path: '/nonexistent/path/file.txt')
-      end.to raise_error do |error|
-        expect(error).to be_a(StandardError)
-        expect(error.message).not_to be_empty
-      end
-      # rubocop:enable Style/MultilineBlockChain
+        Kreuzberg.extract_file_sync('/nonexistent/path/file.txt')
+      end.to raise_error(StandardError)
     end
 
-    it 'raises error for empty file path' do
+    it 'raises error for empty path' do
       expect do
-        Kreuzberg.extract_file_sync(path: '')
+        Kreuzberg.extract_file_sync('')
       end.to raise_error(StandardError)
     end
 
-    it 'raises error for nil file path' do
+    it 'raises error for nil path' do
       expect do
-        Kreuzberg.extract_file_sync(path: nil)
+        Kreuzberg.extract_file_sync(nil)
       end.to raise_error(StandardError)
     end
+  end
 
-    it 'handles corrupted file gracefully' do
-      # Create a file with binary garbage that is not a valid document
-      corrupted_path = create_test_file("\x00\x01\x02\xFF\xFE\xFD", filename: 'corrupted.bin')
+  describe 'invalid MIME type handling' do
+    it 'handles unknown MIME types' do
+      path = create_test_file('Unknown MIME')
 
+      # Implementation may either handle gracefully or raise error for unknown MIME types
       begin
-        result = Kreuzberg.extract_file_sync(path: corrupted_path, mime_type: 'application/octet-stream')
-        # May succeed with empty content or raise error - both acceptable
+        result = Kreuzberg.extract_file_sync(path, mime_type: 'application/x-unknown-type')
         expect(result).to be_a(Kreuzberg::Result)
-      rescue Kreuzberg::Errors::ParsingError => e
-        expect(e).to be_a(Kreuzberg::Errors::ParsingError)
-        expect(e.message).not_to be_empty
       rescue StandardError => e
         expect(e).to be_a(StandardError)
       end
     end
   end
 
-  describe 'invalid MIME type handling' do
-    it 'gracefully handles unknown MIME types' do
-      path = create_test_file('Content with unknown type')
-
-      result_or_error = nil
-      begin
-        result_or_error = Kreuzberg.extract_file_sync(path, mime_type: 'application/x-custom-unknown-format')
-      rescue Kreuzberg::Errors::UnsupportedFormatError, StandardError => e
-        result_or_error = e
-      end
-
-      if result_or_error.is_a?(Kreuzberg::Result)
-        expect(result_or_error).to be_a(Kreuzberg::Result)
-      else
-        expect(result_or_error).to be_a(StandardError)
-        expect(result_or_error.message).not_to be_empty
-      end
+  describe 'invalid configuration' do
+    it 'raises error for invalid ocr config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(ocr: 'invalid')
+      end.to raise_error(ArgumentError)
     end
 
-    it 'handles malformed MIME type strings' do
-      path = create_test_file('Test content')
-
-      # Either succeeds or raises with meaningful error - both acceptable
-      result_or_error = nil
-      begin
-        result_or_error = Kreuzberg.extract_file_sync(path, mime_type: '///invalid@@@')
-      rescue StandardError => e
-        result_or_error = e
-      end
-
-      expect([Kreuzberg::Result, StandardError].any? { |klass| result_or_error.is_a?(klass) }).to be_truthy
+    it 'raises error for invalid chunking config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(chunking: 123)
+      end.to raise_error(ArgumentError)
     end
 
-    it 'rejects empty MIME type with appropriate error' do
-      path = create_test_file('Test')
-
-      # Empty MIME type should either be rejected or handled gracefully
-      result_or_error = nil
-      begin
-        Kreuzberg.extract_file_sync(path, mime_type: '')
-      rescue StandardError => e
-        result_or_error = e
-      end
-
-      expect(result_or_error).to be_a(StandardError) if result_or_error
+    it 'raises error for invalid language_detection config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(language_detection: [])
+      end.to raise_error(ArgumentError)
     end
-  end
-
-  describe 'permission and I/O errors' do
-    it 'raises IOError or subclass for permission denied scenario' do
-      # This is environment-dependent, so we test gracefully
-
-      # Try to write to a file we cannot read from (if setup permits)
-      test_file = create_test_file('test content')
-      File.chmod(0o000, test_file)
 
-      begin
-        Kreuzberg.extract_file_sync(path: test_file)
-      ensure
-        File.chmod(0o644, test_file)
-      end
-    rescue Kreuzberg::Errors::IOError => e
-      expect(e).to be_a(Kreuzberg::Errors::IOError)
-    rescue Errno::EACCES
-      # Platform-specific permission error is acceptable
-      expect(true).to be_truthy
-    rescue StandardError => e
-      # Other IO errors are acceptable
-      expect(e).to be_a(StandardError)
+    it 'raises error for invalid pdf_options config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(pdf_options: 'invalid')
+      end.to raise_error(ArgumentError)
     end
   end
 
-  describe 'malformed document handling' do
-    it 'handles invalid JSON metadata gracefully' do
-      result = Kreuzberg::Result.new(
-        content: 'Test content',
-        mime_type: 'text/plain',
-        metadata_json: 'this is not valid json {'
-      )
-
-      expect(result.content).to eq('Test content')
-      expect(result.metadata).to eq({})
-      expect(result.metadata).to be_a(Hash)
-    end
-
-    it 'handles empty metadata JSON' do
-      result = Kreuzberg::Result.new(
-        content: 'Test',
-        mime_type: 'text/plain',
-        metadata_json: ''
-      )
-
-      expect(result.metadata).to eq({})
-      expect(result.content).to eq('Test')
-    end
-
-    it 'handles nil metadata JSON' do
-      result = Kreuzberg::Result.new(
-        content: 'Test',
-        mime_type: 'text/plain',
-        metadata_json: nil
-      )
-
-      expect(result.metadata).to eq({})
-    end
-
-    it 'handles malformed result object gracefully' do
-      result = Kreuzberg::Result.new({})
-
-      expect(result.content).to eq('')
-      expect(result.mime_type).to eq('')
-      expect(result.metadata).to eq({})
-      expect(result.tables).to eq([])
-      expect(result.detected_languages).to be_nil
-      expect(result.chunks).to eq([])
-      expect(result.images).to be_nil
-    end
-
-    it 'handles partial result data without errors' do
-      result = Kreuzberg::Result.new(
-        content: 'Partial content',
-        mime_type: 'text/plain'
-      )
-
-      expect(result.content).to eq('Partial content')
-      expect(result.mime_type).to eq('text/plain')
-      expect(result.tables).to eq([])
-      expect(result.metadata).to eq({})
+  describe 'error context' do
+    it 'provides meaningful error messages' do
+      Kreuzberg.extract_file_sync('/nonexistent/file.pdf')
+      raise 'Expected an error to be raised'
+    rescue StandardError => e
+      expect(e.message).not_to be_empty
     end
   end
 
-  describe 'batch extraction error handling' do
-    it 'handles mixed valid and invalid files in batch' do
+  describe 'batch extraction errors' do
+    it 'handles mixed valid and invalid files' do
       files = [
-        create_test_file('Valid file content'),
+        create_test_file('Valid'),
         '/definitely/nonexistent/file.txt'
       ]
 
+      # Implementation may either raise error or handle gracefully
       begin
         result = Kreuzberg.batch_extract_files_sync(files)
         expect(result).to be_an(Array)
       rescue StandardError => e
         expect(e).to be_a(StandardError)
-        expect(e.message).not_to be_empty
       end
     end
 
-    it 'handles all invalid files in batch without crashing' do
+    it 'handles all invalid files' do
       files = [
         '/nonexistent1.txt',
         '/nonexistent2.txt',
         '/nonexistent3.txt'
       ]
 
+      # Batch operations may either fail fast or return partial results
       begin
         result = Kreuzberg.batch_extract_files_sync(files)
+        # If no error is raised, result should be an array (possibly empty or with errors)
         expect(result).to be_an(Array)
       rescue StandardError => e
-        expect(e).to be_a(StandardError)
-      end
-    end
-
-    it 'provides error context in batch results' do
-      files = [
-        create_test_file('First file'),
-        '/nonexistent/second.txt'
-      ]
-
-      begin
-        results = Kreuzberg.batch_extract_files_sync(files)
-        expect(results).to be_an(Array)
-      rescue StandardError => e
+        # If error is raised, it should be a StandardError
         expect(e).to be_a(StandardError)
       end
     end
   end
 
-  describe 'concurrent error states' do
-    it 'handles rapid successive error operations' do
-      errors = []
-
-      3.times do |i|
-        Kreuzberg.extract_file_sync(path: "/nonexistent#{i}.pdf")
-      rescue StandardError => e
-        errors << e
-      end
-
-      expect(errors.length).to eq(3)
-      expect(errors).to all(be_a(StandardError))
+  describe 'async error handling' do
+    it 'propagates errors in async extraction' do
+      expect do
+        Kreuzberg.extract_file('/nonexistent/async/file.txt')
+      end.to raise_error(StandardError)
     end
-  end
-
-  describe 'error recovery and graceful degradation' do
-    it 'recovers gracefully after file not found error' do
-      # First operation: try to extract from nonexistent file
-      error_caught = false
-      begin
-        Kreuzberg.extract_file_sync(path: '/nonexistent/does_not_exist.txt')
-      rescue StandardError
-        error_caught = true
-      end
-
-      expect(error_caught).to be_truthy
 
-      # Second operation: should work fine with valid file
-      valid_file = create_test_file('Valid content after error')
-      result = Kreuzberg.extract_file_sync(path: valid_file)
+    it 'propagates errors in async bytes extraction' do
+      # Implementation may either handle invalid MIME types or raise error
 
+      result = Kreuzberg.extract_bytes('data', 'invalid/mime/type/that/causes/error')
       expect(result).to be_a(Kreuzberg::Result)
+    rescue StandardError => e
+      expect(e).to be_a(StandardError)
     end
+  end
 
-    it 'handles mixed error and success scenarios in sequence' do
-      results = []
-
-      # Try invalid file
-      begin
-        Kreuzberg.extract_file_sync(path: '/nonexistent/file1.txt')
-      rescue StandardError
-        results << :error1
-      end
+  describe 'result parsing errors' do
+    it 'handles malformed result gracefully' do
+      # This tests the Result class constructor with edge cases
+      result = Kreuzberg::Result.new({})
 
-      # Valid extraction
-      valid_file = create_test_file('Valid content')
-      Kreuzberg.extract_file_sync(valid_file)
-      results << :success1
+      expect(result.content).to eq('')
+      expect(result.mime_type).to eq('')
+      expect(result.metadata).to eq({})
+      expect(result.tables).to eq([])
+      expect(result.detected_languages).to be_nil
+      expect(result.chunks).to be_nil
+      expect(result.images).to be_nil
+    end
 
-      # Another invalid file
-      begin
-        Kreuzberg.extract_file_sync(path: '/nonexistent/file2.txt')
-      rescue StandardError
-        results << :error2
-      end
+    it 'handles partial result data' do
+      result = Kreuzberg::Result.new(
+        content: 'Test',
+        mime_type: 'text/plain'
+      )
 
-      expect(results).to eq(%i[error1 success1 error2])
+      expect(result.content).to eq('Test')
+      expect(result.mime_type).to eq('text/plain')
+      expect(result.tables).to eq([])
     end
-  end
 
-  describe 'type conversion and coercion errors' do
-    it 'handles non-string content in results gracefully' do
-      path = create_test_file('Type coercion test')
-      result = Kreuzberg.extract_file_sync(path: path)
+    it 'parses invalid metadata JSON' do
+      result = Kreuzberg::Result.new(
+        content: 'Test',
+        mime_type: 'text/plain',
+        metadata_json: 'invalid json{'
+      )
 
-      expect(result.content).to be_a(String)
-      expect(result.mime_type).to be_a(String)
+      expect(result.metadata).to eq({})
     end
 
-    it 'extracts images with proper encoding handling' do
+    it 'parses extracted images' do
       result = Kreuzberg::Result.new(image_result_payload)
       image = result.images&.first
 
@@ -396,4 +199,15 @@ RSpec.describe 'Error Handling' do
       expect(image&.ocr_result).to be_a(Kreuzberg::Result)
     end
   end
+
+  describe 'type conversion errors' do
+    it 'handles non-string content gracefully' do
+      # Test that the wrapper handles type coercion
+      path = create_test_file('Type test')
+      result = Kreuzberg.extract_file_sync(path)
+
+      expect(result.content).to be_a(String)
+      expect(result.mime_type).to be_a(String)
+    end
+  end
 end

data/spec/binding/plugins/ocr_backend_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe 'OCR Backend Plugin System' do
         ocr: Kreuzberg::Config::Ocr.new(backend: 'mock-ocr')
       )
 
-      result = Kreuzberg.extract_file_sync(path: test_image, config: config)
+      result = Kreuzberg.extract_file_sync(test_image, config: config)
 
       expect(backend.process_called).to be true
       expect(result.content).to include('Mocked OCR text')
@@ -69,7 +69,7 @@ RSpec.describe 'OCR Backend Plugin System' do
         )
       )
 
-      Kreuzberg.extract_file_sync(path: test_image, config: config)
+      Kreuzberg.extract_file_sync(test_image, config: config)
 
       expect(backend.received_config).to be_a(Hash)
       expect(backend.received_config['backend']).to eq('config-capture')
@@ -102,7 +102,7 @@ RSpec.describe 'OCR Backend Plugin System' do
         ocr: Kreuzberg::Config::Ocr.new(backend: 'bytes-capture')
       )
 
-      Kreuzberg.extract_file_sync(path: test_image, config: config)
+      Kreuzberg.extract_file_sync(test_image, config: config)
 
       received_bytes = BytesCapturingBackend.instance_variable_get(:@received_bytes)
       expect(received_bytes).to be_a(String)
@@ -131,7 +131,7 @@ RSpec.describe 'OCR Backend Plugin System' do
         ocr: Kreuzberg::Config::Ocr.new(backend: 'simple-ocr')
       )
 
-      result = Kreuzberg.extract_file_sync(path: test_image, config: config)
+      result = Kreuzberg.extract_file_sync(test_image, config: config)
 
       expect(result.content).to include('Invoice Total')
       expect(result.content).to include('1,234.56')
@@ -167,8 +167,8 @@ RSpec.describe 'OCR Backend Plugin System' do
         ocr: Kreuzberg::Config::Ocr.new(backend: 'stateful-ocr')
       )
 
-      Kreuzberg.extract_file_sync(path: test_image, config: config)
-      Kreuzberg.extract_file_sync(path: test_image, config: config)
+      Kreuzberg.extract_file_sync(test_image, config: config)
+      Kreuzberg.extract_file_sync(test_image, config: config)
 
       expect(backend.call_count).to be >= 1
     end
@@ -197,7 +197,7 @@ RSpec.describe 'OCR Backend Plugin System' do
       )
 
       expect do
-        Kreuzberg.extract_file_sync(path: test_image, config: config)
+        Kreuzberg.extract_file_sync(test_image, config: config)
       end.to raise_error(StandardError, /OCR processing failed/)
     end
 
@@ -208,7 +208,7 @@ RSpec.describe 'OCR Backend Plugin System' do
       )
 
       expect do
-        Kreuzberg.extract_file_sync(path: test_image, config: config)
+        Kreuzberg.extract_file_sync(test_image, config: config)
       end.to raise_error
     end
   end