kreuzberg 4.3.5-aarch64-linux

data/spec/fixtures/config.yaml

@@ -0,0 +1,41 @@
+
+use_cache: false
+enable_quality_processing: true
+force_ocr: true
+
+ocr:
+  backend: tesseract
+  language: fra
+
+chunking:
+  max_chars: 750
+  max_overlap: 150
+  preset: balanced
+
+language_detection:
+  enabled: true
+  min_confidence: 0.85
+
+pdf_options:
+  extract_images: false
+  passwords:
+    - password1
+    - password2
+  extract_metadata: true
+
+image_extraction:
+  extract_images: true
+  target_dpi: 300
+  max_image_dimension: 4096
+  auto_adjust_dpi: true
+  min_dpi: 72
+  max_dpi: 600
+
+postprocessor:
+  enabled: false
+  disabled_processors:
+    - token_reduction
+
+token_reduction:
+  mode: light
+  preserve_important_words: false

data/spec/fixtures/invalid_config.toml

@@ -0,0 +1,3 @@
+use_cache = "not_a_boolean"
+[ocr
+backend = "tesseract"

data/spec/serialization_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Cross-language serialization tests for Ruby bindings
+#
+# Validates that ExtractionConfig serializes consistently with other language bindings
+
+require 'json'
+require 'spec_helper'
+
+RSpec.describe Kreuzberg::ExtractionConfig do
+  describe '#to_h' do
+    it 'serializes minimal config to hash' do
+      config = described_class.new
+      hash = config.to_h
+
+      expect(hash).to be_a(Hash)
+      expect(hash).to have_key(:use_cache)
+      expect(hash).to have_key(:enable_quality_processing)
+      expect(hash).to have_key(:force_ocr)
+    end
+
+    it 'serializes config with all fields' do
+      config = described_class.new(
+        use_cache: true,
+        enable_quality_processing: true,
+        force_ocr: false
+      )
+
+      hash = config.to_h
+
+      expect(hash[:use_cache]).to be(true)
+      expect(hash[:enable_quality_processing]).to be(true)
+      expect(hash[:force_ocr]).to be(false)
+    end
+
+    it 'preserves field values after serialization' do
+      original = described_class.new(
+        use_cache: false,
+        enable_quality_processing: true
+      )
+
+      hash = original.to_h
+
+      expect(hash[:use_cache]).to be(false)
+      expect(hash[:enable_quality_processing]).to be(true)
+    end
+  end
+
+  describe '#to_json' do
+    it 'serializes to JSON' do
+      config = described_class.new(use_cache: true)
+      json = config.to_json
+
+      expect(json).to be_a(String)
+
+      parsed = JSON.parse(json, symbolize_names: true)
+      expect(parsed).to have_key(:use_cache)
+      expect(parsed[:use_cache]).to be(true)
+    end
+
+    it 'produces valid JSON' do
+      config = described_class.new
+      json = config.to_json
+
+      expect { JSON.parse(json) }.not_to raise_error
+    end
+
+    it 'uses snake_case field names' do
+      config = described_class.new(use_cache: true)
+      json = config.to_json
+
+      expect(json).to include('use_cache')
+      expect(json).not_to include('useCache')
+    end
+  end
+
+  describe 'round-trip serialization' do
+    it 'survives serialization -> deserialization -> serialization' do
+      config1 = described_class.new(
+        use_cache: true,
+        enable_quality_processing: false
+      )
+
+      json1 = config1.to_json
+      hash1 = JSON.parse(json1, symbolize_names: true)
+
+      config2 = described_class.new(hash1)
+      json2 = config2.to_json
+
+      # JSON strings should be equivalent
+      expect(JSON.parse(json1)).to eq(JSON.parse(json2))
+    end
+  end
+
+  describe 'field consistency' do
+    it 'includes all mandatory fields' do
+      config = described_class.new
+      hash = config.to_h
+
+      mandatory_fields = %i[use_cache enable_quality_processing force_ocr]
+      mandatory_fields.each do |field|
+        expect(hash).to have_key(field)
+      end
+    end
+
+    it 'handles nested ocr config' do
+      config = described_class.new(
+        ocr: {
+          backend: 'tesseract',
+          language: 'eng'
+        }
+      )
+
+      hash = config.to_h
+
+      expect(hash).to have_key(:ocr)
+      expect(hash[:ocr][:backend]).to eq('tesseract')
+      expect(hash[:ocr][:language]).to eq('eng')
+    end
+  end
+
+  describe 'immutability' do
+    it 'does not modify original config during serialization' do
+      config = described_class.new(use_cache: true)
+
+      json1 = config.to_json
+      json2 = config.to_json
+      json3 = config.to_json
+
+      expect(json1).to eq(json2)
+      expect(json2).to eq(json3)
+    end
+  end
+end

data/spec/smoke/package_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+RSpec.describe 'Kreuzberg package' do
+  describe 'import and structure' do
+    it 'can be required without errors' do
+      expect { require 'kreuzberg' }.not_to raise_error
+    end
+
+    it 'has a version constant' do
+      expect(Kreuzberg::VERSION).not_to be_nil
+      expect(Kreuzberg::VERSION).to be_a(String)
+      expect(Kreuzberg::VERSION).to match(/^\d+\.\d+\.\d+/)
+    end
+  end
+
+  describe 'public API exports' do
+    describe 'configuration classes' do
+      it 'exports Config::Extraction' do
+        expect(defined?(Kreuzberg::Config::Extraction)).to eq('constant')
+      end
+
+      it 'exports Config::OCR' do
+        expect(defined?(Kreuzberg::Config::OCR)).to eq('constant')
+      end
+
+      it 'exports Config::Chunking' do
+        expect(defined?(Kreuzberg::Config::Chunking)).to eq('constant')
+      end
+
+      it 'exports Config::LanguageDetection' do
+        expect(defined?(Kreuzberg::Config::LanguageDetection)).to eq('constant')
+      end
+
+      it 'exports Config::PDF' do
+        expect(defined?(Kreuzberg::Config::PDF)).to eq('constant')
+      end
+
+      it 'exports Config::HtmlOptions' do
+        expect(defined?(Kreuzberg::Config::HtmlOptions)).to eq('constant')
+      end
+
+      it 'exports Config::Keywords' do
+        expect(defined?(Kreuzberg::Config::Keywords)).to eq('constant')
+      end
+    end
+
+    describe 'result classes' do
+      it 'exports Result' do
+        expect(defined?(Kreuzberg::Result)).to eq('constant')
+      end
+
+      it 'exports Result::Table' do
+        expect(defined?(Kreuzberg::Result::Table)).to eq('constant')
+      end
+
+      it 'exports Result::Chunk' do
+        expect(defined?(Kreuzberg::Result::Chunk)).to eq('constant')
+      end
+
+      it 'exports Result::Image' do
+        expect(defined?(Kreuzberg::Result::Image)).to eq('constant')
+      end
+    end
+
+    describe 'exception classes' do
+      it 'exports Errors::Error' do
+        expect(defined?(Kreuzberg::Errors::Error)).to eq('constant')
+      end
+
+      it 'exports Errors::ValidationError' do
+        expect(defined?(Kreuzberg::Errors::ValidationError)).to eq('constant')
+      end
+
+      it 'exports Errors::ParsingError' do
+        expect(defined?(Kreuzberg::Errors::ParsingError)).to eq('constant')
+      end
+
+      it 'exports Errors::OCRError' do
+        expect(defined?(Kreuzberg::Errors::OCRError)).to eq('constant')
+      end
+
+      it 'exports Errors::MissingDependencyError' do
+        expect(defined?(Kreuzberg::Errors::MissingDependencyError)).to eq('constant')
+      end
+
+      it 'exports Errors::IOError' do
+        expect(defined?(Kreuzberg::Errors::IOError)).to eq('constant')
+      end
+
+      it 'exports Errors::PluginError' do
+        expect(defined?(Kreuzberg::Errors::PluginError)).to eq('constant')
+      end
+    end
+
+    describe 'extraction functions (sync)' do
+      it 'exports extract_file_sync' do
+        expect(Kreuzberg).to respond_to(:extract_file_sync)
+      end
+
+      it 'exports extract_bytes_sync' do
+        expect(Kreuzberg).to respond_to(:extract_bytes_sync)
+      end
+
+      it 'exports batch_extract_files_sync' do
+        expect(Kreuzberg).to respond_to(:batch_extract_files_sync)
+      end
+    end
+
+    describe 'extraction functions (async)' do
+      it 'exports extract_file' do
+        expect(Kreuzberg).to respond_to(:extract_file)
+      end
+
+      it 'exports extract_bytes' do
+        expect(Kreuzberg).to respond_to(:extract_bytes)
+      end
+
+      it 'exports batch_extract_files' do
+        expect(Kreuzberg).to respond_to(:batch_extract_files)
+      end
+    end
+
+    describe 'utility modules' do
+      it 'exports CLI' do
+        expect(defined?(Kreuzberg::CLI)).to eq('constant')
+      end
+
+      it 'exports CLIProxy' do
+        expect(defined?(Kreuzberg::CLIProxy)).to eq('constant')
+      end
+
+      it 'exports APIProxy' do
+        expect(defined?(Kreuzberg::APIProxy)).to eq('constant')
+      end
+
+      it 'exports MCPProxy' do
+        expect(defined?(Kreuzberg::MCPProxy)).to eq('constant')
+      end
+    end
+  end
+
+  describe 'module structure' do
+    it 'defines Kreuzberg as a module' do
+      expect(Kreuzberg).to be_a(Module)
+    end
+
+    it 'defines Kreuzberg::Config as a module' do
+      expect(Kreuzberg::Config).to be_a(Module)
+    end
+
+    it 'defines Kreuzberg::Errors as a module' do
+      expect(Kreuzberg::Errors).to be_a(Module)
+    end
+  end
+
+  describe 'basic extraction smoke tests' do
+    it 'extracts inline text via bytes API' do
+      bytes = StringIO.new('Hello from Kreuzberg')
+      result = Kreuzberg.extract_bytes_sync(data: bytes.string, mime_type: 'text/plain')
+
+      expect(result.content).to include('Hello')
+      expect(result.mime_type).to eq('text/plain')
+    end
+
+    it 'extracts from small temp file via sync API' do
+      file = create_test_file('Simple document for smoke testing')
+      result = Kreuzberg.extract_file_sync(path: file)
+
+      expect(result.content).to include('Simple document')
+      expect(result.mime_type).to eq('text/plain')
+    ensure
+      File.delete(file) if file && File.exist?(file)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'kreuzberg'
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.default_formatter = 'doc' if config.files_to_run.one?
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.include(Module.new do
+    def fixture_path(filename)
+      File.join(__dir__, 'fixtures', filename)
+    end
+
+    def test_document_path(relative_path)
+      File.expand_path(File.join(__dir__, '..', '..', '..', 'test_documents', relative_path))
+    end
+
+    def create_test_file(content, filename: 'test.txt')
+      path = File.join(Dir.tmpdir, filename)
+      File.write(path, content)
+      path
+    end
+  end)
+end

data/spec/unit/config/chunking_config_spec.rb

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