kreuzberg 4.0.0.rc2 → 4.0.0

data/spec/unit/config/image_extraction_config_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::Config::ImageExtraction do
+  describe '#initialize' do
+    it 'creates config with default values' do
+      config = described_class.new
+
+      expect(config.extract_images).to be true
+      expect(config.target_dpi).to eq 300
+      expect(config.max_image_dimension).to eq 2000
+      expect(config.auto_adjust_dpi).to be true
+      expect(config.min_dpi).to eq 150
+      expect(config.max_dpi).to eq 600
+    end
+
+    it 'creates config with custom values' do
+      config = described_class.new(
+        extract_images: false,
+        target_dpi: 600,
+        max_image_dimension: 4000,
+        auto_adjust_dpi: false,
+        min_dpi: 100,
+        max_dpi: 1200
+      )
+
+      expect(config.extract_images).to be false
+      expect(config.target_dpi).to eq 600
+      expect(config.max_image_dimension).to eq 4000
+      expect(config.auto_adjust_dpi).to be false
+      expect(config.min_dpi).to eq 100
+      expect(config.max_dpi).to eq 1200
+    end
+
+    it 'converts values to integers' do
+      config = described_class.new(
+        target_dpi: '300',
+        max_image_dimension: '2000',
+        min_dpi: '150',
+        max_dpi: '600'
+      )
+
+      expect(config.target_dpi).to eq 300
+      expect(config.max_image_dimension).to eq 2000
+      expect(config.min_dpi).to eq 150
+      expect(config.max_dpi).to eq 600
+      expect(config.target_dpi).to be_a Integer
+    end
+
+    it 'converts boolean values correctly' do
+      config = described_class.new(
+        extract_images: true,
+        auto_adjust_dpi: false
+      )
+
+      expect(config.extract_images).to be true
+      expect(config.auto_adjust_dpi).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'serializes to hash with all values' do
+      config = described_class.new(
+        target_dpi: 300,
+        max_image_dimension: 2000
+      )
+      hash = config.to_h
+
+      expect(hash).to be_a Hash
+      expect(hash[:extract_images]).to be true
+      expect(hash[:target_dpi]).to eq 300
+      expect(hash[:max_image_dimension]).to eq 2000
+      expect(hash[:auto_adjust_dpi]).to be true
+      expect(hash[:min_dpi]).to eq 150
+      expect(hash[:max_dpi]).to eq 600
+    end
+
+    it 'always includes all keys in hash' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash.keys).to contain_exactly(
+        :extract_images,
+        :target_dpi,
+        :max_image_dimension,
+        :auto_adjust_dpi,
+        :min_dpi,
+        :max_dpi
+      )
+    end
+  end
+
+  describe 'validation' do
+    it 'accepts valid DPI values' do
+      expect do
+        described_class.new(target_dpi: 300, min_dpi: 150, max_dpi: 600)
+      end.not_to raise_error
+    end
+
+    it 'accepts valid image dimensions' do
+      expect do
+        described_class.new(max_image_dimension: 4000)
+      end.not_to raise_error
+    end
+
+    it 'converts float DPI to integer' do
+      config = described_class.new(target_dpi: 300.5)
+
+      expect(config.target_dpi).to eq 300
+      expect(config.target_dpi).to be_a Integer
+    end
+  end
+
+  describe 'keyword arguments' do
+    it 'accepts all keyword arguments' do
+      config = described_class.new(
+        extract_images: true,
+        target_dpi: 600,
+        max_image_dimension: 3000,
+        auto_adjust_dpi: true,
+        min_dpi: 200,
+        max_dpi: 800
+      )
+
+      expect(config.extract_images).to be true
+      expect(config.target_dpi).to eq 600
+      expect(config.max_image_dimension).to eq 3000
+      expect(config.auto_adjust_dpi).to be true
+      expect(config.min_dpi).to eq 200
+      expect(config.max_dpi).to eq 800
+    end
+  end
+
+  describe 'equality' do
+    it 'compares configs by value' do
+      config1 = described_class.new(target_dpi: 300, max_image_dimension: 2000)
+      config2 = described_class.new(target_dpi: 300, max_image_dimension: 2000)
+
+      expect(config1.target_dpi).to eq config2.target_dpi
+      expect(config1.max_image_dimension).to eq config2.max_image_dimension
+    end
+
+    it 'detects differences in 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 extract_images' do
+      config1 = described_class.new(extract_images: true)
+      config2 = described_class.new(extract_images: false)
+
+      expect(config1.extract_images).not_to eq config2.extract_images
+    end
+  end
+
+  describe 'nested config integration' do
+    it 'can be nested in Extraction config' do
+      image_config = described_class.new(target_dpi: 600)
+      extraction = Kreuzberg::Config::Extraction.new(image_extraction: image_config)
+
+      expect(extraction.image_extraction).to be_a described_class
+      expect(extraction.image_extraction.target_dpi).to eq 600
+    end
+
+    it 'accepts hash in Extraction config' do
+      extraction = Kreuzberg::Config::Extraction.new(
+        image_extraction: { target_dpi: 600, extract_images: true }
+      )
+
+      expect(extraction.image_extraction).to be_a described_class
+      expect(extraction.image_extraction.target_dpi).to eq 600
+    end
+  end
+
+  describe 'DPI range' do
+    it 'allows realistic DPI values' do
+      config = described_class.new(min_dpi: 150, max_dpi: 1200)
+
+      expect(config.min_dpi).to eq 150
+      expect(config.max_dpi).to eq 1200
+    end
+
+    it 'maintains DPI relationships' do
+      config = described_class.new(
+        target_dpi: 300,
+        min_dpi: 100,
+        max_dpi: 600
+      )
+
+      expect(config.min_dpi).to be <= config.target_dpi
+      expect(config.target_dpi).to be <= config.max_dpi
+    end
+  end
+
+  describe 'image dimension constraints' do
+    it 'accepts large image dimensions' do
+      config = described_class.new(max_image_dimension: 10_000)
+
+      expect(config.max_image_dimension).to eq 10_000
+    end
+
+    it 'accepts small image dimensions' do
+      config = described_class.new(max_image_dimension: 100)
+
+      expect(config.max_image_dimension).to eq 100
+    end
+  end
+end

data/spec/unit/config/image_preprocessing_config_spec.rb

@@ -0,0 +1,249 @@
+# 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 Extraction config' do
+      preprocessing = described_class.new(target_dpi: 600, denoise: true)
+      extraction = Kreuzberg::Config::Extraction.new(image_preprocessing: preprocessing)
+
+      expect(extraction.image_preprocessing).to be_a described_class
+      expect(extraction.image_preprocessing.target_dpi).to eq 600
+      expect(extraction.image_preprocessing.denoise).to be true
+    end
+
+    it 'accepts hash in Extraction config' do
+      extraction = Kreuzberg::Config::Extraction.new(
+        image_preprocessing: { target_dpi: 600, binarization_method: 'sauvola' }
+      )
+
+      expect(extraction.image_preprocessing).to be_a described_class
+      expect(extraction.image_preprocessing.target_dpi).to eq 600
+      expect(extraction.image_preprocessing.binarization_method).to eq 'sauvola'
+    end
+
+    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