kreuzberg 4.0.0.rc1

data/spec/binding/config_validation_spec.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# Configuration validation tests
+
+RSpec.describe 'Configuration Validation' do
+  describe Kreuzberg::Config::Extraction do
+    it 'accepts all valid parameters' do
+      config = described_class.new(
+        use_cache: true,
+        enable_quality_processing: false,
+        force_ocr: false,
+        ocr: Kreuzberg::Config::OCR.new,
+        chunking: Kreuzberg::Config::Chunking.new,
+        language_detection: Kreuzberg::Config::LanguageDetection.new,
+        pdf_options: Kreuzberg::Config::PDF.new
+      )
+
+      expect(config.use_cache).to be true
+      expect(config.enable_quality_processing).to be false
+      expect(config.force_ocr).to be false
+      expect(config.ocr).to be_a(Kreuzberg::Config::OCR)
+      expect(config.chunking).to be_a(Kreuzberg::Config::Chunking)
+      expect(config.language_detection).to be_a(Kreuzberg::Config::LanguageDetection)
+      expect(config.pdf_options).to be_a(Kreuzberg::Config::PDF)
+    end
+
+    it 'accepts hashes for nested configs' do
+      config = described_class.new(
+        ocr: { backend: 'tesseract', language: 'eng' },
+        chunking: { max_chars: 500 }
+      )
+
+      expect(config.ocr).to be_a(Kreuzberg::Config::OCR)
+      expect(config.ocr.backend).to eq('tesseract')
+      expect(config.chunking).to be_a(Kreuzberg::Config::Chunking)
+      expect(config.chunking.max_chars).to eq(500)
+    end
+
+    it 'validates ocr config type' do
+      expect do
+        described_class.new(ocr: 'invalid')
+      end.to raise_error(ArgumentError, /Expected.*OCR/)
+    end
+
+    it 'validates chunking config type' do
+      expect do
+        described_class.new(chunking: 'invalid')
+      end.to raise_error(ArgumentError, /Expected.*Chunking/)
+    end
+
+    it 'converts to hash correctly' do
+      config = described_class.new(
+        use_cache: false,
+        force_ocr: true
+      )
+      hash = config.to_h
+
+      expect(hash).to be_a(Hash)
+      expect(hash[:use_cache]).to be false
+      expect(hash[:force_ocr]).to be true
+    end
+
+    it 'omits nil values from hash' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash[:ocr]).to be_nil
+      expect(hash[:chunking]).to be_nil
+    end
+
+    it 'accepts html options hashes' do
+      config = described_class.new(html_options: { heading_style: :atx, wrap: true })
+      expect(config.html_options).to be_a(Kreuzberg::Config::HtmlOptions)
+      expect(config.html_options.to_h[:heading_style]).to eq(:atx)
+    end
+
+    it 'accepts keyword configurations' do
+      keywords = Kreuzberg::Config::Keywords.new(algorithm: :yake, max_keywords: 5)
+      config = described_class.new(keywords: keywords, max_concurrent_extractions: 4)
+      expect(config.keywords).to be_a(Kreuzberg::Config::Keywords)
+      expect(config.max_concurrent_extractions).to eq(4)
+    end
+  end
+
+  describe Kreuzberg::Config::OCR do
+    it 'has sensible defaults' do
+      config = described_class.new
+
+      expect(config.backend).to eq('tesseract')
+      expect(config.language).to eq('eng')
+      expect(config.tesseract_config).to be_nil
+    end
+
+    it 'accepts custom values' do
+      config = described_class.new(
+        backend: 'easyocr',
+        language: 'deu'
+      )
+
+      expect(config.backend).to eq('easyocr')
+      expect(config.language).to eq('deu')
+    end
+
+    it 'coerces types correctly' do
+      config = described_class.new(
+        backend: :tesseract,
+        language: 123
+      )
+
+      expect(config.backend).to eq('tesseract')
+      expect(config.language).to eq('123')
+    end
+
+    it 'accepts tesseract config hashes' do
+      config = described_class.new(
+        tesseract_config: {
+          psm: 6,
+          enable_table_detection: true
+        }
+      )
+
+      expect(config.tesseract_config).to be_a(Kreuzberg::Config::Tesseract)
+      expect(config.tesseract_config.to_h[:psm]).to eq(6)
+    end
+  end
+
+  describe Kreuzberg::Config::Chunking do
+    it 'has sensible defaults' do
+      config = described_class.new
+
+      expect(config.max_chars).to eq(1000)
+      expect(config.max_overlap).to eq(200)
+      expect(config.preset).to be_nil
+    end
+
+    it 'accepts custom chunk sizes' do
+      config = described_class.new(
+        max_chars: 500,
+        max_overlap: 100
+      )
+
+      expect(config.max_chars).to eq(500)
+      expect(config.max_overlap).to eq(100)
+    end
+
+    it 'supports different strategies' do
+      config = described_class.new(preset: 'fast')
+      expect(config.preset).to eq('fast')
+    end
+
+    it 'accepts embedding configs' do
+      embedding = { model: { type: :preset, name: 'quality' }, normalize: false }
+      config = described_class.new(embedding: embedding)
+      expect(config.embedding).to be_a(Kreuzberg::Config::Embedding)
+      expect(config.embedding.to_h[:model]).to include(type: :preset, name: 'quality')
+    end
+  end
+
+  describe Kreuzberg::Config::LanguageDetection do
+    it 'has sensible defaults' do
+      config = described_class.new
+
+      expect(config.enabled).to be false
+      expect(config.min_confidence).to eq(0.5)
+    end
+
+    it 'accepts custom confidence thresholds' do
+      config = described_class.new(
+        enabled: true,
+        min_confidence: 0.9
+      )
+
+      expect(config.enabled).to be true
+      expect(config.min_confidence).to eq(0.9)
+    end
+
+    it 'coerces confidence to float' do
+      config = described_class.new(min_confidence: '0.75')
+      expect(config.min_confidence).to eq(0.75)
+    end
+
+    it 'supports detect_multiple flag' do
+      config = described_class.new(detect_multiple: true)
+      expect(config.detect_multiple).to be true
+      expect(config.to_h[:detect_multiple]).to be true
+    end
+  end
+
+  describe Kreuzberg::Config::PDF do
+    it 'has sensible defaults' do
+      config = described_class.new
+
+      expect(config.extract_images).to be false
+      expect(config.passwords).to be_nil
+      expect(config.extract_metadata).to be true
+    end
+
+    it 'accepts custom values' do
+      config = described_class.new(
+        extract_images: true,
+        passwords: ['secret123']
+      )
+
+      expect(config.extract_images).to be true
+      expect(config.passwords).to eq(['secret123'])
+    end
+
+    it 'converts password to string' do
+      config = described_class.new(passwords: 12_345)
+      expect(config.passwords).to eq(['12345'])
+    end
+  end
+
+  describe Kreuzberg::Config::HtmlOptions do
+    it 'normalizes preprocessing settings' do
+      options = described_class.new(
+        heading_style: :atx_closed,
+        preprocessing: { enabled: true, preset: :standard }
+      )
+      hash = options.to_h
+      expect(hash[:heading_style]).to eq(:atx_closed)
+      expect(hash[:preprocessing]).to include(preset: :standard)
+    end
+  end
+
+  describe Kreuzberg::Config::Keywords do
+    it 'accepts hash arguments' do
+      config = described_class.new(
+        algorithm: :yake,
+        max_keywords: 10,
+        ngram_range: [1, 3],
+        yake_params: { window_size: 4 }
+      )
+      expect(config.to_h[:algorithm]).to eq('yake')
+      expect(config.to_h[:yake_params]).to eq(window_size: 4)
+    end
+  end
+
+  describe 'config usage in extraction' do
+    it 'works with OCR config' do
+      path = create_test_file('OCR config test')
+      config = Kreuzberg::Config::Extraction.new(
+        ocr: Kreuzberg::Config::OCR.new(backend: 'tesseract', language: 'eng')
+      )
+
+      result = Kreuzberg.extract_file_sync(path, config: config)
+      expect(result).to be_a(Kreuzberg::Result)
+    end
+
+    it 'works with chunking config' do
+      path = create_test_file('Chunking config test' * 50)
+      config = Kreuzberg::Config::Extraction.new(
+        chunking: Kreuzberg::Config::Chunking.new(max_chars: 50)
+      )
+
+      result = Kreuzberg.extract_file_sync(path, config: config)
+      expect(result).to be_a(Kreuzberg::Result)
+    end
+
+    it 'works with language detection config' do
+      path = create_test_file('Language detection test')
+      config = Kreuzberg::Config::Extraction.new(
+        language_detection: Kreuzberg::Config::LanguageDetection.new(enabled: true)
+      )
+
+      result = Kreuzberg.extract_file_sync(path, config: config)
+      expect(result).to be_a(Kreuzberg::Result)
+    end
+
+    it 'works with combined configs' do
+      path = create_test_file('Combined config test')
+      config = Kreuzberg::Config::Extraction.new(
+        use_cache: false,
+        force_ocr: false,
+        ocr: { backend: 'tesseract', language: 'eng' },
+        language_detection: { enabled: false }
+      )
+
+      result = Kreuzberg.extract_file_sync(path, config: config)
+      expect(result).to be_a(Kreuzberg::Result)
+    end
+  end
+end

data/spec/binding/error_handling_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# Error handling and exception mapping tests
+
+RSpec.describe 'Error Handling' do
+  let(:nested_ocr_result) do
+    {
+      'content' => 'ocr text',
+      'mime_type' => 'text/plain',
+      'metadata_json' => '{}',
+      'tables' => []
+    }
+  end
+
+  let(:image_result_payload) do
+    {
+      content: 'Test',
+      mime_type: 'text/plain',
+      images: [
+        {
+          'data' => "binary\0data",
+          'format' => 'png',
+          'image_index' => 0,
+          'page_number' => 1,
+          'width' => 100,
+          'height' => 200,
+          'colorspace' => 'RGB',
+          'bits_per_component' => 8,
+          'is_mask' => false,
+          'description' => 'inline image',
+          'ocr_result' => nested_ocr_result
+        }
+      ]
+    }
+  end
+
+  describe 'file not found errors' do
+    it 'raises error for non-existent file' do
+      expect do
+        Kreuzberg.extract_file_sync('/nonexistent/path/file.txt')
+      end.to raise_error(StandardError)
+    end
+
+    it 'raises error for empty path' do
+      expect do
+        Kreuzberg.extract_file_sync('')
+      end.to raise_error(StandardError)
+    end
+
+    it 'raises error for nil path' do
+      expect do
+        Kreuzberg.extract_file_sync(nil)
+      end.to raise_error(StandardError)
+    end
+  end
+
+  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, mime_type: 'application/x-unknown-type')
+        expect(result).to be_a(Kreuzberg::Result)
+      rescue StandardError => e
+        expect(e).to be_a(StandardError)
+      end
+    end
+  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 'raises error for invalid chunking config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(chunking: 123)
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'raises error for invalid language_detection config' do
+      expect do
+        Kreuzberg::Config::Extraction.new(language_detection: [])
+      end.to raise_error(ArgumentError)
+    end
+
+    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 '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 errors' do
+    it 'handles mixed valid and invalid files' do
+      files = [
+        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)
+      end
+    end
+
+    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
+        # If error is raised, it should be a StandardError
+        expect(e).to be_a(StandardError)
+      end
+    end
+  end
+
+  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
+
+    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
+
+  describe 'result parsing errors' do
+    it 'handles malformed result gracefully' do
+      # This tests the Result class constructor with edge cases
+      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 be_nil
+      expect(result.images).to be_nil
+    end
+
+    it 'handles partial result data' do
+      result = Kreuzberg::Result.new(
+        content: 'Test',
+        mime_type: 'text/plain'
+      )
+
+      expect(result.content).to eq('Test')
+      expect(result.mime_type).to eq('text/plain')
+      expect(result.tables).to eq([])
+    end
+
+    it 'parses invalid metadata JSON' do
+      result = Kreuzberg::Result.new(
+        content: 'Test',
+        mime_type: 'text/plain',
+        metadata_json: 'invalid json{'
+      )
+
+      expect(result.metadata).to eq({})
+    end
+
+    it 'parses extracted images' do
+      result = Kreuzberg::Result.new(image_result_payload)
+      image = result.images&.first
+
+      expect(image&.format).to eq('png')
+      expect(image&.data&.encoding).to eq(Encoding::BINARY)
+      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/errors_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Errors do
+  describe Kreuzberg::Errors::Error do
+    it 'is a StandardError subclass' do
+      expect(described_class).to be < StandardError
+    end
+
+    it 'can be raised with a message' do
+      expect do
+        raise described_class, 'Test error'
+      end.to raise_error(described_class, 'Test error')
+    end
+  end
+
+  describe Kreuzberg::Errors::ValidationError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+  end
+
+  describe Kreuzberg::Errors::ParsingError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+
+    it 'stores context' do
+      error = described_class.new('Parsing failed', context: { file: 'test.pdf' })
+      expect(error.context).to eq({ file: 'test.pdf' })
+    end
+  end
+
+  describe Kreuzberg::Errors::OCRError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+
+    it 'stores context' do
+      error = described_class.new('OCR failed', context: { page: 1 })
+      expect(error.context).to eq({ page: 1 })
+    end
+  end
+
+  describe Kreuzberg::Errors::MissingDependencyError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+
+    it 'stores dependency name' do
+      error = described_class.new('Tesseract not found', dependency: 'tesseract')
+      expect(error.dependency).to eq('tesseract')
+    end
+  end
+
+  describe Kreuzberg::Errors::IOError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+  end
+
+  describe Kreuzberg::Errors::PluginError do
+    it 'is an Error subclass' do
+      expect(described_class).to be < Kreuzberg::Errors::Error
+    end
+  end
+end