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

data/spec/unit/config/chunking_config_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kreuzberg::Config::Chunking do
-  describe '#initialize' do
-    it 'creates config with default values' do
-      config = described_class.new
-
-      expect(config.max_chars).to eq 1000
-      expect(config.max_overlap).to eq 200
-      expect(config.preset).to be_nil
-      expect(config.embedding).to be_nil
-      expect(config.enabled).to be true
-    end
-
-    it 'creates config with custom values' do
-      config = described_class.new(
-        max_chars: 500,
-        max_overlap: 100,
-        preset: 'fast'
-      )
-
-      expect(config.max_chars).to eq 500
-      expect(config.max_overlap).to eq 100
-      expect(config.preset).to eq 'fast'
-    end
-
-    it 'accepts chunk_size alias for max_chars' do
-      config = described_class.new(chunk_size: 750)
-
-      expect(config.max_chars).to eq 750
-    end
-
-    it 'accepts chunk_overlap alias for max_overlap' do
-      config = described_class.new(chunk_overlap: 150)
-
-      expect(config.max_overlap).to eq 150
-    end
-
-    it 'uses max_chars when both chunk_size and max_chars provided' do
-      config = described_class.new(chunk_size: 500, max_chars: 1000)
-
-      expect(config.max_chars).to eq 500
-    end
-
-    it 'accepts embedding as instance' do
-      embedding = Kreuzberg::Config::Embedding.new(model: { type: :preset, name: 'fast' })
-      config = described_class.new(embedding: embedding)
-
-      expect(config.embedding).to be_a Kreuzberg::Config::Embedding
-    end
-
-    it 'converts embedding hash to instance' do
-      config = described_class.new(embedding: { model: { type: :preset, name: 'balanced' } })
-
-      expect(config.embedding).to be_a Kreuzberg::Config::Embedding
-    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[:max_chars]).to eq 1000
-      expect(hash[:max_overlap]).to eq 200
-      expect(hash[:enabled]).to be true
-    end
-
-    it 'includes embedding in hash when present' do
-      config = described_class.new(embedding: { model: { type: :preset, name: 'fast' } })
-      hash = config.to_h
-
-      expect(hash[:embedding]).to be_a Hash
-    end
-
-    it 'compacts nil values from hash' do
-      config = described_class.new
-      hash = config.to_h
-
-      expect(hash.key?(:preset)).to be false
-      expect(hash.key?(:embedding)).to be false
-    end
-  end
-
-  describe 'validation' do
-    it 'rejects negative max_chars' do
-      expect do
-        described_class.new(max_chars: -100)
-      end.to raise_error ArgumentError, /max_chars must be a positive integer/
-    end
-
-    it 'rejects negative max_overlap' do
-      expect do
-        described_class.new(max_overlap: -50)
-      end.to raise_error ArgumentError, /max_overlap must be a positive integer/
-    end
-
-    it 'accepts zero values' do
-      expect do
-        described_class.new(max_chars: 0, max_overlap: 0)
-      end.not_to raise_error
-    end
-
-    it 'accepts positive values' do
-      expect do
-        described_class.new(max_chars: 2000, max_overlap: 500)
-      end.not_to raise_error
-    end
-  end
-
-  describe 'keyword arguments' do
-    it 'accepts all keyword arguments' do
-      config = described_class.new(
-        max_chars: 750,
-        max_overlap: 150,
-        preset: 'balanced',
-        enabled: true
-      )
-
-      expect(config.max_chars).to eq 750
-      expect(config.max_overlap).to eq 150
-      expect(config.preset).to eq 'balanced'
-      expect(config.enabled).to be true
-    end
-
-    it 'converts preset to string' do
-      config = described_class.new(preset: :fast)
-
-      expect(config.preset).to eq 'fast'
-      expect(config.preset).to be_a String
-    end
-  end
-
-  describe 'equality' do
-    it 'compares configs by value' do
-      config1 = described_class.new(max_chars: 500, max_overlap: 100)
-      config2 = described_class.new(max_chars: 500, max_overlap: 100)
-
-      expect(config1.max_chars).to eq config2.max_chars
-      expect(config1.max_overlap).to eq config2.max_overlap
-    end
-
-    it 'detects differences' do
-      config1 = described_class.new(max_chars: 500)
-      config2 = described_class.new(max_chars: 1000)
-
-      expect(config1.max_chars).not_to eq config2.max_chars
-    end
-  end
-
-  describe 'nested config integration' do
-    it 'can be nested in Extraction config' do
-      chunking = described_class.new(max_chars: 750, preset: 'fast')
-      extraction = Kreuzberg::Config::Extraction.new(chunking: chunking)
-
-      expect(extraction.chunking).to be_a described_class
-      expect(extraction.chunking.max_chars).to eq 750
-    end
-
-    it 'accepts hash in Extraction config' do
-      extraction = Kreuzberg::Config::Extraction.new(
-        chunking: { max_chars: 500, preset: 'balanced' }
-      )
-
-      expect(extraction.chunking).to be_a described_class
-      expect(extraction.chunking.max_chars).to eq 500
-    end
-  end
-
-  describe 'symbol vs string key handling' do
-    it 'converts symbol preset to string' do
-      config = described_class.new(preset: :fast)
-
-      expect(config.preset).to eq 'fast'
-      expect(config.preset).to be_a String
-    end
-
-    it 'converts integer strings to integers' do
-      config = described_class.new(max_chars: '1500', max_overlap: '300')
-
-      expect(config.max_chars).to eq 1500
-      expect(config.max_overlap).to eq 300
-      expect(config.max_chars).to be_a Integer
-    end
-  end
-
-  describe 'enabled field' do
-    it 'defaults to true' do
-      config = described_class.new
-
-      expect(config.enabled).to be true
-    end
-
-    it 'accepts false' do
-      config = described_class.new(enabled: false)
-
-      expect(config.enabled).to be false
-    end
-
-    it 'converts truthy values to true' do
-      config = described_class.new(enabled: 'yes')
-
-      expect(config.enabled).to be true
-    end
-
-    it 'can be nil' do
-      config = described_class.new(enabled: nil)
-
-      expect(config.enabled).to be_nil
-    end
-  end
-end

data/spec/unit/config/embedding_config_spec.rb

@@ -1,343 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Kreuzberg::Config::Embedding do
-  describe '#initialize' do
-    it 'creates config with default values' do
-      config = described_class.new
-
-      expect(config.model).to be_a Hash
-      expect(config.model[:type]).to eq :preset
-      expect(config.model[:name]).to eq 'balanced'
-      expect(config.normalize).to be true
-      expect(config.batch_size).to eq 32
-      expect(config.show_download_progress).to be false
-      expect(config.cache_dir).to be_nil
-    end
-
-    it 'creates config with custom model hash' do
-      model = { type: :preset, name: 'fast' }
-      config = described_class.new(model: model)
-
-      expect(config.model[:type]).to eq :preset
-      expect(config.model[:name]).to eq 'fast'
-    end
-
-    it 'creates config with custom values' do
-      config = described_class.new(
-        normalize: false,
-        batch_size: 64,
-        show_download_progress: true,
-        cache_dir: '/cache'
-      )
-
-      expect(config.normalize).to be false
-      expect(config.batch_size).to eq 64
-      expect(config.show_download_progress).to be true
-      expect(config.cache_dir).to eq '/cache'
-    end
-
-    it 'converts model with to_h method' do
-      model_like = double(to_h: { type: :custom, name: 'model' })
-      config = described_class.new(model: model_like)
-
-      expect(config.model).to be_a Hash
-      expect(config.model[:type]).to eq :custom
-    end
-
-    it 'converts batch_size to integer' do
-      config = described_class.new(batch_size: '128')
-
-      expect(config.batch_size).to eq 128
-      expect(config.batch_size).to be_a Integer
-    end
-
-    it 'converts normalize to boolean' do
-      config = described_class.new(normalize: 1)
-
-      expect(config.normalize).to be true
-    end
-
-    it 'converts show_download_progress to boolean' do
-      config = described_class.new(show_download_progress: 'yes')
-
-      expect(config.show_download_progress).to be true
-    end
-
-    it 'converts cache_dir to string' do
-      config = described_class.new(cache_dir: :default_cache)
-
-      expect(config.cache_dir).to be_a String
-    end
-  end
-
-  describe '#to_h' do
-    it 'serializes to hash with all values' do
-      config = described_class.new(
-        model: { type: :preset, name: 'fast' },
-        batch_size: 64
-      )
-      hash = config.to_h
-
-      expect(hash).to be_a Hash
-      expect(hash[:model]).to be_a Hash
-      expect(hash[:normalize]).to be true
-      expect(hash[:batch_size]).to eq 64
-    end
-
-    it 'includes cache_dir when present' do
-      config = described_class.new(cache_dir: '/cache')
-      hash = config.to_h
-
-      expect(hash[:cache_dir]).to eq '/cache'
-    end
-
-    it 'compacts nil values from hash' do
-      config = described_class.new
-      hash = config.to_h
-
-      expect(hash.key?(:cache_dir)).to be false
-    end
-
-    it 'always includes model in hash' do
-      config = described_class.new
-      hash = config.to_h
-
-      expect(hash.key?(:model)).to be true
-      expect(hash[:model]).to be_a Hash
-    end
-  end
-
-  describe 'validation' do
-    it 'rejects invalid model type (not hash)' do
-      expect do
-        described_class.new(model: 'invalid_string')
-      end.to raise_error ArgumentError, /model must be a Hash/
-    end
-
-    it 'accepts model as hash' do
-      expect do
-        described_class.new(model: { type: :preset, name: 'fast' })
-      end.not_to raise_error
-    end
-
-    it 'accepts model with to_h method' do
-      model_like = double(to_h: { type: :preset, name: 'fast' })
-      expect do
-        described_class.new(model: model_like)
-      end.not_to raise_error
-    end
-
-    it 'accepts valid batch_size' do
-      expect do
-        described_class.new(batch_size: 32)
-      end.not_to raise_error
-    end
-
-    it 'accepts valid cache_dir' do
-      expect do
-        described_class.new(cache_dir: '/tmp/cache')
-      end.not_to raise_error
-    end
-  end
-
-  describe 'keyword arguments' do
-    it 'accepts all keyword arguments' do
-      config = described_class.new(
-        model: { type: :preset, name: 'balanced' },
-        normalize: true,
-        batch_size: 48,
-        show_download_progress: true,
-        cache_dir: '/cache'
-      )
-
-      expect(config.model[:name]).to eq 'balanced'
-      expect(config.normalize).to be true
-      expect(config.batch_size).to eq 48
-      expect(config.show_download_progress).to be true
-      expect(config.cache_dir).to eq '/cache'
-    end
-  end
-
-  describe 'equality' do
-    it 'compares configs by value' do
-      config1 = described_class.new(
-        model: { type: :preset, name: 'fast' },
-        batch_size: 64
-      )
-      config2 = described_class.new(
-        model: { type: :preset, name: 'fast' },
-        batch_size: 64
-      )
-
-      expect(config1.model).to eq config2.model
-      expect(config1.batch_size).to eq config2.batch_size
-    end
-
-    it 'detects differences in model' do
-      config1 = described_class.new(model: { type: :preset, name: 'fast' })
-      config2 = described_class.new(model: { type: :preset, name: 'balanced' })
-
-      expect(config1.model).not_to eq config2.model
-    end
-
-    it 'detects differences in batch_size' do
-      config1 = described_class.new(batch_size: 32)
-      config2 = described_class.new(batch_size: 64)
-
-      expect(config1.batch_size).not_to eq config2.batch_size
-    end
-
-    it 'detects differences in normalize' do
-      config1 = described_class.new(normalize: true)
-      config2 = described_class.new(normalize: false)
-
-      expect(config1.normalize).not_to eq config2.normalize
-    end
-  end
-
-  describe 'nested config integration' do
-    it 'can be nested in Chunking config' do
-      embedding = described_class.new(
-        model: { type: :preset, name: 'fast' },
-        batch_size: 64
-      )
-      chunking = Kreuzberg::Config::Chunking.new(embedding: embedding)
-
-      expect(chunking.embedding).to be_a described_class
-      expect(chunking.embedding.batch_size).to eq 64
-    end
-
-    it 'accepts hash in Chunking config' do
-      chunking = Kreuzberg::Config::Chunking.new(
-        embedding: { model: { type: :preset, name: 'balanced' } }
-      )
-
-      expect(chunking.embedding).to be_a described_class
-      expect(chunking.embedding.model[:name]).to eq 'balanced'
-    end
-
-    it 'can be nested in Extraction config via Chunking' do
-      extraction = Kreuzberg::Config::Extraction.new(
-        chunking: { embedding: { batch_size: 48 } }
-      )
-
-      expect(extraction.chunking.embedding).to be_a described_class
-      expect(extraction.chunking.embedding.batch_size).to eq 48
-    end
-  end
-
-  describe 'symbol vs string key handling' do
-    it 'normalizes model keys to symbols' do
-      config = described_class.new(model: { 'type' => :preset, 'name' => 'fast' })
-
-      expect(config.model).to be_a Hash
-      expect(config.model[:type]).to eq :preset
-    end
-
-    it 'preserves symbol values in model' do
-      config = described_class.new(model: { type: :preset })
-
-      expect(config.model[:type]).to eq :preset
-    end
-  end
-
-  describe 'boolean conversion' do
-    it 'converts truthy normalize to true' do
-      config = described_class.new(normalize: 1)
-
-      expect(config.normalize).to be true
-    end
-
-    it 'converts false normalize to false' do
-      config = described_class.new(normalize: false)
-
-      expect(config.normalize).to be false
-    end
-
-    it 'converts truthy show_download_progress to true' do
-      config = described_class.new(show_download_progress: 'yes')
-
-      expect(config.show_download_progress).to be true
-    end
-
-    it 'converts false show_download_progress to false' do
-      config = described_class.new(show_download_progress: false)
-
-      expect(config.show_download_progress).to be false
-    end
-  end
-
-  describe 'model configuration' do
-    it 'accepts preset model type' do
-      config = described_class.new(model: { type: :preset, name: 'fast' })
-
-      expect(config.model[:type]).to eq :preset
-    end
-
-    it 'accepts custom model type' do
-      config = described_class.new(model: { type: :custom, path: '/model' })
-
-      expect(config.model[:type]).to eq :custom
-    end
-
-    it 'preserves model configuration details' do
-      model = { type: :preset, name: 'balanced', dimensions: 384 }
-      config = described_class.new(model: model)
-
-      expect(config.model[:dimensions]).to eq 384
-    end
-  end
-
-  describe 'batch size handling' do
-    it 'defaults to 32' do
-      config = described_class.new
-
-      expect(config.batch_size).to eq 32
-    end
-
-    it 'accepts small batch sizes' do
-      config = described_class.new(batch_size: 1)
-
-      expect(config.batch_size).to eq 1
-    end
-
-    it 'accepts large batch sizes' do
-      config = described_class.new(batch_size: 512)
-
-      expect(config.batch_size).to eq 512
-    end
-
-    it 'converts string batch_size to integer' do
-      config = described_class.new(batch_size: '256')
-
-      expect(config.batch_size).to eq 256
-      expect(config.batch_size).to be_a Integer
-    end
-  end
-
-  describe 'cache directory' do
-    it 'defaults to nil' do
-      config = described_class.new
-
-      expect(config.cache_dir).to be_nil
-    end
-
-    it 'accepts absolute paths' do
-      config = described_class.new(cache_dir: '/var/cache/embeddings')
-
-      expect(config.cache_dir).to eq '/var/cache/embeddings'
-    end
-
-    it 'accepts relative paths' do
-      config = described_class.new(cache_dir: './cache')
-
-      expect(config.cache_dir).to eq './cache'
-    end
-
-    it 'converts path to string' do
-      config = described_class.new(cache_dir: :default_cache)
-
-      expect(config.cache_dir).to be_a String
-    end
-  end
-end