kreuzberg 4.3.5-aarch64-linux

data/spec/unit/config/extraction_config_spec.rb

@@ -0,0 +1,434 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::Extraction do
+  describe '#initialize' do
+    it 'creates config with default values' do
+      config = described_class.new
+
+      expect(config.use_cache).to be true
+      expect(config.enable_quality_processing).to be true
+      expect(config.force_ocr).to be false
+      expect(config.ocr).to be_nil
+      expect(config.chunking).to be_nil
+      expect(config.language_detection).to be_nil
+      expect(config.pdf_options).to be_nil
+      expect(config.image_extraction).to be_nil
+      expect(config.postprocessor).to be_nil
+      expect(config.token_reduction).to be_nil
+      expect(config.keywords).to be_nil
+      expect(config.html_options).to be_nil
+      expect(config.pages).to be_nil
+      expect(config.max_concurrent_extractions).to be_nil
+    end
+
+    it 'creates config with custom boolean values' do
+      config = described_class.new(
+        use_cache: false,
+        enable_quality_processing: true,
+        force_ocr: true
+      )
+
+      expect(config.use_cache).to be false
+      expect(config.enable_quality_processing).to be true
+      expect(config.force_ocr).to be true
+    end
+
+    it 'accepts all nested config instances' do
+      ocr = Kreuzberg::Config::OCR.new(backend: 'tesseract')
+      chunking = Kreuzberg::Config::Chunking.new(max_chars: 500)
+      lang_detect = Kreuzberg::Config::LanguageDetection.new(enabled: true)
+
+      config = described_class.new(
+        ocr: ocr,
+        chunking: chunking,
+        language_detection: lang_detect
+      )
+
+      expect(config.ocr).to be ocr
+      expect(config.chunking).to be chunking
+      expect(config.language_detection).to be lang_detect
+    end
+
+    it 'converts nested config hashes to instances' do
+      config = described_class.new(
+        ocr: { backend: 'easyocr', language: 'fra' },
+        chunking: { max_chars: 750 }
+      )
+
+      expect(config.ocr).to be_a Kreuzberg::Config::OCR
+      expect(config.ocr.backend).to eq 'easyocr'
+      expect(config.chunking).to be_a Kreuzberg::Config::Chunking
+      expect(config.chunking.max_chars).to eq 750
+    end
+
+    it 'converts max_concurrent_extractions to integer' do
+      config = described_class.new(max_concurrent_extractions: '4')
+
+      expect(config.max_concurrent_extractions).to eq 4
+      expect(config.max_concurrent_extractions).to be_a Integer
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash' do
+      config = described_class.new(use_cache: true)
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:use_cache]).to be true
+    end
+
+    it 'includes all nested configs in hash' do
+      config = described_class.new(
+        ocr: { backend: 'tesseract' },
+        chunking: { max_chars: 500 }
+      )
+      hash = config.to_h
+
+      expect(hash[:ocr]).to be_a Hash
+      expect(hash[:chunking]).to be_a Hash
+    end
+
+    it 'compacts nil nested configs from hash' do
+      config = described_class.new(use_cache: true)
+      hash = config.to_h
+
+      expect(hash.key?(:ocr)).to be false
+      expect(hash.key?(:chunking)).to be false
+    end
+
+    it 'always includes top-level boolean values' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash[:use_cache]).to be true
+      expect(hash[:enable_quality_processing]).to be true
+      expect(hash[:force_ocr]).to be false
+    end
+  end
+
+  describe '#to_json' do
+    it 'serializes to JSON string' do
+      config = described_class.new(use_cache: true, force_ocr: false)
+      json = config.to_json
+
+      expect(json).to be_a String
+      parsed = JSON.parse(json)
+      expect(parsed['use_cache']).to be true
+      expect(parsed['force_ocr']).to be false
+    end
+
+    it 'handles nested configs in JSON' do
+      config = described_class.new(ocr: { backend: 'tesseract' })
+      json = config.to_json
+
+      parsed = JSON.parse(json)
+      expect(parsed['ocr']['backend']).to eq 'tesseract'
+    end
+  end
+
+  describe '#get_field' do
+    it 'retrieves top-level field' do
+      config = described_class.new(use_cache: false)
+
+      expect(config.get_field('use_cache')).to be false
+    end
+
+    it 'retrieves nested field with dot notation' do
+      config = described_class.new(ocr: { backend: 'tesseract' })
+
+      expect(config.get_field('ocr.backend')).to eq 'tesseract'
+    end
+
+    it 'returns nil for non-existent field' do
+      config = described_class.new
+
+      expect(config.get_field('nonexistent')).to be_nil
+    end
+
+    it 'accepts symbol field names' do
+      config = described_class.new(use_cache: true)
+
+      expect(config.get_field(:use_cache)).to be true
+    end
+
+    it 'handles deeply nested fields' do
+      config = described_class.new(
+        chunking: { embedding: { model: { type: :preset, name: 'fast' } } }
+      )
+
+      expect(config.get_field('chunking.embedding.model')).to be_a Hash
+    end
+  end
+
+  describe '#merge' do
+    it 'merges two configs' do
+      base = described_class.new(use_cache: true, force_ocr: false)
+      override = described_class.new(force_ocr: true)
+      merged = base.merge(override)
+
+      expect(merged.use_cache).to be true
+      expect(merged.force_ocr).to be true
+    end
+
+    it 'returns new config without modifying original' do
+      base = described_class.new(use_cache: true)
+      override = described_class.new(use_cache: false)
+      merged = base.merge(override)
+
+      expect(base.use_cache).to be true
+      expect(merged.use_cache).to be false
+    end
+
+    it 'merges nested configs' do
+      base = described_class.new(ocr: { backend: 'tesseract' })
+      override = described_class.new(ocr: { language: 'fra' })
+      merged = base.merge(override)
+
+      expect(merged.ocr.backend).to eq 'tesseract'
+    end
+
+    it 'accepts hash as merge argument' do
+      base = described_class.new(use_cache: true)
+      merged = base.merge({ use_cache: false })
+
+      expect(merged.use_cache).to be false
+    end
+  end
+
+  describe '#merge!' do
+    it 'mutates config in-place' do
+      config = described_class.new(use_cache: true, force_ocr: false)
+      override = described_class.new(force_ocr: true)
+      result = config.merge!(override)
+
+      expect(config.force_ocr).to be true
+      expect(result).to be config
+    end
+
+    it 'returns self' do
+      config = described_class.new
+      override = described_class.new
+
+      expect(config.merge!(override)).to be config
+    end
+
+    it 'accepts hash argument' do
+      config = described_class.new(use_cache: true)
+      config[:use_cache] = false
+      config[:force_ocr] = true
+
+      expect(config.use_cache).to be false
+      expect(config.force_ocr).to be true
+    end
+  end
+
+  describe 'validation' do
+    it 'rejects invalid ocr type' do
+      expect do
+        described_class.new(ocr: 'invalid')
+      end.to raise_error ArgumentError, /Expected.*OCR/
+    end
+
+    it 'rejects invalid chunking type' do
+      expect do
+        described_class.new(chunking: 123)
+      end.to raise_error ArgumentError, /Expected.*Chunking/
+    end
+
+    it 'accepts valid nested instances' do
+      expect do
+        described_class.new(
+          ocr: Kreuzberg::Config::OCR.new,
+          chunking: Kreuzberg::Config::Chunking.new
+        )
+      end.not_to raise_error
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      config = described_class.new(
+        use_cache: false,
+        enable_quality_processing: true,
+        force_ocr: true,
+        ocr: { backend: 'tesseract' },
+        chunking: { max_chars: 500 },
+        language_detection: { enabled: true },
+        pdf_options: { extract_images: true },
+        image_extraction: { target_dpi: 600 },
+        postprocessor: { enabled: true },
+        token_reduction: { mode: 'light' },
+        keywords: { algorithm: 'yake' },
+        pages: { extract_pages: true },
+        max_concurrent_extractions: 4
+      )
+
+      expect(config.use_cache).to be false
+      expect(config.enable_quality_processing).to be true
+      expect(config.force_ocr).to be true
+      expect(config.ocr).to be_a Kreuzberg::Config::OCR
+      expect(config.max_concurrent_extractions).to eq 4
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs with same values' do
+      config1 = described_class.new(use_cache: true, force_ocr: false)
+      config2 = described_class.new(use_cache: true, force_ocr: false)
+
+      expect(config1.use_cache).to eq config2.use_cache
+      expect(config1.force_ocr).to eq config2.force_ocr
+    end
+
+    it 'detects differences' do
+      config1 = described_class.new(use_cache: true)
+      config2 = described_class.new(use_cache: false)
+
+      expect(config1.use_cache).not_to eq config2.use_cache
+    end
+  end
+
+  describe '.from_file' do
+    it 'loads from TOML file' do
+      config_path = File.join(__dir__, '../../fixtures/config.toml')
+      config = described_class.from_file(config_path)
+
+      expect(config).to be_a described_class
+      expect(config.use_cache).to be false
+    end
+
+    it 'loads from YAML file' do
+      config_path = File.join(__dir__, '../../fixtures/config.yaml')
+      config = described_class.from_file(config_path)
+
+      expect(config).to be_a described_class
+      expect(config.use_cache).to be false
+    end
+
+    it 'raises error for non-existent file' do
+      expect do
+        described_class.from_file('/nonexistent/path/config.toml')
+      end.to raise_error Kreuzberg::Errors::ValidationError
+    end
+  end
+
+  describe '.discover' do
+    it 'returns nil when no config file found' do
+      # This test may vary by environment
+      # Documenting the behavior
+      config = described_class.discover
+      # Should either return a config or nil
+      expect(config.nil? || config.is_a?(described_class)).to be true
+    end
+  end
+
+  describe 'boolean conversion' do
+    it 'converts truthy use_cache to true' do
+      config = described_class.new(use_cache: 1)
+
+      expect(config.use_cache).to be true
+    end
+
+    it 'converts false use_cache to false' do
+      config = described_class.new(use_cache: false)
+
+      expect(config.use_cache).to be false
+    end
+
+    it 'converts truthy enable_quality_processing to true' do
+      config = described_class.new(enable_quality_processing: 'yes')
+
+      expect(config.enable_quality_processing).to be true
+    end
+
+    it 'converts false enable_quality_processing to false' do
+      config = described_class.new(enable_quality_processing: false)
+
+      expect(config.enable_quality_processing).to be false
+    end
+
+    it 'converts truthy force_ocr to true' do
+      config = described_class.new(force_ocr: [1])
+
+      expect(config.force_ocr).to be true
+    end
+
+    it 'converts false force_ocr to false' do
+      config = described_class.new(force_ocr: false)
+
+      expect(config.force_ocr).to be false
+    end
+  end
+
+  describe 'complex nested configurations' do
+    it 'handles deeply nested configs' do
+      config = described_class.new(
+        chunking: {
+          max_chars: 750,
+          embedding: {
+            model: { type: :preset, name: 'balanced' },
+            batch_size: 64
+          }
+        }
+      )
+
+      expect(config.chunking.embedding).to be_a Kreuzberg::Config::Embedding
+      expect(config.chunking.embedding.batch_size).to eq 64
+    end
+
+    it 'handles PDF with font and hierarchy configs' do
+      config = described_class.new(
+        pdf_options: {
+          extract_images: true,
+          font_config: { enabled: true, custom_font_dirs: ['/fonts'] },
+          hierarchy: { k_clusters: 8 }
+        }
+      )
+
+      expect(config.pdf_options.font_config).to be_a Kreuzberg::Config::FontConfig
+      expect(config.pdf_options.hierarchy).to be_a Kreuzberg::Config::Hierarchy
+    end
+
+    it 'handles complete extraction config' do
+      config = described_class.new(
+        use_cache: false,
+        force_ocr: true,
+        ocr: { backend: 'tesseract', language: 'deu' },
+        chunking: { max_chars: 500, preset: 'fast' },
+        language_detection: { enabled: true, min_confidence: 0.9 },
+        pdf_options: { extract_images: true, passwords: ['secret'] },
+        image_extraction: { target_dpi: 600 },
+        postprocessor: { enabled: true, enabled_processors: %w[quality] },
+        token_reduction: { mode: 'light' },
+        keywords: { algorithm: 'yake', max_keywords: 10 },
+        pages: { extract_pages: true }
+      )
+
+      expect(config.use_cache).to be false
+      expect(config.force_ocr).to be true
+      expect(config.ocr.language).to eq 'deu'
+      expect(config.chunking.max_chars).to eq 500
+      expect(config.language_detection.enabled).to be true
+      expect(config.pdf_options.extract_images).to be true
+      expect(config.image_extraction.target_dpi).to eq 600
+      expect(config.postprocessor.enabled).to be true
+      expect(config.token_reduction.mode).to eq 'light'
+      expect(config.keywords.max_keywords).to eq 10
+      expect(config.pages.extract_pages).to be true
+    end
+  end
+
+  describe 'ExtractionConfig alias' do
+    it 'exists as module constant' do
+      expect(Kreuzberg.const_defined?(:ExtractionConfig)).to be true
+    end
+
+    it 'can be instantiated through alias' do
+      config = Kreuzberg::ExtractionConfig.new(use_cache: false)
+
+      expect(config).to be_a described_class
+      expect(config.use_cache).to be false
+    end
+  end
+end

data/spec/unit/config/font_config_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::FontConfig do
+  describe '#initialize' do
+    it 'creates config with default values' do
+      config = described_class.new
+
+      expect(config.enabled).to be true
+      expect(config.custom_font_dirs).to be_nil
+    end
+
+    it 'creates config with enabled false' do
+      config = described_class.new(enabled: false)
+
+      expect(config.enabled).to be false
+    end
+
+    it 'creates config with custom_font_dirs' do
+      dirs = ['/usr/share/fonts', '/home/user/.fonts']
+      config = described_class.new(custom_font_dirs: dirs)
+
+      expect(config.custom_font_dirs).to eq dirs
+    end
+
+    it 'accepts single font directory as string' do
+      config = described_class.new(custom_font_dirs: '/usr/share/fonts')
+
+      expect(config.custom_font_dirs).to eq '/usr/share/fonts'
+    end
+
+    it 'accepts multiple directories as array' do
+      dirs = ['/fonts1', '/fonts2', '/fonts3']
+      config = described_class.new(custom_font_dirs: dirs)
+
+      expect(config.custom_font_dirs).to eq dirs
+    end
+
+    it 'converts enabled to boolean' do
+      config = described_class.new(enabled: 1)
+
+      expect(config.enabled).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash with default values' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:enabled]).to be true
+    end
+
+    it 'includes custom_font_dirs when present' do
+      dirs = ['/fonts']
+      config = described_class.new(custom_font_dirs: dirs)
+      hash = config.to_h
+
+      expect(hash[:custom_font_dirs]).to eq dirs
+    end
+
+    it 'compacts nil values from hash' do
+      config = described_class.new(enabled: true)
+      hash = config.to_h
+
+      expect(hash.key?(:custom_font_dirs)).to be false
+    end
+
+    it 'includes both keys when both are present' do
+      config = described_class.new(
+        enabled: true,
+        custom_font_dirs: ['/fonts']
+      )
+      hash = config.to_h
+
+      expect(hash.keys).to contain_exactly(:enabled, :custom_font_dirs)
+    end
+  end
+
+  describe 'validation' do
+    it 'accepts enabled true' do
+      expect do
+        described_class.new(enabled: true)
+      end.not_to raise_error
+    end
+
+    it 'accepts enabled false' do
+      expect do
+        described_class.new(enabled: false)
+      end.not_to raise_error
+    end
+
+    it 'accepts custom_font_dirs as string' do
+      expect do
+        described_class.new(custom_font_dirs: '/fonts')
+      end.not_to raise_error
+    end
+
+    it 'accepts custom_font_dirs as array' do
+      expect do
+        described_class.new(custom_font_dirs: ['/fonts1', '/fonts2'])
+      end.not_to raise_error
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      dirs = ['/fonts']
+      config = described_class.new(
+        enabled: false,
+        custom_font_dirs: dirs
+      )
+
+      expect(config.enabled).to be false
+      expect(config.custom_font_dirs).to eq dirs
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs by value' do
+      config1 = described_class.new(
+        enabled: true,
+        custom_font_dirs: ['/fonts']
+      )
+      config2 = described_class.new(
+        enabled: true,
+        custom_font_dirs: ['/fonts']
+      )
+
+      expect(config1.enabled).to eq config2.enabled
+      expect(config1.custom_font_dirs).to eq config2.custom_font_dirs
+    end
+
+    it 'detects differences in enabled' do
+      config1 = described_class.new(enabled: true)
+      config2 = described_class.new(enabled: false)
+
+      expect(config1.enabled).not_to eq config2.enabled
+    end
+
+    it 'detects differences in custom_font_dirs' do
+      config1 = described_class.new(custom_font_dirs: ['/fonts1'])
+      config2 = described_class.new(custom_font_dirs: ['/fonts2'])
+
+      expect(config1.custom_font_dirs).not_to eq config2.custom_font_dirs
+    end
+  end
+
+  describe 'nested config integration' do
+    it 'can be nested in PDF config' do
+      font_config = described_class.new(enabled: true, custom_font_dirs: ['/fonts'])
+      pdf = Kreuzberg::Config::PDF.new(font_config: font_config)
+
+      expect(pdf.font_config).to be_a described_class
+      expect(pdf.font_config.enabled).to be true
+      expect(pdf.font_config.custom_font_dirs).to eq ['/fonts']
+    end
+
+    it 'accepts hash in PDF config' do
+      pdf = Kreuzberg::Config::PDF.new(
+        font_config: { enabled: true, custom_font_dirs: ['/fonts'] }
+      )
+
+      expect(pdf.font_config).to be_a described_class
+      expect(pdf.font_config.enabled).to be true
+      expect(pdf.font_config.custom_font_dirs).to eq ['/fonts']
+    end
+
+    it 'can be nested in Extraction config via PDF' do
+      extraction = Kreuzberg::Config::Extraction.new(
+        pdf_options: { font_config: { enabled: true } }
+      )
+
+      expect(extraction.pdf_options.font_config).to be_a described_class
+      expect(extraction.pdf_options.font_config.enabled).to be true
+    end
+  end
+
+  describe 'symbol vs string key handling' do
+    it 'converts symbol enabled to boolean' do
+      config = described_class.new(enabled: true)
+
+      expect(config.enabled).to be true
+    end
+
+    it 'preserves custom_font_dirs as array' do
+      dirs = ['/fonts1', '/fonts2']
+      config = described_class.new(custom_font_dirs: dirs)
+
+      expect(config.custom_font_dirs).to eq dirs
+    end
+  end
+
+  describe 'boolean conversion' do
+    it 'converts truthy enabled to true' do
+      config = described_class.new(enabled: 1)
+
+      expect(config.enabled).to be true
+    end
+
+    it 'converts false enabled to false' do
+      config = described_class.new(enabled: false)
+
+      expect(config.enabled).to be false
+    end
+
+    it 'converts string yes to true' do
+      config = described_class.new(enabled: 'yes')
+
+      expect(config.enabled).to be true
+    end
+
+    it 'converts nil to false' do
+      config = described_class.new(enabled: nil)
+
+      expect(config.enabled).to be false
+    end
+  end
+
+  describe 'font directory handling' do
+    it 'stores single directory path as string' do
+      config = described_class.new(custom_font_dirs: '/usr/share/fonts')
+
+      expect(config.custom_font_dirs).to eq '/usr/share/fonts'
+    end
+
+    it 'stores multiple directories as array' do
+      dirs = ['/fonts1', '/fonts2', '/fonts3']
+      config = described_class.new(custom_font_dirs: dirs)
+
+      expect(config.custom_font_dirs).to eq dirs
+      expect(config.custom_font_dirs).to be_a Array
+    end
+
+    it 'preserves exact directory paths' do
+      dir = '/home/user/.local/share/fonts'
+      config = described_class.new(custom_font_dirs: dir)
+
+      expect(config.custom_font_dirs).to eq dir
+    end
+
+    it 'preserves array of directory paths' do
+      dirs = ['/usr/share/fonts', '/home/user/.fonts', '~/.local/share/fonts']
+      config = described_class.new(custom_font_dirs: dirs)
+
+      expect(config.custom_font_dirs).to eq dirs
+    end
+  end
+
+  describe 'mutability' do
+    it 'allows modification of enabled' do
+      config = described_class.new(enabled: true)
+      config.enabled = false
+
+      expect(config.enabled).to be false
+    end
+
+    it 'allows modification of custom_font_dirs' do
+      config = described_class.new(custom_font_dirs: ['/fonts1'])
+      config.custom_font_dirs = ['/fonts2']
+
+      expect(config.custom_font_dirs).to eq ['/fonts2']
+    end
+  end
+
+  describe 'default behavior' do
+    it 'defaults to enabled' do
+      config = described_class.new
+
+      expect(config.enabled).to be true
+    end
+
+    it 'defaults to no custom font directories' do
+      config = described_class.new
+
+      expect(config.custom_font_dirs).to be_nil
+    end
+
+    it 'allows disabling font support' do
+      config = described_class.new(enabled: false)
+
+      expect(config.enabled).to be false
+    end
+  end
+end