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

data/spec/unit/config/tesseract_config_spec.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kreuzberg::Config::Tesseract do
-  describe '#initialize' do
-    it 'creates config with no arguments' do
-      config = described_class.new
-
-      expect(config).to be_a described_class
-      expect(config.options).to eq({})
-    end
-
-    it 'creates config with custom options' do
-      config = described_class.new(dpi: 300, psm: 3)
-
-      expect(config.options[:dpi]).to eq 300
-      expect(config.options[:psm]).to eq 3
-    end
-
-    it 'converts string keys to symbols' do
-      config = described_class.new('oem' => 1, 'lang' => 'eng')
-
-      expect(config.options[:oem]).to eq 1
-      expect(config.options[:lang]).to eq 'eng'
-    end
-
-    it 'accepts preprocessing as hash' do
-      config = described_class.new(preprocessing: { target_dpi: 300 })
-
-      expect(config.options[:preprocessing]).to be_a Kreuzberg::Config::ImagePreprocessing
-    end
-
-    it 'accepts preprocessing as instance' do
-      preprocessing = Kreuzberg::Config::ImagePreprocessing.new(target_dpi: 600)
-      config = described_class.new(preprocessing: preprocessing)
-
-      expect(config.options[:preprocessing]).to be_a Kreuzberg::Config::ImagePreprocessing
-      expect(config.options[:preprocessing].target_dpi).to eq 600
-    end
-  end
-
-  describe '#to_h' do
-    it 'returns options as hash' do
-      config = described_class.new(dpi: 300, psm: 3)
-      hash = config.to_h
-
-      expect(hash).to be_a Hash
-      expect(hash[:dpi]).to eq 300
-      expect(hash[:psm]).to eq 3
-    end
-
-    it 'includes nested preprocessing in hash' do
-      config = described_class.new(
-        preprocessing: { target_dpi: 300, denoise: true }
-      )
-      hash = config.to_h
-
-      expect(hash[:preprocessing]).to be_a Kreuzberg::Config::ImagePreprocessing
-      # Access the config object's attributes
-      expect(hash[:preprocessing].target_dpi).to eq 300
-      expect(hash[:preprocessing].denoise).to be true
-    end
-
-    it 'returns duplicate hash not original' do
-      config = described_class.new(value: 'test')
-      hash1 = config.to_h
-      hash2 = config.to_h
-
-      expect(hash1).to eq hash2
-      expect(hash1).not_to be hash2
-    end
-  end
-
-  describe 'validation' do
-    it 'rejects invalid preprocessing type' do
-      expect do
-        described_class.new(preprocessing: 'invalid')
-      end.to raise_error ArgumentError, /preprocessing must be.*ImagePreprocessing.*Hash/
-    end
-
-    it 'accepts valid preprocessing hash' do
-      expect do
-        described_class.new(preprocessing: { target_dpi: 300 })
-      end.not_to raise_error
-    end
-
-    it 'accepts valid preprocessing instance' do
-      preprocessing = Kreuzberg::Config::ImagePreprocessing.new
-      expect do
-        described_class.new(preprocessing: preprocessing)
-      end.not_to raise_error
-    end
-  end
-
-  describe 'keyword arguments' do
-    it 'accepts arbitrary keyword arguments' do
-      config = described_class.new(
-        dpi: 300,
-        psm: 3,
-        oem: 1,
-        custom_option: 'value'
-      )
-
-      expect(config.options[:dpi]).to eq 300
-      expect(config.options[:psm]).to eq 3
-      expect(config.options[:oem]).to eq 1
-      expect(config.options[:custom_option]).to eq 'value'
-    end
-
-    it 'stores all options with symbol keys' do
-      config = described_class.new(foo: 'bar', baz: 42)
-
-      expect(config.options.keys).to all be_a Symbol
-      expect(config.options[:foo]).to eq 'bar'
-      expect(config.options[:baz]).to eq 42
-    end
-  end
-
-  describe 'equality' do
-    it 'compares configs by options value' do
-      config1 = described_class.new(dpi: 300, psm: 3)
-      config2 = described_class.new(dpi: 300, psm: 3)
-
-      expect(config1.options).to eq config2.options
-    end
-
-    it 'detects differences in options' do
-      config1 = described_class.new(dpi: 300)
-      config2 = described_class.new(dpi: 600)
-
-      expect(config1.options).not_to eq config2.options
-    end
-  end
-
-  describe 'nested config integration' do
-    it 'can be nested in OCR config' do
-      tesseract = described_class.new(dpi: 300, psm: 3)
-      ocr = Kreuzberg::Config::OCR.new(tesseract_config: tesseract)
-
-      expect(ocr.tesseract_config).to be_a described_class
-      expect(ocr.tesseract_config.options[:dpi]).to eq 300
-    end
-
-    it 'accepts preprocessing nested in tesseract' do
-      preprocessing_data = { target_dpi: 600, denoise: true }
-      tesseract = described_class.new(preprocessing: preprocessing_data)
-
-      expect(tesseract.options[:preprocessing]).to be_a Kreuzberg::Config::ImagePreprocessing
-      expect(tesseract.options[:preprocessing].denoise).to be true
-    end
-  end
-
-  describe 'symbol vs string key handling' do
-    it 'normalizes all keys to symbols' do
-      config = described_class.new(
-        'string_key' => 'value1',
-        symbol_key: 'value2'
-      )
-
-      expect(config.options.keys).to all be_a Symbol
-      expect(config.options[:string_key]).to eq 'value1'
-      expect(config.options[:symbol_key]).to eq 'value2'
-    end
-
-    it 'preserves string values while converting keys to symbols' do
-      config = described_class.new('test_key' => 'test_value')
-
-      expect(config.options[:test_key]).to eq 'test_value'
-      expect(config.options[:test_key]).to be_a String
-    end
-  end
-
-  describe 'immutability concerns' do
-    it 'stores options but does not freeze them by default' do
-      config = described_class.new(value: 'test')
-
-      # The config itself can be modified by re-assigning instance variables
-      # This is a design choice that allows for mutability
-      expect(config.options).to respond_to(:merge)
-    end
-  end
-end

data/spec/unit/config/token_reduction_config_spec.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kreuzberg::Config::TokenReduction do
-  describe '#initialize' do
-    it 'creates config with default values' do
-      config = described_class.new
-
-      expect(config.mode).to eq 'off'
-      expect(config.preserve_important_words).to be true
-    end
-
-    it 'creates config with custom mode' do
-      config = described_class.new(mode: 'light')
-
-      expect(config.mode).to eq 'light'
-      expect(config.preserve_important_words).to be true
-    end
-
-    it 'creates config with custom preserve setting' do
-      config = described_class.new(
-        mode: 'aggressive',
-        preserve_important_words: false
-      )
-
-      expect(config.mode).to eq 'aggressive'
-      expect(config.preserve_important_words).to be false
-    end
-
-    it 'converts mode symbol to string' do
-      config = described_class.new(mode: :moderate)
-
-      expect(config.mode).to eq 'moderate'
-      expect(config.mode).to be_a String
-    end
-
-    it 'converts preserve_important_words to boolean' do
-      config = described_class.new(preserve_important_words: 1)
-
-      expect(config.preserve_important_words).to be true
-    end
-  end
-
-  describe '#to_h' do
-    it 'serializes to hash with all values' do
-      config = described_class.new(
-        mode: 'light',
-        preserve_important_words: false
-      )
-      hash = config.to_h
-
-      expect(hash).to be_a Hash
-      expect(hash[:mode]).to eq 'light'
-      expect(hash[:preserve_important_words]).to be false
-    end
-
-    it 'always includes all keys in hash' do
-      config = described_class.new
-      hash = config.to_h
-
-      expect(hash.keys).to contain_exactly(:mode, :preserve_important_words)
-    end
-  end
-
-  describe 'validation' do
-    it 'accepts off mode' do
-      expect do
-        described_class.new(mode: 'off')
-      end.not_to raise_error
-    end
-
-    it 'accepts light mode' do
-      expect do
-        described_class.new(mode: 'light')
-      end.not_to raise_error
-    end
-
-    it 'accepts moderate mode' do
-      expect do
-        described_class.new(mode: 'moderate')
-      end.not_to raise_error
-    end
-
-    it 'accepts aggressive mode' do
-      expect do
-        described_class.new(mode: 'aggressive')
-      end.not_to raise_error
-    end
-
-    it 'accepts maximum mode' do
-      expect do
-        described_class.new(mode: 'maximum')
-      end.not_to raise_error
-    end
-
-    it 'rejects invalid mode' do
-      expect do
-        described_class.new(mode: 'invalid_mode')
-      end.to raise_error ArgumentError, /Invalid token reduction mode/
-    end
-
-    it 'lists valid modes in error message' do
-      expect do
-        described_class.new(mode: 'unknown')
-      end.to raise_error ArgumentError, /off.*light.*moderate.*aggressive.*maximum/
-    end
-  end
-
-  describe 'keyword arguments' do
-    it 'accepts all keyword arguments' do
-      config = described_class.new(
-        mode: 'maximum',
-        preserve_important_words: false
-      )
-
-      expect(config.mode).to eq 'maximum'
-      expect(config.preserve_important_words).to be false
-    end
-  end
-
-  describe 'equality' do
-    it 'compares configs by value' do
-      config1 = described_class.new(mode: 'light', preserve_important_words: true)
-      config2 = described_class.new(mode: 'light', preserve_important_words: true)
-
-      expect(config1.mode).to eq config2.mode
-      expect(config1.preserve_important_words).to eq config2.preserve_important_words
-    end
-
-    it 'detects differences in mode' do
-      config1 = described_class.new(mode: 'light')
-      config2 = described_class.new(mode: 'aggressive')
-
-      expect(config1.mode).not_to eq config2.mode
-    end
-
-    it 'detects differences in preserve_important_words' do
-      config1 = described_class.new(preserve_important_words: true)
-      config2 = described_class.new(preserve_important_words: false)
-
-      expect(config1.preserve_important_words).not_to eq config2.preserve_important_words
-    end
-  end
-
-  describe 'nested config integration' do
-    it 'can be nested in Extraction config' do
-      token_reduction = described_class.new(mode: 'light')
-      extraction = Kreuzberg::Config::Extraction.new(token_reduction: token_reduction)
-
-      expect(extraction.token_reduction).to be_a described_class
-      expect(extraction.token_reduction.mode).to eq 'light'
-    end
-
-    it 'accepts hash in Extraction config' do
-      extraction = Kreuzberg::Config::Extraction.new(
-        token_reduction: { mode: 'moderate', preserve_important_words: true }
-      )
-
-      expect(extraction.token_reduction).to be_a described_class
-      expect(extraction.token_reduction.mode).to eq 'moderate'
-      expect(extraction.token_reduction.preserve_important_words).to be true
-    end
-  end
-
-  describe 'symbol vs string key handling' do
-    it 'converts symbol mode to string' do
-      config = described_class.new(mode: :aggressive)
-
-      expect(config.mode).to eq 'aggressive'
-      expect(config.mode).to be_a String
-    end
-
-    it 'accepts string mode' do
-      config = described_class.new(mode: 'light')
-
-      expect(config.mode).to eq 'light'
-      expect(config.mode).to be_a String
-    end
-  end
-
-  describe 'boolean conversion' do
-    it 'converts truthy preserve_important_words to true' do
-      config = described_class.new(preserve_important_words: 1)
-
-      expect(config.preserve_important_words).to be true
-    end
-
-    it 'converts false preserve_important_words to false' do
-      config = described_class.new(preserve_important_words: false)
-
-      expect(config.preserve_important_words).to be false
-    end
-
-    it 'converts string yes to true' do
-      config = described_class.new(preserve_important_words: 'yes')
-
-      expect(config.preserve_important_words).to be true
-    end
-  end
-
-  describe 'reduction modes' do
-    it 'off mode disables reduction' do
-      config = described_class.new(mode: 'off')
-
-      expect(config.mode).to eq 'off'
-    end
-
-    it 'light mode provides light reduction' do
-      config = described_class.new(mode: 'light')
-
-      expect(config.mode).to eq 'light'
-    end
-
-    it 'moderate mode provides balanced reduction' do
-      config = described_class.new(mode: 'moderate')
-
-      expect(config.mode).to eq 'moderate'
-    end
-
-    it 'aggressive mode reduces more tokens' do
-      config = described_class.new(mode: 'aggressive')
-
-      expect(config.mode).to eq 'aggressive'
-    end
-
-    it 'maximum mode is most aggressive' do
-      config = described_class.new(mode: 'maximum')
-
-      expect(config.mode).to eq 'maximum'
-    end
-  end
-
-  describe 'default behavior' do
-    it 'defaults to off mode for safety' do
-      config = described_class.new
-
-      expect(config.mode).to eq 'off'
-    end
-
-    it 'defaults to preserving important words' do
-      config = described_class.new
-
-      expect(config.preserve_important_words).to be true
-    end
-
-    it 'can enable reduction with light mode' do
-      config = described_class.new(mode: 'light')
-
-      expect(config.mode).to eq 'light'
-    end
-  end
-end