kreuzberg 4.3.5-aarch64-linux

data/spec/binding/batch_spec.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tempfile'
+require 'fileutils'
+require 'securerandom'
+
+RSpec.describe Kreuzberg do
+  describe '#batch_extract_files_sync' do
+    it 'extracts multiple files in a single batch operation' do
+      paths = []
+      3.times do |i|
+        file = Tempfile.new(["batch_test_#{i}", '.md'])
+        file.write("# Content of file #{i}\n\nSome markdown content")
+        file.close
+        paths << file.path
+      end
+
+      results = described_class.batch_extract_files_sync(paths: paths)
+
+      expect(results).to be_a(Array)
+      expect(results.length).to eq(3)
+      results.each do |result|
+        expect(result).to be_a(Kreuzberg::Result)
+        expect(result.content).not_to be_empty
+      end
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+
+    it 'maintains correct order of results' do
+      paths = []
+      unique_ids = []
+      3.times do |i|
+        file = Tempfile.new(["ordered_#{i}", '.md'])
+        unique_id = SecureRandom.hex(8)
+        content = "# File #{i}\n\nUnique marker: #{unique_id}\n\nSome content"
+        file.write(content)
+        file.close
+        paths << file.path
+        unique_ids << unique_id
+      end
+
+      results = described_class.batch_extract_files_sync(paths: paths)
+
+      expect(results.length).to eq(paths.length)
+      results.each_with_index do |result, idx|
+        expect(result.content).to include(unique_ids[idx])
+      end
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+
+    it 'handles empty file list gracefully' do
+      results = described_class.batch_extract_files_sync(paths: [])
+      expect(results).to be_a(Array)
+      expect(results).to be_empty
+    end
+
+    it 'handles batch operations with configuration' do
+      paths = []
+      2.times do |i|
+        file = Tempfile.new("config_batch_#{i}.txt")
+        file.write("Config test content #{i}")
+        file.close
+        paths << file.path
+      end
+
+      config = Kreuzberg::Config::Extraction.new(
+        use_cache: false
+      )
+
+      results = described_class.batch_extract_files_sync(paths: paths, config: config)
+
+      expect(results).to be_a(Array)
+      expect(results.length).to eq(2)
+      expect(results).to all(be_a(Kreuzberg::Result))
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+
+    it 'returns independent result objects' do
+      paths = []
+      2.times do |i|
+        file = Tempfile.new("independent_#{i}.txt")
+        file.write("Independent content #{i}")
+        file.close
+        paths << file.path
+      end
+
+      results = described_class.batch_extract_files_sync(paths: paths)
+
+      expect(results[0].content).not_to eq(results[1].content)
+      expect(results[0].mime_type).to eq(results[1].mime_type)
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+
+    it 'extracts different file types in batch' do
+      paths = []
+      temp_dir = Dir.mktmpdir
+
+      txt_file = File.join(temp_dir, 'test.txt')
+      File.write(txt_file, 'Text content')
+      paths << txt_file
+
+      csv_file = File.join(temp_dir, 'test.csv')
+      File.write(csv_file, "Name,Value\nAlice,1\nBob,2")
+      paths << csv_file
+
+      json_file = File.join(temp_dir, 'test.json')
+      File.write(json_file, '{"key": "value"}')
+      paths << json_file
+
+      results = described_class.batch_extract_files_sync(paths: paths)
+
+      expect(results.length).to eq(3)
+      results.each do |result|
+        expect(result.mime_type).not_to be_nil
+        expect(result.content).not_to be_empty
+      end
+    ensure
+      FileUtils.remove_entry(temp_dir)
+    end
+  end
+
+  describe '#batch_extract_files' do
+    it 'extracts multiple files asynchronously' do
+      paths = []
+      3.times do |i|
+        file = Tempfile.new("async_batch_#{i}.txt")
+        file.write("Async content #{i}")
+        file.close
+        paths << file.path
+      end
+
+      results = described_class.batch_extract_files(paths: paths)
+
+      expect(results).to be_a(Array)
+      expect(results.length).to eq(3)
+      expect(results).to all(be_a(Kreuzberg::Result))
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+
+    it 'handles async batch with configuration' do
+      paths = []
+      2.times do |i|
+        file = Tempfile.new("async_config_#{i}.txt")
+        file.write("Async config #{i}")
+        file.close
+        paths << file.path
+      end
+
+      config = Kreuzberg::Config::Extraction.new(
+        use_cache: false
+      )
+
+      results = described_class.batch_extract_files(paths: paths, config: config)
+
+      expect(results.length).to eq(2)
+      results.each { |result| expect(result.content).not_to be_empty }
+    ensure
+      paths.each { |p| FileUtils.rm_f(p) }
+    end
+  end
+
+  describe '#batch_extract_bytes_sync' do
+    it 'extracts multiple byte sources in batch' do
+      data = [
+        'First content',
+        'Second content',
+        '{"json": true}'
+      ]
+      mime_types = [
+        'text/plain',
+        'text/plain',
+        'application/json'
+      ]
+
+      results = described_class.batch_extract_bytes_sync(data_array: data, mime_types: mime_types)
+
+      expect(results).to be_a(Array)
+      expect(results.length).to eq(3)
+      expect(results).to all(be_a(Kreuzberg::Result))
+    end
+
+    it 'maintains order for batch byte operations' do
+      data = ['Content A', 'Content B', 'Content C']
+      mime_types = ['text/plain'] * 3
+
+      results = described_class.batch_extract_bytes_sync(data_array: data, mime_types: mime_types)
+
+      expect(results.length).to eq(3)
+      results.each_with_index do |result, idx|
+        expect(result.content).to include(data[idx])
+      end
+    end
+
+    it 'handles empty byte list' do
+      results = described_class.batch_extract_bytes_sync(data_array: [], mime_types: [])
+      expect(results).to be_a(Array)
+      expect(results).to be_empty
+    end
+
+    it 'applies configuration to byte batch operations' do
+      data = ['Batch bytes 1', 'Batch bytes 2']
+      mime_types = ['text/plain'] * 2
+
+      config = Kreuzberg::Config::Extraction.new(
+        use_cache: false
+      )
+
+      results = described_class.batch_extract_bytes_sync(data_array: data, mime_types: mime_types, config: config)
+
+      expect(results.length).to eq(2)
+      results.each { |result| expect(result.mime_type).to eq('text/plain') }
+    end
+  end
+
+  describe '#batch_extract_bytes' do
+    it 'extracts multiple bytes asynchronously' do
+      data = ['Async bytes 1', 'Async bytes 2']
+      mime_types = ['text/plain'] * 2
+
+      results = described_class.batch_extract_bytes(data_array: data, mime_types: mime_types)
+
+      expect(results).to be_a(Array)
+      expect(results.length).to eq(2)
+      expect(results).to all(be_a(Kreuzberg::Result))
+    end
+
+    it 'handles async byte batch with configuration' do
+      data = ['Config async 1', 'Config async 2']
+      mime_types = ['text/plain'] * 2
+
+      config = Kreuzberg::Config::Extraction.new(
+        use_cache: false
+      )
+
+      results = described_class.batch_extract_bytes(data_array: data, mime_types: mime_types, config: config)
+
+      expect(results.length).to eq(2)
+      results.each { |result| expect(result.content).not_to be_empty }
+    end
+  end
+
+  describe 'batch performance characteristics' do
+    it 'processes batch operations efficiently' do
+      paths = []
+      file_count = 5
+
+      temp_dir = Dir.mktmpdir
+      file_count.times do |i|
+        file_path = File.join(temp_dir, "perf_test_#{i}.txt")
+        File.write(file_path, "Performance test content #{i}")
+        paths << file_path
+      end
+
+      start_time = Time.now
+      results = described_class.batch_extract_files_sync(paths: paths)
+      batch_duration = Time.now - start_time
+
+      expect(results.length).to eq(file_count)
+      expect(results).to all(be_a(Kreuzberg::Result))
+
+      expect(batch_duration).to be < 60
+    ensure
+      FileUtils.remove_entry(temp_dir)
+    end
+
+    it 'batch results match sequential results' do
+      paths = []
+      temp_dir = Dir.mktmpdir
+
+      3.times do |i|
+        file_path = File.join(temp_dir, "compare_#{i}.txt")
+        File.write(file_path, "Comparison content #{i}")
+        paths << file_path
+      end
+
+      batch_results = described_class.batch_extract_files_sync(paths: paths)
+
+      sequential_results = paths.map { |p| described_class.extract_file_sync(path: p) }
+
+      expect(batch_results.length).to eq(sequential_results.length)
+      batch_results.each_with_index do |batch_result, idx|
+        seq_result = sequential_results[idx]
+        expect(batch_result.content).to eq(seq_result.content)
+        expect(batch_result.mime_type).to eq(seq_result.mime_type)
+      end
+    ensure
+      FileUtils.remove_entry(temp_dir)
+    end
+  end
+
+  describe 'batch error handling' do
+    it 'raises IOError for missing files in batch' do
+      paths = [
+        '/nonexistent/file1.txt',
+        '/nonexistent/file2.txt'
+      ]
+
+      expect do
+        described_class.batch_extract_files_sync(paths: paths)
+      end.to raise_error(Kreuzberg::Errors::IOError, /not found/)
+    end
+
+    it 'raises IOError when batch contains invalid paths' do
+      paths = []
+      temp_dir = Dir.mktmpdir
+
+      valid_path = File.join(temp_dir, 'valid.txt')
+      File.write(valid_path, 'Valid content')
+      paths << valid_path
+
+      paths << '/nonexistent/invalid.txt'
+
+      expect do
+        described_class.batch_extract_files_sync(paths: paths)
+      end.to raise_error(Kreuzberg::Errors::IOError, /not found/)
+    ensure
+      FileUtils.remove_entry(temp_dir)
+    end
+
+    it 'raises error on invalid mime type in byte batch' do
+      data = ['Content']
+      mime_types = ['invalid/mime/type']
+
+      expect do
+        described_class.batch_extract_bytes_sync(data_array: data, mime_types: mime_types)
+      end.not_to raise_error
+    end
+  end
+
+  describe 'batch caching behavior' do
+    it 'respects cache configuration in batch' do
+      paths = []
+      temp_dir = Dir.mktmpdir
+
+      2.times do |i|
+        file_path = File.join(temp_dir, "cache_test_#{i}.txt")
+        File.write(file_path, "Cache test #{i}")
+        paths << file_path
+      end
+
+      config_no_cache = Kreuzberg::Config::Extraction.new(use_cache: false)
+
+      results1 = described_class.batch_extract_files_sync(paths: paths, config: config_no_cache)
+      results2 = described_class.batch_extract_files_sync(paths: paths, config: config_no_cache)
+
+      expect(results1.length).to eq(results2.length)
+      results1.each_with_index do |result, idx|
+        expect(result.content).to eq(results2[idx].content)
+      end
+    ensure
+      FileUtils.remove_entry(temp_dir)
+    end
+  end
+end

data/spec/binding/cache_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Cache Management' do
+  let(:test_pdf) do
+    test_document_path('pdf/5_level_paging_and_5_level_ept_intel_revision_1_1_may_2017.pdf')
+  end
+  let(:test_text) { test_document_path('text/contract_test.txt') }
+  let(:test_docx) { test_document_path('docx/extraction_test.docx') }
+
+  before do
+    Kreuzberg.clear_cache
+  end
+
+  after do
+    Kreuzberg.clear_cache
+  end
+
+  describe 'clear_cache' do
+    it 'removes all cached results' do
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(path: test_text)
+
+      stats_before = Kreuzberg.cache_stats
+      expect(stats_before['total_entries']).to be_positive
+
+      Kreuzberg.clear_cache
+
+      stats_after = Kreuzberg.cache_stats
+      expect(stats_after['total_entries']).to eq(0)
+      expect(stats_after['total_size_bytes']).to eq(0)
+    end
+
+    it 'returns nil (void return)' do
+      result = Kreuzberg.clear_cache
+      expect(result).to be_nil
+    end
+
+    it 'can be called multiple times safely' do
+      Kreuzberg.clear_cache
+      Kreuzberg.clear_cache
+      Kreuzberg.clear_cache
+
+      stats = Kreuzberg.cache_stats
+      expect(stats['total_entries']).to eq(0)
+    end
+
+    it 'does not affect future extractions' do
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.clear_cache
+
+      result = Kreuzberg.extract_file_sync(path: test_pdf)
+
+      expect(result).to be_a(Kreuzberg::Result)
+      expect(result.content).not_to be_empty
+    end
+  end
+
+  describe 'cache_stats' do
+    it 'returns hash with correct structure' do
+      stats = Kreuzberg.cache_stats
+
+      expect(stats).to be_a(Hash)
+      expect(stats).to have_key('total_entries')
+      expect(stats).to have_key('total_size_bytes')
+    end
+
+    it 'returns zero stats when cache is empty' do
+      Kreuzberg.clear_cache
+      stats = Kreuzberg.cache_stats
+
+      expect(stats['total_entries']).to eq(0)
+      expect(stats['total_size_bytes']).to eq(0)
+    end
+
+    it 'shows entries after extractions' do
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      stats = Kreuzberg.cache_stats
+
+      expect(stats['total_entries']).to be_positive
+    end
+
+    it 'shows total size in bytes' do
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      stats = Kreuzberg.cache_stats
+
+      expect(stats['total_size_bytes']).to be_positive
+    end
+
+    it 'increases stats with multiple extractions' do
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      stats_after_one = Kreuzberg.cache_stats
+
+      Kreuzberg.extract_file_sync(path: test_text)
+      stats_after_two = Kreuzberg.cache_stats
+
+      expect(stats_after_two['total_entries']).to be >= stats_after_one['total_entries']
+    end
+  end
+
+  describe 'cache behavior across extractions' do
+    it 'caches extraction results' do
+      Kreuzberg.clear_cache
+      stats_initial = Kreuzberg.cache_stats
+      expect(stats_initial['total_entries']).to eq(0)
+
+      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+      stats_after_first = Kreuzberg.cache_stats
+      expect(stats_after_first['total_entries']).to be_positive
+
+      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+      stats_after_second = Kreuzberg.cache_stats
+
+      expect(result1.content).to eq(result2.content)
+      expect(stats_after_second['total_entries']).to eq(stats_after_first['total_entries'] + 1)
+    end
+
+    it 'tracks different files separately' do
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      stats_after_pdf = Kreuzberg.cache_stats
+
+      Kreuzberg.extract_file_sync(path: test_text)
+      stats_after_text = Kreuzberg.cache_stats
+
+      expect(stats_after_text['total_entries']).to be >= stats_after_pdf['total_entries']
+    end
+
+    it 'second extraction of same file may use cache' do
+      Kreuzberg.clear_cache
+
+      Time.now
+      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+      Time.now
+
+      Time.now
+      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+      Time.now
+
+      expect(result1.content).to eq(result2.content)
+      expect(result1.mime_type).to eq(result2.mime_type)
+    end
+
+    it 'clears cache between extractions when requested' do
+      result1 = Kreuzberg.extract_file_sync(path: test_pdf)
+
+      Kreuzberg.clear_cache
+
+      result2 = Kreuzberg.extract_file_sync(path: test_pdf)
+
+      expect(result1.content).to eq(result2.content)
+    end
+  end
+
+  describe 'cache with different configurations' do
+    it 'respects use_cache flag in configs' do
+      Kreuzberg.clear_cache
+
+      config1 = Kreuzberg::Config::Extraction.new(use_cache: true)
+      config2 = Kreuzberg::Config::Extraction.new(use_cache: false)
+
+      Kreuzberg.extract_file_sync(path: test_pdf, config: config1)
+      stats_after_first = Kreuzberg.cache_stats
+
+      Kreuzberg.extract_file_sync(path: test_pdf, config: config2)
+      stats_after_second = Kreuzberg.cache_stats
+
+      expect(stats_after_second['total_entries']).to eq(stats_after_first['total_entries'])
+    end
+  end
+
+  describe 'cache stats consistency' do
+    it 'stats remain consistent after clear' do
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.extract_file_sync(path: test_text)
+
+      Kreuzberg.clear_cache
+      stats = Kreuzberg.cache_stats
+
+      expect(stats['total_entries']).to eq(0)
+      expect(stats['total_size_bytes']).to eq(0)
+    end
+
+    it 'stats update correctly after new extractions' do
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_pdf)
+      Kreuzberg.cache_stats
+
+      Kreuzberg.clear_cache
+
+      Kreuzberg.extract_file_sync(path: test_text)
+      stats2 = Kreuzberg.cache_stats
+
+      expect(stats2['total_entries']).to be_positive
+    end
+  end
+
+  describe 'integration with batch operations' do
+    it 'caches batch extraction results' do
+      Kreuzberg.clear_cache
+
+      results = Kreuzberg.batch_extract_files_sync(paths: [test_pdf, test_text])
+      stats = Kreuzberg.cache_stats
+
+      expect(results.length).to eq(2)
+      expect(stats['total_entries']).to be_positive
+    end
+
+    it 'clear_cache affects batch extractions' do
+      Kreuzberg.batch_extract_files_sync(paths: [test_pdf, test_text])
+
+      Kreuzberg.clear_cache
+
+      stats = Kreuzberg.cache_stats
+      expect(stats['total_entries']).to eq(0)
+    end
+  end
+end

data/spec/binding/cli_proxy_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe Kreuzberg::CLIProxy do
+  describe '.find_cli_binary' do
+    context 'when binary exists' do
+      it 'finds the binary in search paths' do
+        binary = described_class.find_cli_binary
+        expect(binary).to be_a(Pathname)
+        expect(binary.file?).to be true
+      end
+    end
+
+    context 'when binary does not exist' do
+      before do
+        allow(described_class).to receive(:search_paths).and_return([])
+      end
+
+      it 'raises MissingBinaryError' do
+        expect do
+          described_class.find_cli_binary
+        end.to raise_error(Kreuzberg::CLIProxy::MissingBinaryError, /not found/)
+      end
+    end
+  end
+
+  describe '.call' do
+    context 'when binary is available' do
+      it 'executes CLI command successfully' do
+        output = described_class.call(['--version'])
+        expect(output).to be_a(String)
+        expect(output).not_to be_empty
+      end
+
+      it 'raises CLIExecutionError on failure' do
+        expect do
+          described_class.call(['invalid-command'])
+        end.to raise_error(Kreuzberg::CLIProxy::CLIExecutionError)
+      end
+    end
+  end
+
+  describe '.search_paths' do
+    it 'returns an array of Pathname objects' do
+      paths = described_class.search_paths('kreuzberg')
+      expect(paths).to be_an(Array)
+      expect(paths).to all(be_a(Pathname))
+    end
+
+    it 'includes expected search locations' do
+      paths = described_class.search_paths('kreuzberg')
+      path_strings = paths.map(&:to_s)
+
+      expect(path_strings.any? { |p| p.include?('lib/bin') }).to be true
+      expect(path_strings.any? { |p| p.include?('target/release') }).to be true
+    end
+  end
+
+  describe '.root_path' do
+    it 'returns a Pathname' do
+      expect(described_class.root_path).to be_a(Pathname)
+    end
+
+    it 'points to an existing directory' do
+      expect(described_class.root_path.directory?).to be true
+    end
+  end
+
+  describe '.lib_path' do
+    it 'returns a Pathname' do
+      expect(described_class.lib_path).to be_a(Pathname)
+    end
+
+    it 'points to an existing directory' do
+      expect(described_class.lib_path.directory?).to be true
+    end
+  end
+
+  describe '.missing_binary_message' do
+    it 'returns helpful error message' do
+      message = described_class.missing_binary_message
+      expect(message).to include('cargo build')
+      expect(message).to include('kreuzberg-cli')
+    end
+  end
+end