kreuzberg 4.3.5-aarch64-linux

data/spec/unit/config/image_preprocessing_config_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::ImagePreprocessing do
+  describe '#initialize' do
+    it 'creates config with default values' 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 'creates config with 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 'converts target_dpi to integer' do
+      config = described_class.new(target_dpi: '300')
+
+      expect(config.target_dpi).to eq 300
+      expect(config.target_dpi).to be_a Integer
+    end
+
+    it 'converts binarization_method to string' do
+      config = described_class.new(binarization_method: :niblack)
+
+      expect(config.binarization_method).to eq 'niblack'
+      expect(config.binarization_method).to be_a String
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash with all values' do
+      config = described_class.new(target_dpi: 300, denoise: true)
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:target_dpi]).to eq 300
+      expect(hash[:denoise]).to be true
+      expect(hash[:auto_rotate]).to be true
+      expect(hash[:binarization_method]).to eq 'otsu'
+    end
+
+    it 'always includes all keys in hash' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash.keys).to contain_exactly(
+        :target_dpi,
+        :auto_rotate,
+        :deskew,
+        :denoise,
+        :contrast_enhance,
+        :binarization_method,
+        :invert_colors
+      )
+    end
+  end
+
+  describe 'validation' do
+    it 'rejects invalid binarization method' do
+      expect do
+        described_class.new(binarization_method: 'invalid_method')
+      end.to raise_error ArgumentError, /Invalid binarization_method/
+    end
+
+    it 'accepts all valid binarization methods' do
+      valid_methods = %w[otsu sauvola niblack wolf bradley adaptive]
+
+      valid_methods.each do |method|
+        expect do
+          described_class.new(binarization_method: method)
+        end.not_to raise_error
+      end
+    end
+
+    it 'accepts binarization method as symbol' do
+      expect do
+        described_class.new(binarization_method: :sauvola)
+      end.not_to raise_error
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      config = described_class.new(
+        target_dpi: 600,
+        auto_rotate: true,
+        deskew: false,
+        denoise: true,
+        contrast_enhance: false,
+        binarization_method: 'bradley',
+        invert_colors: true
+      )
+
+      expect(config.target_dpi).to eq 600
+      expect(config.auto_rotate).to be true
+      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 'bradley'
+      expect(config.invert_colors).to be true
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs by value' do
+      config1 = described_class.new(
+        target_dpi: 300,
+        binarization_method: 'otsu',
+        denoise: true
+      )
+      config2 = described_class.new(
+        target_dpi: 300,
+        binarization_method: 'otsu',
+        denoise: true
+      )
+
+      expect(config1.target_dpi).to eq config2.target_dpi
+      expect(config1.binarization_method).to eq config2.binarization_method
+      expect(config1.denoise).to eq config2.denoise
+    end
+
+    it 'detects differences in target_dpi' do
+      config1 = described_class.new(target_dpi: 300)
+      config2 = described_class.new(target_dpi: 600)
+
+      expect(config1.target_dpi).not_to eq config2.target_dpi
+    end
+
+    it 'detects differences in binarization_method' do
+      config1 = described_class.new(binarization_method: 'otsu')
+      config2 = described_class.new(binarization_method: 'sauvola')
+
+      expect(config1.binarization_method).not_to eq config2.binarization_method
+    end
+  end
+
+  describe 'nested config integration' do
+    it 'can be nested in Tesseract config' do
+      preprocessing = described_class.new(denoise: true)
+      tesseract = Kreuzberg::Config::Tesseract.new(preprocessing: preprocessing)
+
+      expect(tesseract.options[:preprocessing]).to be_a described_class
+      expect(tesseract.options[:preprocessing].denoise).to be true
+    end
+  end
+
+  describe 'symbol vs string key handling' do
+    it 'converts symbol binarization method to string' do
+      config = described_class.new(binarization_method: :bradley)
+
+      expect(config.binarization_method).to eq 'bradley'
+      expect(config.binarization_method).to be_a String
+    end
+
+    it 'converts string target_dpi to integer' do
+      config = described_class.new(target_dpi: '600')
+
+      expect(config.target_dpi).to eq 600
+      expect(config.target_dpi).to be_a Integer
+    end
+  end
+
+  describe 'boolean conversion' do
+    it 'converts truthy values to boolean' do
+      config = described_class.new(
+        auto_rotate: 1,
+        deskew: 'yes',
+        denoise: true
+      )
+
+      expect(config.auto_rotate).to be true
+      expect(config.deskew).to be true
+      expect(config.denoise).to be true
+    end
+
+    it 'converts false values to boolean' do
+      config = described_class.new(
+        auto_rotate: false,
+        deskew: false,
+        denoise: false
+      )
+
+      expect(config.auto_rotate).to be false
+      expect(config.deskew).to be false
+      expect(config.denoise).to be false
+    end
+  end
+
+  describe 'DPI configuration' do
+    it 'accepts realistic DPI values' do
+      config = described_class.new(target_dpi: 300)
+
+      expect(config.target_dpi).to eq 300
+    end
+
+    it 'accepts high DPI values' do
+      config = described_class.new(target_dpi: 1200)
+
+      expect(config.target_dpi).to eq 1200
+    end
+
+    it 'accepts low DPI values' do
+      config = described_class.new(target_dpi: 72)
+
+      expect(config.target_dpi).to eq 72
+    end
+  end
+end

data/spec/unit/config/keyword_config_spec.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::Keywords do
+  describe '#initialize' do
+    it 'creates config with default values' do
+      config = described_class.new
+
+      expect(config.algorithm).to be_nil
+      expect(config.max_keywords).to be_nil
+      expect(config.min_score).to be_nil
+      expect(config.ngram_range).to be_nil
+      expect(config.language).to be_nil
+      expect(config.yake_params).to be_nil
+      expect(config.rake_params).to be_nil
+    end
+
+    it 'creates config with custom values' do
+      config = described_class.new(
+        algorithm: 'yake',
+        max_keywords: 10,
+        min_score: 0.5,
+        ngram_range: [1, 3],
+        language: 'en'
+      )
+
+      expect(config.algorithm).to eq 'yake'
+      expect(config.max_keywords).to eq 10
+      expect(config.min_score).to eq 0.5
+      expect(config.ngram_range).to eq [1, 3]
+      expect(config.language).to eq 'en'
+    end
+
+    it 'accepts yake_params as instance' do
+      yake_params = Kreuzberg::Config::KeywordYakeParams.new(window_size: 3)
+      config = described_class.new(yake_params: yake_params)
+
+      expect(config.yake_params).to be_a Kreuzberg::Config::KeywordYakeParams
+      expect(config.yake_params.window_size).to eq 3
+    end
+
+    it 'converts yake_params hash to instance' do
+      config = described_class.new(yake_params: { window_size: 2 })
+
+      expect(config.yake_params).to be_a Kreuzberg::Config::KeywordYakeParams
+      expect(config.yake_params.window_size).to eq 2
+    end
+
+    it 'accepts rake_params as instance' do
+      rake_params = Kreuzberg::Config::KeywordRakeParams.new(min_word_length: 3)
+      config = described_class.new(rake_params: rake_params)
+
+      expect(config.rake_params).to be_a Kreuzberg::Config::KeywordRakeParams
+    end
+
+    it 'converts rake_params hash to instance' do
+      config = described_class.new(rake_params: { min_word_length: 2 })
+
+      expect(config.rake_params).to be_a Kreuzberg::Config::KeywordRakeParams
+      expect(config.rake_params.min_word_length).to eq 2
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash' do
+      config = described_class.new(algorithm: 'yake', max_keywords: 10)
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:algorithm]).to eq 'yake'
+      expect(hash[:max_keywords]).to eq 10
+    end
+
+    it 'includes nested params in hash' do
+      config = described_class.new(
+        algorithm: 'yake',
+        yake_params: { window_size: 3 }
+      )
+      hash = config.to_h
+
+      expect(hash[:yake_params]).to be_a Hash
+      expect(hash[:yake_params][:window_size]).to eq 3
+    end
+
+    it 'compacts nil values from hash' do
+      config = described_class.new(algorithm: 'rake')
+      hash = config.to_h
+
+      expect(hash.key?(:max_keywords)).to be false
+      expect(hash.key?(:yake_params)).to be false
+    end
+  end
+
+  describe 'validation' do
+    it 'accepts valid algorithm names' do
+      expect do
+        described_class.new(algorithm: 'yake')
+      end.not_to raise_error
+    end
+
+    it 'accepts valid max_keywords' do
+      expect do
+        described_class.new(max_keywords: 20)
+      end.not_to raise_error
+    end
+
+    it 'raises error for invalid yake_params type' do
+      expect do
+        described_class.new(yake_params: 'invalid')
+      end.to raise_error ArgumentError, /Expected.*KeywordYakeParams.*Hash.*nil/
+    end
+
+    it 'raises error for invalid rake_params type' do
+      expect do
+        described_class.new(rake_params: 'invalid')
+      end.to raise_error ArgumentError, /Expected.*KeywordRakeParams.*Hash.*nil/
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      config = described_class.new(
+        algorithm: 'yake',
+        max_keywords: 15,
+        min_score: 0.7,
+        ngram_range: [1, 2],
+        language: 'fr',
+        yake_params: { window_size: 3 }
+      )
+
+      expect(config.algorithm).to eq 'yake'
+      expect(config.max_keywords).to eq 15
+      expect(config.min_score).to eq 0.7
+      expect(config.ngram_range).to eq [1, 2]
+      expect(config.language).to eq 'fr'
+      expect(config.yake_params).to be_a Kreuzberg::Config::KeywordYakeParams
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs by value' do
+      config1 = described_class.new(algorithm: 'yake', max_keywords: 10)
+      config2 = described_class.new(algorithm: 'yake', max_keywords: 10)
+
+      expect(config1.algorithm).to eq config2.algorithm
+      expect(config1.max_keywords).to eq config2.max_keywords
+    end
+
+    it 'detects differences in algorithm' do
+      config1 = described_class.new(algorithm: 'yake')
+      config2 = described_class.new(algorithm: 'rake')
+
+      expect(config1.algorithm).not_to eq config2.algorithm
+    end
+
+    it 'detects differences in max_keywords' do
+      config1 = described_class.new(max_keywords: 10)
+      config2 = described_class.new(max_keywords: 20)
+
+      expect(config1.max_keywords).not_to eq config2.max_keywords
+    end
+  end
+
+  describe 'nested config integration' do
+    it 'can be nested in Extraction config' do
+      keywords = described_class.new(algorithm: 'yake', max_keywords: 15)
+      extraction = Kreuzberg::Config::Extraction.new(keywords: keywords)
+
+      expect(extraction.keywords).to be_a described_class
+      expect(extraction.keywords.algorithm).to eq 'yake'
+      expect(extraction.keywords.max_keywords).to eq 15
+    end
+
+    it 'accepts hash in Extraction config' do
+      extraction = Kreuzberg::Config::Extraction.new(
+        keywords: { algorithm: 'rake', max_keywords: 10 }
+      )
+
+      expect(extraction.keywords).to be_a described_class
+      expect(extraction.keywords.algorithm).to eq 'rake'
+      expect(extraction.keywords.max_keywords).to eq 10
+    end
+  end
+
+  describe 'symbol vs string key handling' do
+    it 'converts symbol algorithm to string' do
+      config = described_class.new(algorithm: :yake)
+
+      expect(config.algorithm).to eq 'yake'
+      expect(config.algorithm).to be_a String
+    end
+
+    it 'converts symbol language to string' do
+      config = described_class.new(language: :eng)
+
+      expect(config.language).to eq 'eng'
+      expect(config.language).to be_a String
+    end
+
+    it 'converts ngram_range values to integers' do
+      config = described_class.new(ngram_range: %w[1 3])
+
+      expect(config.ngram_range).to eq [1, 3]
+      expect(config.ngram_range.all?(Integer)).to be true
+    end
+  end
+
+  describe 'parameter conversions' do
+    it 'converts max_keywords to integer' do
+      config = described_class.new(max_keywords: '20')
+
+      expect(config.max_keywords).to eq 20
+      expect(config.max_keywords).to be_a Integer
+    end
+
+    it 'converts min_score to float' do
+      config = described_class.new(min_score: '0.75')
+
+      expect(config.min_score).to eq 0.75
+      expect(config.min_score).to be_a Float
+    end
+
+    it 'converts ngram_range to array of integers' do
+      config = described_class.new(ngram_range: [1, 2])
+
+      expect(config.ngram_range).to eq [1, 2]
+      expect(config.ngram_range.all?(Integer)).to be true
+    end
+  end
+end

data/spec/unit/config/language_detection_config_spec.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::LanguageDetection do
+  describe '#initialize' do
+    it 'creates config with default values' do
+      config = described_class.new
+
+      expect(config.enabled).to be false
+      expect(config.min_confidence).to eq 0.5
+      expect(config.detect_multiple).to be false
+    end
+
+    it 'creates config with custom values' do
+      config = described_class.new(
+        enabled: true,
+        min_confidence: 0.9,
+        detect_multiple: true
+      )
+
+      expect(config.enabled).to be true
+      expect(config.min_confidence).to eq 0.9
+      expect(config.detect_multiple).to be true
+    end
+
+    it 'converts enabled to boolean' do
+      config = described_class.new(enabled: 1)
+
+      expect(config.enabled).to be true
+      expect(config.enabled).to be_a TrueClass
+    end
+
+    it 'converts min_confidence to float' do
+      config = described_class.new(min_confidence: '0.75')
+
+      expect(config.min_confidence).to eq 0.75
+      expect(config.min_confidence).to be_a Float
+    end
+
+    it 'converts detect_multiple to boolean' do
+      config = described_class.new(detect_multiple: 'yes')
+
+      expect(config.detect_multiple).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash with all values' do
+      config = described_class.new(
+        enabled: true,
+        min_confidence: 0.8,
+        detect_multiple: true
+      )
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:enabled]).to be true
+      expect(hash[:min_confidence]).to eq 0.8
+      expect(hash[:detect_multiple]).to be true
+    end
+
+    it 'always includes all keys in hash' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash.keys).to contain_exactly(
+        :enabled,
+        :min_confidence,
+        :detect_multiple
+      )
+    end
+  end
+
+  describe 'validation' do
+    it 'accepts confidence value of 0.5' do
+      expect do
+        described_class.new(min_confidence: 0.5)
+      end.not_to raise_error
+    end
+
+    it 'accepts confidence value of 0.0' do
+      expect do
+        described_class.new(min_confidence: 0.0)
+      end.not_to raise_error
+    end
+
+    it 'accepts confidence value of 1.0' do
+      expect do
+        described_class.new(min_confidence: 1.0)
+      end.not_to raise_error
+    end
+
+    it 'accepts boolean enabled' do
+      expect do
+        described_class.new(enabled: true)
+      end.not_to raise_error
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      config = described_class.new(
+        enabled: true,
+        min_confidence: 0.85,
+        detect_multiple: true
+      )
+
+      expect(config.enabled).to be true
+      expect(config.min_confidence).to eq 0.85
+      expect(config.detect_multiple).to be true
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs by value' do
+      config1 = described_class.new(
+        enabled: true,
+        min_confidence: 0.8
+      )
+      config2 = described_class.new(
+        enabled: true,
+        min_confidence: 0.8
+      )
+
+      expect(config1.enabled).to eq config2.enabled
+      expect(config1.min_confidence).to eq config2.min_confidence
+    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 min_confidence' do
+      config1 = described_class.new(min_confidence: 0.5)
+      config2 = described_class.new(min_confidence: 0.9)
+
+      expect(config1.min_confidence).not_to eq config2.min_confidence
+    end
+
+    it 'detects differences in detect_multiple' do
+      config1 = described_class.new(detect_multiple: true)
+      config2 = described_class.new(detect_multiple: false)
+
+      expect(config1.detect_multiple).not_to eq config2.detect_multiple
+    end
+  end
+
+  describe 'nested config integration' do
+    it 'can be nested in Extraction config' do
+      lang_detect = described_class.new(enabled: true, min_confidence: 0.9)
+      extraction = Kreuzberg::Config::Extraction.new(language_detection: lang_detect)
+
+      expect(extraction.language_detection).to be_a described_class
+      expect(extraction.language_detection.enabled).to be true
+      expect(extraction.language_detection.min_confidence).to eq 0.9
+    end
+
+    it 'accepts hash in Extraction config' do
+      extraction = Kreuzberg::Config::Extraction.new(
+        language_detection: { enabled: true, min_confidence: 0.75 }
+      )
+
+      expect(extraction.language_detection).to be_a described_class
+      expect(extraction.language_detection.enabled).to be true
+      expect(extraction.language_detection.min_confidence).to eq 0.75
+    end
+  end
+
+  describe 'symbol vs string key handling' do
+    it 'accepts symbol and string enabled values' do
+      config = described_class.new(enabled: true)
+
+      expect(config.enabled).to be true
+    end
+
+    it 'converts min_confidence string to float' do
+      config = described_class.new(min_confidence: '0.95')
+
+      expect(config.min_confidence).to eq 0.95
+      expect(config.min_confidence).to be_a Float
+    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 truthy detect_multiple to true' do
+      config = described_class.new(detect_multiple: 'yes')
+
+      expect(config.detect_multiple).to be true
+    end
+
+    it 'converts false detect_multiple to false' do
+      config = described_class.new(detect_multiple: false)
+
+      expect(config.detect_multiple).to be false
+    end
+  end
+
+  describe 'confidence range' do
+    it 'accepts minimum confidence value' do
+      config = described_class.new(min_confidence: 0.0)
+
+      expect(config.min_confidence).to eq 0.0
+    end
+
+    it 'accepts maximum confidence value' do
+      config = described_class.new(min_confidence: 1.0)
+
+      expect(config.min_confidence).to eq 1.0
+    end
+
+    it 'accepts mid-range confidence value' do
+      config = described_class.new(min_confidence: 0.6)
+
+      expect(config.min_confidence).to eq 0.6
+    end
+
+    it 'preserves high precision confidence values' do
+      config = described_class.new(min_confidence: 0.123456)
+
+      expect(config.min_confidence).to be_within(0.00001).of(0.123456)
+    end
+  end
+
+  describe 'multiple language detection' do
+    it 'allows enabling multiple language detection' do
+      config = described_class.new(detect_multiple: true)
+
+      expect(config.detect_multiple).to be true
+    end
+
+    it 'defaults to single language detection' do
+      config = described_class.new
+
+      expect(config.detect_multiple).to be false
+    end
+
+    it 'can be disabled when enabled is true' do
+      config = described_class.new(enabled: true, detect_multiple: false)
+
+      expect(config.enabled).to be true
+      expect(config.detect_multiple).to be false
+    end
+  end
+end