xmp_toolkit_ruby 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7aee0acc492647a8dba0533d35958329a0a3778b46d57788c351de5aeadfaa6
-  data.tar.gz: 17a5b39e71708f9d4a6ce25a24e03451fe65bf929f2a46c8d57ac4c320c9c7ff
+  metadata.gz: 79c3338c7bfd4d7b6634b4a07791b21f970c2039e06522b3d465fdf83a114f3c
+  data.tar.gz: 96cba607570ff7fb55c712855bfd6b9696e94149bfc8f94b4b425d5cba474eed
 SHA512:
-  metadata.gz: cdc48bafd443561d8e7b920dfa8a0c50b47f7704ec4e6bcf20c8a7258f65cb8329f8e66956e1aa38099646d26407369a78b18355b0af7b848885090168e67303
-  data.tar.gz: 88658e87bbae1cf9e2f2d43a4a3c73772994c44ee847c3b5523b99e8568630e1b321976d2f8e67088c557231e586ceb88ca20fa7cce88c4f9b32430bdd7a3c84
+  metadata.gz: 705b287f7a933014e54080e6b2668201b4b2815fa1b8cb3d7dc53d13bf717e909627caa29be9fab739b8449b3f7271e9f5d96536c9193165362f94d9938d7eaf
+  data.tar.gz: 925a360cd3f4c733e632020d53fa8251837a62c60a2e3d560bdee3f698d67fe7e6a0174a5b9649499909d382dc905f5af26d67b3dc561274b3da1475e2d90171

data/.clang-format

@@ -0,0 +1,4 @@
+BasedOnStyle: Google
+SortIncludes: false
+IndentWidth: 2
+ColumnLimit: 120

data/CHANGELOG.md

@@ -7,10 +7,42 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-[unreleased]: https://github.com///compare/v0.0.1..HEAD
+[unreleased]: https://github.com///compare/v0.0.2..HEAD
 
 <!-- generated by git-cliff end -->
 
+## [0.1.0] - 2025-06-11
+
+### 🧪 Tests
+
+- Add XMP data extraction tests for various files
+
+### 🔄 Changed
+
+- Added Multiple new Classes and Methods for XMP Metadata Handling
+
+### 🚀 Added
+
+- Add rbs signatures
+- Add localized property retrieval method
+- Add property retrieval method for XMP metadata
+- Enhance XMP file handling with fallback options
+- Enhance XMP file handling and error messaging
+- Add update_meta method for XMP metadata
+- Add metadata retrieval method
+- Add character format mapping and lookup methods
+- Add file_info and packet_info methods
+- Add support for multiple XMP value types
+- Enhance XMP file handling with fine-grained control
+- Enable single property updates in XMP files
+- Enhance SDK initialization with optional path
+- Enhance SDK initialization and termination
+
+### 📝 Docs
+
+- Add docs for simple property and localized property getters
+- Enhance XmpFile class with detailed documentation
+
 ## [0.0.2] - 2025-06-06
 
 ### 🐛 Fixed
@@ -41,5 +73,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release
 
-- [unreleased](https://github.com/dieter-medium/bidi2pdf/compare/v0.0.2..HEAD)
+## Changelog
+
+- [unreleased](https://github.com/dieter-medium/bidi2pdf/compare/v0.1.0..HEAD)
+- [0.1.0](https://github.com/dieter-medium/bidi2pdf/compare/v0.0.2..v0.1.0)
 - [0.0.2](https://github.com/dieter-medium/bidi2pdf/compare/v0.0.1..v0.0.2) 

data/README.md

@@ -214,6 +214,32 @@ XmpToolkitRuby.xmp_to_file(
   new_xmp,
   override: true # Set to false to upsert/merge instead of replacing
 )
+
+# fine-grained control
+
+# if you want to take full control over the SDK lifecycle
+# you can use the XmpToolkitRuby::XmpToolkit module directly:
+XmpToolkitRuby::XmpToolkit.initialize_xmp(XmpToolkitRuby::PLUGINS_PATH)
+# in this case you can call here 
+XmpToolkitRuby::XmpFile.register_namespace XmpToolkitRuby::Namespaces::XMP_NS_PDFUA_ID, "pdfua"
+
+XmpToolkitRuby::XmpFile.with_xmp_file(filename, open_flags: XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_update, :open_use_smart_handler, auto_terminate_toolkit: false)) do |xmp_file|
+  # in case the lifecycle is managed by with_xmp_file
+  XmpToolkitRuby::XmpFile.register_namespace XmpToolkitRuby::Namespaces::XMP_NS_PDFUA_ID, "pdfua"
+
+  xmp_file.update_localized_property schema_ns: XmpToolkitRuby::Namespaces::XMP_NS_DC,
+                                     alt_text_name: "title",
+                                     generic_lang: "en",
+                                     specific_lang: "en-US",
+                                     item_value: "Hello world",
+                                     options: 0
+
+  xmp_file.update_property XmpToolkitRuby::Namespaces::XMP_NS_PDFUA_ID, "part", "1"
+end
+
+# if auto_terminate_toolkit is false, you must call
+XmpToolkitRuby::XmpToolkit.terminate
+# to clean up resources
 ```
 
 If you built the XMP Toolkit yourself or store the plugins elsewhere,
@@ -227,6 +253,109 @@ export XMP_TOOLKIT_PLUGINS_PATH=/path/to/XMP-Toolkit-SDK/XMPFilesPlugins/PDF_Han
 Run your Ruby code or CLI commands in the same shell so this variable is
 visible.
 
+#### Fine-grained Control with `XmpFile`
+
+The `XmpToolkitRuby::XmpFile` class exposes low-level access to XMP metadata files, allowing you to:
+
+- Register new or custom namespaces to extend XMP property support
+- Open files with precise control over file open modes and handlers
+- Update localized properties (e.g., multi-language text with alternatives)
+- Update simple properties in specified namespaces
+- Use blocks to ensure file handles are properly closed and changes saved
+
+In order to work properly you need to ensure the XMP Toolkit is initialized:
+
+```ruby
+XmpToolkitRuby::XmpToolkit.initialize_xmp(XmpToolkitRuby::PLUGINS_PATH)
+```
+
+Alternatively, you can use the `with_xmp_file` method which automatically initializes and terminates the toolkit.
+
+##### Registering a Namespace
+
+Before working with properties in custom or less-common namespaces, you need to register them with a prefix:
+
+```ruby
+XmpToolkitRuby::XmpFile.register_namespace XmpToolkitRuby::Namespaces::XMP_NS_PDFUA_ID, "pdfua"
+```
+
+This allows the SDK to recognize and correctly handle properties within that namespace.
+
+##### Opening a File with Custom Flags
+
+You can open an XMP file with specific flags to control behavior:
+
+- `open_for_update`: Open the file for modifying metadata
+- `open_use_smart_handler`: Use smart handlers for better metadata processing
+
+Flags are combined via the `bitmask_for` helper method:
+
+```ruby
+flags = XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_update, :open_use_smart_handler)
+```
+
+Open the file in a block to ensure safe usage:
+
+```ruby
+XmpToolkitRuby::XmpFile.with_xmp_file(filename, open_flags: flags) do |xmp_file|
+  # work with xmp_file inside this block
+end
+```
+
+##### Updating a Localized Property
+
+Localized properties support multiple language alternatives. Use `update_localized_property` with options:
+
+- `schema_ns`: Namespace URI for the schema (e.g., Dublin Core)
+- `alt_text_name`: The property name that holds alternative texts
+- `generic_lang`: Language tag for the generic language (e.g., `"en"`)
+- `specific_lang`: Specific locale variant (e.g., `"en-US"`)
+- `item_value`: The actual text value to set
+- `options`: Optional flags (typically 0)
+
+Example:
+
+```ruby
+xmp_file.update_localized_property(
+  schema_ns: XmpToolkitRuby::Namespaces::XMP_NS_DC,
+  alt_text_name: "title",
+  generic_lang: "en",
+  specific_lang: "en-US",
+  item_value: "Hello world",
+  options: 0
+)
+```
+
+This sets or updates the localized `"title"` property in English (US).
+
+##### Updating a Simple Property
+
+For simpler property updates without localization, use `update_property`:
+
+```ruby
+xmp_file.update_property(
+  XmpToolkitRuby::Namespaces::XMP_NS_PDFUA_ID,
+  "part",
+  "1"
+)
+```
+
+This updates the `"part"` property within the PDF/UA ID namespace.
+
+---
+
+##### Summary
+
+The fine-grained control API empowers you to work precisely with metadata:
+
+- Register custom namespaces for extended support
+- Open files with control over update modes and handlers
+- Modify localized text properties with language variants
+- Update simple XMP properties by namespace and name
+
+Using these methods allows sophisticated metadata management, crucial for professional publishing, digital asset
+management, or compliance workflows.
+
 ---
 
 ### CLI
@@ -285,3 +414,5 @@ Bug reports and pull requests are welcome on [GitHub](https://github.com/DieterS
 ## License
 
 This project is open source, licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+---

data/ext/xmp_toolkit_ruby/xmp_toolkit.cpp

@@ -1,321 +1,154 @@
 #include "xmp_toolkit.hpp"
 
+#include <mutex>
 
+static std::mutex sdk_init_mutex;
+static bool sdk_initialized = false;
+static bool terminate_registered = false;
 
-bool xmp_meta_error_callback(
-                                       void *             clientContext,
-                                       XMP_ErrorSeverity  severity,
-                                       XMP_Int32          cause,
-                                       XMP_StringPtr      message
-) {
-   const char * sevStr = (severity == kXMPErrSev_Recoverable) ? "RECOVERABLE"
-                         : (severity == kXMPErrSev_OperationFatal)    ? "FATAL OPERATION"
-                            : (severity == kXMPErrSev_FileFatal)         ? "FATAL FILE"
-                                 : (severity == kXMPErrSev_ProcessFatal)      ? "FATAL PROCESS"
-                                                               : "UNKNOWN";
-   std::cerr << "[TXMPMeta " << sevStr << "] "
-             << "Code=0x" << std::hex << cause << std::dec
-             << "  Msg=\"" << (message ? message : "(no detail)") << "\"\n";
-
-   // If it's a recoverable error, return true so XMP can try to continue;
-   // otherwise return false to force an exception back to the caller.
-   return (severity == kXMPErrSev_Recoverable);
+static void terminate_sdk_internal() {
+  std::lock_guard<std::mutex> guard(sdk_init_mutex);
+  if (sdk_initialized) {
+    SXMPFiles::Terminate();
+    SXMPMeta::Terminate();
+    sdk_initialized = false;
+  }
 }
 
-bool xmp_file_error_callback(
- void *             clientContext,
-    XMP_StringPtr      filePath,
-    XMP_ErrorSeverity  severity,
-    XMP_Int32          cause,
-    XMP_StringPtr      message){
-
-    const char * sevStr = (severity == kXMPErrSev_Recoverable) ? "RECOVERABLE"
-                             : (severity == kXMPErrSev_OperationFatal)    ? "FATAL OPERATION"
-                                : (severity == kXMPErrSev_FileFatal)         ? "FATAL FILE"
-                                     : (severity == kXMPErrSev_ProcessFatal)      ? "FATAL PROCESS"
-                                                                   : "UNKNOWN";
+// Register termination at Ruby exit
+static void register_terminate_at_exit() {
+  if (terminate_registered) {
+    return;  // Already registered
+  }
 
-    std::cerr << "[TXMPFiles " << sevStr << "] "
-                  << "file=\"" << (filePath ? filePath : "(null)") << "\"  "
-                  << "cause=0x" << std::hex << cause << std::dec << "\n"
-                  << "    msg=\"" << (message ? message : "(no detail)") << "\"\n";
+  terminate_registered = true;
 
-        // Only attempt recovery if the error is marked recoverable
-        return (severity == kXMPErrSev_Recoverable);
+  rb_set_end_proc([](VALUE) { terminate_sdk_internal(); }, Qnil);
 }
 
-VALUE write_xmp_to_file(int argc, VALUE* argv, VALUE self){
-    VALUE rb_filename, rb_xmp_data, rb_mode_sym;
-    XMP_OptionBits templateFlags = 0;
+static void ensure_sdk_initialized(const char *path) {
+  std::lock_guard<std::mutex> guard(sdk_init_mutex);
 
-    rb_scan_args(argc, argv, "3", &rb_filename, &rb_xmp_data, &rb_mode_sym);
+  if (sdk_initialized) {
+    return;
+  }
 
-    Check_Type(rb_filename, T_STRING);
-    const char* xmpString = NULL;
-    if (!NIL_P(rb_xmp_data)) {
-      Check_Type(rb_xmp_data, T_STRING);
-      xmpString = StringValueCStr(rb_xmp_data);
+  try {
+    if (!SXMPMeta::Initialize()) {
+      rb_raise(rb_eRuntimeError, "Failed to initialize XMP Toolkit metadata");
+      return;
     }
 
-    const char* mode_cstr;
-    if (RB_TYPE_P(rb_mode_sym, T_SYMBOL)) {
-        // Convert symbol to string first
-        VALUE mode_str = rb_sym_to_s(rb_mode_sym);
-        mode_cstr = StringValueCStr(mode_str);
-    } else {
-        // Already a string
-        mode_cstr = StringValueCStr(rb_mode_sym);
-    }
-    bool override;
+    sdk_initialized = true;
+    register_terminate_at_exit();
+
+    XMP_OptionBits options = 0;
+    options |= kXMPFiles_ServerMode;
 
-    if (strcmp(mode_cstr, "upsert") == 0) {
-       templateFlags = kXMPTemplate_AddNewProperties
-                       | kXMPTemplate_ReplaceExistingProperties
-                       | kXMPTemplate_IncludeInternalProperties;
-      override = false;
-    } else if (strcmp(mode_cstr, "override") == 0) {
-      override = true;
+    if (path) {
+      if (!SXMPFiles::Initialize(options, path)) {
+        rb_raise(rb_eRuntimeError, "Failed to initialize XMP Files with plugin path");
+        return;
+      }
     } else {
-       rb_raise(rb_eArgError, "mode must be :upsert or :override (String or Symbol). Got '%s'", mode_cstr);
-       return Qnil; // unreachable, but for clarity
+      if (!SXMPFiles::Initialize(options)) {
+        rb_raise(rb_eRuntimeError, "Failed to initialize XMP Files without plugin path");
+        return;
+      }
     }
 
+    return;
+  } catch (const XMP_Error &e) {
+    rb_raise(rb_eRuntimeError, "XMP Error during initialization: %s", e.GetErrMsg());
+    return;
+  } catch (const std::exception &e) {
+    rb_raise(rb_eRuntimeError, "C++ exception during initialization: %s", e.what());
+    return;
+  } catch (...) {
+    rb_raise(rb_eRuntimeError, "Unknown error during XMP initialization");
+    return;
+  }
+}
 
-    const char* fileName = StringValueCStr(rb_filename);
-
-    bool ok;
-    SXMPFiles xmpFile;
-    SXMPMeta newMeta;
-    SXMPMeta currentMeta;
-    XMP_PacketInfo    xmpPacket;
+VALUE
+is_sdk_initialized(VALUE self) {
+  std::lock_guard<std::mutex> guard(sdk_init_mutex);
+  return sdk_initialized ? Qtrue : Qfalse;
+}
 
-    if (xmpString != NULL) {
-        int i;
-        for (i = 0; i < (long)strlen(xmpString) - 10; i += 10){
-            newMeta.ParseFromBuffer(&xmpString[i], 10, kXMP_ParseMoreBuffers);
-        }
+void ensure_sdk_initialized() {
+  // Look up XmpToolkitRuby::PLUGINS_PATH if defined
+  VALUE xmp_module = rb_const_get(rb_cObject, rb_intern("XmpToolkitRuby"));
+  if (rb_const_defined(xmp_module, rb_intern("PLUGINS_PATH"))) {
+    VALUE plugins_path = rb_const_get(xmp_module, rb_intern("PLUGINS_PATH"));
 
-        newMeta.ParseFromBuffer(&xmpString[i], (XMP_StringLen)strlen(xmpString) - i);
+    if (TYPE(plugins_path) == T_STRING) {
+      const char *path = StringValueCStr(plugins_path);
+      ensure_sdk_initialized(path);
+      return;
     }
+  }
 
-    try {
-        XMP_OptionBits opts = kXMPFiles_OpenForUpdate | kXMPFiles_OpenUseSmartHandler;
-        ok = xmpFile.OpenFile(fileName, kXMP_UnknownFile, opts);
-        if (!ok) {
-            xmpFile.CloseFile();
-
-            opts = kXMPFiles_OpenForUpdate | kXMPFiles_OpenUsePacketScanning;
-            ok   = xmpFile.OpenFile( fileName, kXMP_UnknownFile, opts );
-            if ( ! ok ) {
-                // Neither smart handler nor packet scanning worked
-                xmpFile.CloseFile();
-                return Qnil;
-            }
-        }
-
-        fprintf(stderr, "Opened file %s for update\n", fileName);
-
-        ok = xmpFile.GetXMP(&currentMeta, 0, &xmpPacket);
-        if (!ok) {
-            xmpFile.CloseFile();
-            return Qnil;
-        }
-
-        XMP_DateTime dt;
-        SXMPUtils::CurrentDateTime(&dt);
-        std::string nowStr;
-        SXMPUtils::ConvertFromDate(dt, &nowStr);
-
-        if (xmpString != NULL){
-          newMeta.SetProperty(kXMP_NS_XMP, "MetadataDate", nowStr.c_str());
-        }
-
-        std::string newBuffer;
-        if (override) {
-
-           if (xmpFile.CanPutXMP(newMeta) ) {
-              xmpFile.PutXMP(newMeta);
-           } else {
-               xmpFile.CloseFile();
-
-               newMeta.SerializeToBuffer(&newBuffer);
-
-               rb_raise(rb_eArgError, "Can't update XMP new Data: '%s'", newBuffer.c_str());
-
-               return Qnil;
-           }
-        } else {
-            SXMPUtils::ApplyTemplate(
-                &currentMeta,
-                newMeta,
-                templateFlags
-            );
-
-            if (xmpFile.CanPutXMP(currentMeta) ) {
-               xmpFile.PutXMP(currentMeta);
-             } else {
-               xmpFile.CloseFile();
-
-               currentMeta.SerializeToBuffer(&newBuffer);
-
-               rb_raise(rb_eArgError, "Can't update XMP new Data: '%s'", newBuffer.c_str());
-
-               return Qnil;
-             }
-        }
-
-
-
+  ensure_sdk_initialized(nullptr);
 
-        xmpFile.CloseFile();
-    }
-    catch (XMP_Error& e) {
-        xmpFile.CloseFile();
-        rb_raise(rb_eRuntimeError, "XMP Error: %s", e.GetErrMsg());
-        return Qnil;
-    }
-    catch (...) {
-        xmpFile.CloseFile();
-        rb_raise(rb_eRuntimeError, "Unknown error processing XMP file");
-        return Qnil;
-    }
-
-    return Qnil;
+  return;
 }
 
-VALUE get_xmp_from_file(VALUE self, VALUE rb_filename)
-{
-    Check_Type(rb_filename, T_STRING);
-    const char* fileName = StringValueCStr(rb_filename);
-
-    bool ok;
-    SXMPMeta    xmpMeta;
-    SXMPFiles   xmpFile;
-    XMP_FileFormat    format;
-    XMP_OptionBits    openFlags, handlerFlags;
-    XMP_PacketInfo    xmpPacket;
-
-    try {
-        XMP_OptionBits opts = kXMPFiles_OpenForRead | kXMPFiles_OpenUseSmartHandler;
-        ok = xmpFile.OpenFile(fileName, kXMP_UnknownFile, opts);
-        if (!ok) {
-            xmpFile.CloseFile();
-
-            opts = kXMPFiles_OpenForRead | kXMPFiles_OpenUsePacketScanning;
-            ok   = xmpFile.OpenFile( fileName, kXMP_UnknownFile, opts );
-            if ( ! ok ) {
-                // Neither smart handler nor packet scanning worked
-                xmpFile.CloseFile();
-                return Qnil;
-            }
-        }
-
-        ok = xmpFile.GetFileInfo(0, &openFlags, &format, &handlerFlags);
-        if (!ok) {
-            xmpFile.CloseFile();
-            return Qnil;
-        }
-
-        ok = xmpFile.GetXMP(&xmpMeta, 0, &xmpPacket);
-        if (!ok) {
-            xmpFile.CloseFile();
-            return Qnil;
-        }
-
-        VALUE result = rb_hash_new();
-
-        rb_hash_aset(result,
-                     rb_str_new_cstr("format"),
-                     UINT2NUM(format));
-        rb_hash_aset(result,
-                     rb_str_new_cstr("handler_flags"),
-                     UINT2NUM(handlerFlags));
-        rb_hash_aset(result,
-                     rb_str_new_cstr("offset"),
-                     LONG2NUM(xmpPacket.offset));
-        rb_hash_aset(result,
-                     rb_str_new_cstr("length"),
-                     LONG2NUM(xmpPacket.length));
-
-        std::string xmpString;
-        xmpMeta.SerializeToBuffer(&xmpString);
-        rb_hash_aset(result,
-                     rb_str_new_cstr("xmp_data"),
-                     rb_str_new_cstr(xmpString.c_str()));
+bool xmp_meta_error_callback(void *clientContext, XMP_ErrorSeverity severity, XMP_Int32 cause, XMP_StringPtr message) {
+  const char *sevStr = (severity == kXMPErrSev_Recoverable)      ? "RECOVERABLE"
+                       : (severity == kXMPErrSev_OperationFatal) ? "FATAL OPERATION"
+                       : (severity == kXMPErrSev_FileFatal)      ? "FATAL FILE"
+                       : (severity == kXMPErrSev_ProcessFatal)   ? "FATAL PROCESS"
+                                                                 : "UNKNOWN";
+  std::cerr << "[TXMPMeta " << sevStr << "] "
+            << "Code=0x" << std::hex << cause << std::dec << "  Msg=\"" << (message ? message : "(no detail)")
+            << "\"\n";
+
+  // If it's a recoverable error, return true so XMP can try to continue;
+  // otherwise return false to force an exception back to the caller.
+  return (severity == kXMPErrSev_Recoverable);
+}
 
-        xmpFile.CloseFile();
-        return result;
-    }
-    catch (XMP_Error& e) {
-        xmpFile.CloseFile();
-        rb_raise(rb_eRuntimeError, "XMP Error: %s", e.GetErrMsg());
-        return Qnil;
-    }
-    catch (...) {
-        xmpFile.CloseFile();
-        rb_raise(rb_eRuntimeError, "Unknown error processing XMP file");
-        return Qnil;
-    }
+bool xmp_file_error_callback(void *clientContext, XMP_StringPtr filePath, XMP_ErrorSeverity severity, XMP_Int32 cause,
+                             XMP_StringPtr message) {
+  const char *sevStr = (severity == kXMPErrSev_Recoverable)      ? "RECOVERABLE"
+                       : (severity == kXMPErrSev_OperationFatal) ? "FATAL OPERATION"
+                       : (severity == kXMPErrSev_FileFatal)      ? "FATAL FILE"
+                       : (severity == kXMPErrSev_ProcessFatal)   ? "FATAL PROCESS"
+                                                                 : "UNKNOWN";
+
+  std::cerr << "[TXMPFiles " << sevStr << "] "
+            << "file=\"" << (filePath ? filePath : "(null)") << "\"  "
+            << "cause=0x" << std::hex << cause << std::dec << "\n"
+            << "    msg=\"" << (message ? message : "(no detail)") << "\"\n";
+
+  // Only attempt recovery if the error is marked recoverable
+  return (severity == kXMPErrSev_Recoverable);
 }
 
-// xmp_initialize(self, filename)
+// xmp_initialize(self)
 // Initialize the XMP Toolkit and SXMPFiles with an optional PLUGINS_PATH
-VALUE xmp_initialize(VALUE self)
-{
-    try {
-        if (!SXMPMeta::Initialize()) {
-            rb_raise(rb_eRuntimeError, "Failed to initialize XMP Toolkit metadata");
-            return Qnil;
-        }
+VALUE
+xmp_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE rb_path_arg = Qnil;
 
-        // Look up XmpToolkitRuby::PLUGINS_PATH if defined
-        VALUE xmp_module = rb_const_get(rb_cObject, rb_intern("XmpToolkitRuby"));
-        if (rb_const_defined(xmp_module, rb_intern("PLUGINS_PATH"))) {
-            VALUE plugins_path = rb_const_get(xmp_module, rb_intern("PLUGINS_PATH"));
+  rb_scan_args(argc, argv, "01", &rb_path_arg);
 
-            if (TYPE(plugins_path) == T_STRING) {
-                const char* path = StringValueCStr(plugins_path);
-                XMP_OptionBits options = 0;
-                options |= kXMPFiles_ServerMode;
+  if (rb_path_arg != Qnil) {
+    Check_Type(rb_path_arg, T_STRING);
+    const char *path = StringValueCStr(rb_path_arg);
 
-                if (!SXMPFiles::Initialize(options, path)) {
-                    rb_raise(rb_eRuntimeError, "Failed to initialize XMP Files with plugin path");
-                    return Qnil;
-                }
-            }
-            else {
-                if (!SXMPFiles::Initialize()) {
-                    rb_raise(rb_eRuntimeError, "Failed to initialize XMP Files without plugin path");
-                    return Qnil;
-                }
-            }
-        }
-        else {
-            if (!SXMPFiles::Initialize()) {
-                rb_raise(rb_eRuntimeError, "Failed to initialize XMP Files (PLUGINS_PATH not defined)");
-                return Qnil;
-            }
-        }
+    ensure_sdk_initialized(path);
 
-        return Qnil;
-    }
-    catch (const XMP_Error& e) {
-        rb_raise(rb_eRuntimeError, "XMP Error during initialization: %s", e.GetErrMsg());
-        return Qnil;
-    }
-    catch (const std::exception& e) {
-        rb_raise(rb_eRuntimeError, "C++ exception during initialization: %s", e.what());
-        return Qnil;
-    }
-    catch (...) {
-        rb_raise(rb_eRuntimeError, "Unknown error during XMP initialization");
-        return Qnil;
-    }
+    return Qnil;
+  }
+
+  ensure_sdk_initialized();
+  return Qnil;
 }
 
-VALUE xmp_terminate(VALUE self)
-{
-    SXMPFiles::Terminate();
-    SXMPMeta::Terminate();
-    return Qnil;
+VALUE
+xmp_terminate(VALUE self) {
+  terminate_sdk_internal();
+  return Qnil;
 }