kreuzberg 4.0.0.rc1 → 4.0.0.rc2

data/lib/kreuzberg/error_context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kreuzberg
+  # ErrorContext module provides access to FFI error introspection functions.
+  # Retrieve the last error code and panic context information from errors.
+  module ErrorContext
+    class << self
+      def last_error_code
+        Kreuzberg._last_error_code_native
+      rescue StandardError
+        0
+      end
+
+      def last_panic_context
+        json_str = Kreuzberg._last_panic_context_json_native
+        return nil unless json_str
+
+        Errors::PanicContext.from_json(json_str)
+      rescue StandardError
+        nil
+      end
+
+      def last_panic_context_json
+        Kreuzberg._last_panic_context_json_native
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/kreuzberg/errors.rb

@@ -1,50 +1,118 @@
-# frozen_string_literal: true
-
-module Kreuzberg
-  module Errors
-    # Base error class for all Kreuzberg errors
-    class Error < StandardError; end
-
-    # Raised when validation fails
-    class ValidationError < Error; end
-
-    # Raised when document parsing fails
-    class ParsingError < Error
-      attr_reader :context
-
-      def initialize(message, context: nil)
-        super(message)
-        @context = context
-      end
-    end
-
-    # Raised when OCR processing fails
-    class OCRError < Error
-      attr_reader :context
-
-      def initialize(message, context: nil)
-        super(message)
-        @context = context
-      end
-    end
-
-    # Raised when a required dependency is missing
-    class MissingDependencyError < Error
-      attr_reader :dependency
-
-      def initialize(message, dependency: nil)
-        super(message)
-        @dependency = dependency
-      end
-    end
-
-    # Raised when an I/O operation fails
-    class IOError < Error; end
-
-    # Raised when plugin operations fail
-    class PluginError < Error; end
-
-    # Raised when an unsupported file format or MIME type is encountered
-    class UnsupportedFormatError < Error; end
-  end
-end
+# frozen_string_literal: true
+
+require 'json'
+
+module Kreuzberg
+  # Error code constants matching kreuzberg-ffi error codes
+  ERROR_CODE_SUCCESS = 0
+  ERROR_CODE_GENERIC = 1
+  ERROR_CODE_PANIC = 2
+  ERROR_CODE_INVALID_ARGUMENT = 3
+  ERROR_CODE_IO = 4
+  ERROR_CODE_PARSING = 5
+  ERROR_CODE_OCR = 6
+  ERROR_CODE_MISSING_DEPENDENCY = 7
+
+  module Errors
+    # Panic context information from FFI error introspection
+    class PanicContext
+      attr_reader :file, :line, :function, :message, :timestamp_secs
+
+      def initialize(file:, line:, function:, message:, timestamp_secs:)
+        @file = file
+        @line = line
+        @function = function
+        @message = message
+        @timestamp_secs = timestamp_secs
+      end
+
+      def to_s
+        "#{file}:#{line}:#{function}: #{message}"
+      end
+
+      def to_h
+        {
+          file:,
+          line:,
+          function:,
+          message:,
+          timestamp_secs:
+        }
+      end
+
+      def self.from_json(json_string)
+        return nil if json_string.nil? || json_string.empty?
+
+        data = JSON.parse(json_string, symbolize_names: true)
+        sliced = data.slice(:file, :line, :function, :message, :timestamp_secs)
+        new(**with_defaults(sliced))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def self.with_defaults(sliced)
+        {
+          file: sliced[:file] || '',
+          line: sliced[:line] || 0,
+          function: sliced[:function] || '',
+          message: sliced[:message] || '',
+          timestamp_secs: sliced[:timestamp_secs] || 0
+        }
+      end
+      private_class_method :with_defaults
+    end
+
+    # Base error class for all Kreuzberg errors
+    class Error < StandardError
+      attr_reader :panic_context, :error_code
+
+      def initialize(message, panic_context: nil, error_code: nil)
+        super(message)
+        @panic_context = panic_context
+        @error_code = error_code
+      end
+    end
+
+    # Raised when validation fails
+    class ValidationError < Error; end
+
+    # Raised when document parsing fails
+    class ParsingError < Error
+      attr_reader :context
+
+      def initialize(message, context: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @context = context
+      end
+    end
+
+    # Raised when OCR processing fails
+    class OCRError < Error
+      attr_reader :context
+
+      def initialize(message, context: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @context = context
+      end
+    end
+
+    # Raised when a required dependency is missing
+    class MissingDependencyError < Error
+      attr_reader :dependency
+
+      def initialize(message, dependency: nil, panic_context: nil, error_code: nil)
+        super(message, panic_context:, error_code:)
+        @dependency = dependency
+      end
+    end
+
+    # Raised when an I/O operation fails
+    class IOError < Error; end
+
+    # Raised when plugin operations fail
+    class PluginError < Error; end
+
+    # Raised when an unsupported file format or MIME type is encountered
+    class UnsupportedFormatError < Error; end
+  end
+end

data/lib/kreuzberg/extraction_api.rb

@@ -1,84 +1,85 @@
-# frozen_string_literal: true
-
-module Kreuzberg
-  module ExtractionAPI
-    def extract_file_sync(path, mime_type: nil, config: nil)
-      opts = normalize_config(config)
-      hash = if mime_type
-               native_extract_file_sync(path.to_s, mime_type.to_s, **opts)
-             else
-               native_extract_file_sync(path.to_s, **opts)
-             end
-      result = Result.new(hash)
-      record_cache_entry!(result, opts)
-      result
-    end
-
-    def extract_bytes_sync(data, mime_type, config: nil)
-      opts = normalize_config(config)
-      hash = native_extract_bytes_sync(data.to_s, mime_type.to_s, **opts)
-      result = Result.new(hash)
-      record_cache_entry!(result, opts)
-      result
-    end
-
-    def batch_extract_files_sync(paths, config: nil)
-      opts = normalize_config(config)
-      hashes = native_batch_extract_files_sync(paths.map(&:to_s), **opts)
-      results = hashes.map { |hash| Result.new(hash) }
-      record_cache_entry!(results, opts)
-      results
-    end
-
-    def extract_file(path, mime_type: nil, config: nil)
-      opts = normalize_config(config)
-      hash = if mime_type
-               native_extract_file(path.to_s, mime_type.to_s, **opts)
-             else
-               native_extract_file(path.to_s, **opts)
-             end
-      result = Result.new(hash)
-      record_cache_entry!(result, opts)
-      result
-    end
-
-    def extract_bytes(data, mime_type, config: nil)
-      opts = normalize_config(config)
-      hash = native_extract_bytes(data.to_s, mime_type.to_s, **opts)
-      result = Result.new(hash)
-      record_cache_entry!(result, opts)
-      result
-    end
-
-    def batch_extract_files(paths, config: nil)
-      opts = normalize_config(config)
-      hashes = native_batch_extract_files(paths.map(&:to_s), **opts)
-      results = hashes.map { |hash| Result.new(hash) }
-      record_cache_entry!(results, opts)
-      results
-    end
-
-    def batch_extract_bytes_sync(data_array, mime_types, config: nil)
-      opts = normalize_config(config)
-      hashes = native_batch_extract_bytes_sync(data_array.map(&:to_s), mime_types.map(&:to_s), **opts)
-      results = hashes.map { |hash| Result.new(hash) }
-      record_cache_entry!(results, opts)
-      results
-    end
-
-    def batch_extract_bytes(data_array, mime_types, config: nil)
-      opts = normalize_config(config)
-      hashes = native_batch_extract_bytes(data_array.map(&:to_s), mime_types.map(&:to_s), **opts)
-      results = hashes.map { |hash| Result.new(hash) }
-      record_cache_entry!(results, opts)
-      results
-    end
-
-    def normalize_config(config)
-      return {} if config.nil?
-      return config if config.is_a?(Hash)
-
-      config.to_h
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Kreuzberg
+  # Provides extraction methods for documents and text.
+  module ExtractionAPI
+    def extract_file_sync(path, mime_type: nil, config: nil)
+      opts = normalize_config(config)
+      hash = if mime_type
+               native_extract_file_sync(path.to_s, mime_type.to_s, **opts)
+             else
+               native_extract_file_sync(path.to_s, **opts)
+             end
+      result = Result.new(hash)
+      record_cache_entry!(result, opts)
+      result
+    end
+
+    def extract_bytes_sync(data, mime_type, config: nil)
+      opts = normalize_config(config)
+      hash = native_extract_bytes_sync(data.to_s, mime_type.to_s, **opts)
+      result = Result.new(hash)
+      record_cache_entry!(result, opts)
+      result
+    end
+
+    def batch_extract_files_sync(paths, config: nil)
+      opts = normalize_config(config)
+      hashes = native_batch_extract_files_sync(paths.map(&:to_s), **opts)
+      results = hashes.map { |hash| Result.new(hash) }
+      record_cache_entry!(results, opts)
+      results
+    end
+
+    def extract_file(path, mime_type: nil, config: nil)
+      opts = normalize_config(config)
+      hash = if mime_type
+               native_extract_file(path.to_s, mime_type.to_s, **opts)
+             else
+               native_extract_file(path.to_s, **opts)
+             end
+      result = Result.new(hash)
+      record_cache_entry!(result, opts)
+      result
+    end
+
+    def extract_bytes(data, mime_type, config: nil)
+      opts = normalize_config(config)
+      hash = native_extract_bytes(data.to_s, mime_type.to_s, **opts)
+      result = Result.new(hash)
+      record_cache_entry!(result, opts)
+      result
+    end
+
+    def batch_extract_files(paths, config: nil)
+      opts = normalize_config(config)
+      hashes = native_batch_extract_files(paths.map(&:to_s), **opts)
+      results = hashes.map { |hash| Result.new(hash) }
+      record_cache_entry!(results, opts)
+      results
+    end
+
+    def batch_extract_bytes_sync(data_array, mime_types, config: nil)
+      opts = normalize_config(config)
+      hashes = native_batch_extract_bytes_sync(data_array.map(&:to_s), mime_types.map(&:to_s), **opts)
+      results = hashes.map { |hash| Result.new(hash) }
+      record_cache_entry!(results, opts)
+      results
+    end
+
+    def batch_extract_bytes(data_array, mime_types, config: nil)
+      opts = normalize_config(config)
+      hashes = native_batch_extract_bytes(data_array.map(&:to_s), mime_types.map(&:to_s), **opts)
+      results = hashes.map { |hash| Result.new(hash) }
+      record_cache_entry!(results, opts)
+      results
+    end
+
+    def normalize_config(config)
+      return {} if config.nil?
+      return config if config.is_a?(Hash)
+
+      config.to_h
+    end
+  end
+end