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

data/spec/unit/config/image_extraction_config_spec.rb

@@ -1,209 +0,0 @@
-# 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

@@ -1,249 +0,0 @@
-# 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

@@ -1,229 +0,0 @@
-# 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