xmp_toolkit_ruby 0.0.2

data/ext/xmp_toolkit_ruby/xmp_toolkit.cpp

@@ -0,0 +1,321 @@
+#include "xmp_toolkit.hpp"
+
+
+
+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);
+}
+
+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);
+}
+
+VALUE write_xmp_to_file(int argc, VALUE* argv, VALUE self){
+    VALUE rb_filename, rb_xmp_data, rb_mode_sym;
+    XMP_OptionBits templateFlags = 0;
+
+    rb_scan_args(argc, argv, "3", &rb_filename, &rb_xmp_data, &rb_mode_sym);
+
+    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);
+    }
+
+    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;
+
+    if (strcmp(mode_cstr, "upsert") == 0) {
+       templateFlags = kXMPTemplate_AddNewProperties
+                       | kXMPTemplate_ReplaceExistingProperties
+                       | kXMPTemplate_IncludeInternalProperties;
+      override = false;
+    } else if (strcmp(mode_cstr, "override") == 0) {
+      override = true;
+    } else {
+       rb_raise(rb_eArgError, "mode must be :upsert or :override (String or Symbol). Got '%s'", mode_cstr);
+       return Qnil; // unreachable, but for clarity
+    }
+
+
+    const char* fileName = StringValueCStr(rb_filename);
+
+    bool ok;
+    SXMPFiles xmpFile;
+    SXMPMeta newMeta;
+    SXMPMeta currentMeta;
+    XMP_PacketInfo    xmpPacket;
+
+    if (xmpString != NULL) {
+        int i;
+        for (i = 0; i < (long)strlen(xmpString) - 10; i += 10){
+            newMeta.ParseFromBuffer(&xmpString[i], 10, kXMP_ParseMoreBuffers);
+        }
+
+        newMeta.ParseFromBuffer(&xmpString[i], (XMP_StringLen)strlen(xmpString) - i);
+    }
+
+    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;
+             }
+        }
+
+
+
+
+        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;
+}
+
+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()));
+
+        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;
+    }
+}
+
+// xmp_initialize(self, filename)
+// 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;
+        }
+
+        // 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"));
+
+            if (TYPE(plugins_path) == T_STRING) {
+                const char* path = StringValueCStr(plugins_path);
+                XMP_OptionBits options = 0;
+                options |= kXMPFiles_ServerMode;
+
+                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;
+            }
+        }
+
+        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;
+    }
+}
+
+VALUE xmp_terminate(VALUE self)
+{
+    SXMPFiles::Terminate();
+    SXMPMeta::Terminate();
+    return Qnil;
+}

data/ext/xmp_toolkit_ruby/xmp_toolkit.hpp

@@ -0,0 +1,69 @@
+#ifndef XMP_TOOLKIT_HPP
+#define XMP_TOOLKIT_HPP
+
+#include <cstdio>
+#include <vector>
+#include <string>
+#include <cstring>
+
+//#define ENABLE_XMP_CPP_INTERFACE 1
+
+// Must be defined to instantiate template classes
+#define TXMP_STRING_TYPE std::string
+
+// Must be defined to give access to XMPFiles
+#define XMP_INCLUDE_XMPFILES 1
+
+// Ensure XMP templates are instantiated
+#include "XMP.incl_cpp"
+
+// Provide access to the API
+#include "XMP.hpp"
+
+#include <iostream>
+#include <fstream>
+
+#include <ruby.h>
+
+using namespace std;
+
+//#define ENABLE_XMP_CPP_INTERFACE 1;
+
+// Must be defined to instantiate template classes
+#define TXMP_STRING_TYPE std::string
+// Must be defined to give access to XMPFiles
+#define XMP_INCLUDE_XMPFILES 1
+
+#include "XMP.incl_cpp"
+#include "XMP.hpp"
+
+// TXMPMeta‐style error callback
+bool xmp_meta_error_callback(
+    void *             clientContext,
+    XMP_ErrorSeverity  severity,
+    XMP_Int32          cause,
+    XMP_StringPtr      message
+);
+
+// TXMPFiles‐style error callback
+bool xmp_file_error_callback(
+    void *             clientContext,
+    XMP_StringPtr      filePath,
+    XMP_ErrorSeverity  severity,
+    XMP_Int32          cause,
+    XMP_StringPtr      message
+);
+
+// Initialize SXMPMeta + SXMPFiles, installing callbacks.
+// Returns Qtrue or raises a Ruby exception.
+VALUE xmp_initialize(VALUE self);
+
+// Terminate SXMPFiles + SXMPMeta.
+VALUE xmp_terminate(VALUE self);
+
+// process_file(filename) → Ruby Hash or nil
+VALUE get_xmp_from_file(VALUE self, VALUE rb_filename);
+
+VALUE write_xmp_to_file(int argc, VALUE* argv, VALUE self);
+
+#endif

data/ext/xmp_toolkit_ruby/xmp_toolkit_ruby.cpp

@@ -0,0 +1,44 @@
+// xmp_init.cpp
+
+#include "xmp_toolkit.hpp"
+#include <ruby.h>
+
+// The one and only Init function.  Ruby will look for Init_xmp_toolkit_ruby
+// because we will (in extconf.rb) build this extension as “xmp_toolkit_ruby.so”.
+extern "C"
+void Init_xmp_toolkit_ruby()
+{
+
+   SXMPMeta::SetDefaultErrorCallback(
+        xmp_meta_error_callback,
+        nullptr,
+        0
+    );
+
+    SXMPFiles::SetDefaultErrorCallback(
+            xmp_file_error_callback,
+            nullptr,
+            0
+   );
+
+   VALUE mXmpToolkitRuby = rb_define_module("XmpToolkitRuby");
+   VALUE mXMPToolkit = rb_define_module_under(mXmpToolkitRuby, "XmpToolkit");
+
+   rb_define_singleton_method(mXMPToolkit,
+                              "initialize_xmp",
+                              RUBY_METHOD_FUNC(xmp_initialize),
+                              0);
+   rb_define_singleton_method(mXMPToolkit,
+                              "terminate",
+                              RUBY_METHOD_FUNC(xmp_terminate),
+                              0);
+   rb_define_singleton_method(mXMPToolkit,
+                              "read_xmp",
+                              RUBY_METHOD_FUNC(get_xmp_from_file),
+                              1);
+ rb_define_singleton_method(mXMPToolkit,
+                              "write_xmp",
+                              RUBY_METHOD_FUNC(write_xmp_to_file),
+                              -1);
+
+}

data/lib/xmp_toolkit_ruby/cli.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module XmpToolkitRuby
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  class CLI < Thor
+    # Ensures that the CLI exits with a non-zero status code on failure.
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "print_xmp FILE_PATH [OUTPUT_FILE_PATH]", "Prints the XMP metadata from a given file. Optionally writes to OUTPUT_FILE_PATH."
+    method_option :raw, type: :boolean, default: false, desc: "Output the original, raw XMP data instead of the cleaned version."
+
+    def print_xmp(file_path, output_file_path = nil)
+      metadata = XmpToolkitRuby.xmp_from_file(file_path)
+      key_to_print = options[:raw] ? "xmp_data_orig" : "xmp_data"
+
+      if metadata && metadata[key_to_print]
+        xmp_content = metadata[key_to_print]
+        if output_file_path
+          begin
+            File.write(output_file_path, xmp_content)
+            puts "XMP Metadata from #{file_path}#{" (raw)" if options[:raw]} written to #{output_file_path}"
+          rescue SystemCallError => e # Catches errors like EACCES, ENOENT etc.
+            raise Thor::Error, "Error writing to output file #{output_file_path}: #{e.message}"
+          end
+        else
+          puts "XMP Metadata for: #{file_path}#{" (raw)" if options[:raw]}"
+          puts xmp_content
+        end
+      else
+        message = "No XMP metadata found (key: #{key_to_print}) or an error occurred for: #{file_path}"
+        raise Thor::Error, message if output_file_path
+
+        puts message
+
+      end
+    rescue XmpToolkitRuby::FileNotFoundError => e
+      raise Thor::Error, "Error: #{e.message}"
+    rescue StandardError => e
+      raise Thor::Error, "An unexpected error occurred: #{e.message}"
+    end
+
+    desc "override_xmp FILE_PATH XML_FILE_PATH", "Overrides or merges XMP metadata in FILE_PATH with content from XML_FILE_PATH."
+    long_desc <<-LONGDESC
+      This command will either replace or merge the XMP metadata in FILE_PATH
+      with the XMP metadata provided in XML_FILE_PATH.
+
+      When using --no-override (the default), new properties are added and existing ones updated.
+      When using --override, all existing XMP metadata is replaced with the new content.
+
+      The content of XML_FILE_PATH will be validated as XML before attempting to write.
+    LONGDESC
+    method_option :override, type: :boolean, default: false, desc: "Completely replace existing XMP instead of merging"
+
+    def override_xmp(file_path, xml_file_path)
+      raise Thor::Error, "XML file not found: #{xml_file_path}" unless File.exist?(xml_file_path)
+      raise Thor::Error, "XML file is not readable: #{xml_file_path}" unless File.readable?(xml_file_path)
+
+      xml_content = File.read(xml_file_path)
+
+      # Validate XML
+      doc = Nokogiri::XML(xml_content) do |config|
+        config.strict.nonet # More secure parsing options
+      end
+
+      unless doc.errors.empty?
+        error_messages = doc.errors.map(&:message).join("\n - ")
+        raise Thor::Error, "Invalid XML in #{xml_file_path}:\n - #{error_messages}"
+      end
+
+      # The XmpToolkitRuby.xmp_to_file method itself will call check_file! for file_path
+      XmpToolkitRuby.xmp_to_file(file_path, xml_content, override: options[:override])
+
+      mode = options[:override] ? "overrode" : "merged"
+      puts "Successfully #{mode} XMP metadata in #{file_path} with content from #{xml_file_path}."
+    rescue XmpToolkitRuby::FileNotFoundError => e
+      raise Thor::Error, "Error: #{e.message}"
+    rescue Thor::Error # Re-raise Thor errors directly
+      raise
+    rescue StandardError => e
+      raise Thor::Error, "An unexpected error occurred: #{e.message}\n#{e.backtrace.join("\n")}"
+    end
+
+    desc "version", "Show xmp_toolkit_ruby version"
+
+    def version
+      puts "xmp_toolkit_ruby version #{XmpToolkitRuby::VERSION}"
+    end
+  end
+
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+end

data/lib/xmp_toolkit_ruby/namespaces.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module XmpToolkitRuby
+  module Namespaces
+    XMP_NS_XMP = "http://ns.adobe.com/xap/1.0/"
+
+    XMP_NS_XMP_RIGHTS = "http://ns.adobe.com/xap/1.0/rights/"
+    XMP_NS_XMP_MM = "http://ns.adobe.com/xap/1.0/mm/"
+    XMP_NS_XMP_BJ = "http://ns.adobe.com/xap/1.0/bj/"
+
+    XMP_NS_PDF = "http://ns.adobe.com/pdf/1.3/"
+    XMP_NS_PHOTOSHOP = "http://ns.adobe.com/photoshop/1.0/"
+    XMP_NS_PSALBUM = "http://ns.adobe.com/album/1.0/"
+    XMP_NS_EXIF = "http://ns.adobe.com/exif/1.0/"
+    XMP_NS_EXIF_AUX = "http://ns.adobe.com/exif/1.0/aux/"
+    XMP_NS_TIFF = "http://ns.adobe.com/tiff/1.0/"
+    XMP_NS_PNG = "http://ns.adobe.com/png/1.0/"
+    XMP_NS_SWF = "http://ns.adobe.com/swf/1.0/"
+    XMP_NS_JPEG = "http://ns.adobe.com/jpeg/1.0/"
+    XMP_NS_JP2K = "http://ns.adobe.com/jp2k/1.0/"
+    XMP_NS_CAMERA_RAW = "http://ns.adobe.com/camera-raw-settings/1.0/"
+    XMP_NS_DM = "http://ns.adobe.com/xmp/1.0/DynamicMedia/"
+    XMP_NS_SCRIPT = "http://ns.adobe.com/xmp/1.0/Script/"
+    XMP_NS_ASF = "http://ns.adobe.com/asf/1.0/"
+    XMP_NS_WAV = "http://ns.adobe.com/xmp/wav/1.0/"
+    XMP_NS_BWF = "http://ns.adobe.com/bwf/bext/1.0/"
+    XMP_NS_AESCART = "http://ns.adobe.com/aes/cart/"
+    XMP_NS_RIFFINFO = "http://ns.adobe.com/riff/info/"
+    XMP_NS_IXML = "http://ns.adobe.com/ixml/1.0/"
+    XMP_NS_XMP_NOTE = "http://ns.adobe.com/xmp/note/"
+
+    XMP_NS_ADOBE_STOCK_PHOTO = "http://ns.adobe.com/StockPhoto/1.0/"
+    XMP_NS_CREATOR_ATOM = "http://ns.adobe.com/creatorAtom/1.0/"
+
+    XMP_NS_EXIF_EX = "http://cipa.jp/exif/1.0/"
+
+    XMP_NS_XMP_IDENTIFIER_QUAL = "http://ns.adobe.com/xmp/Identifier/qual/1.0/"
+    XMP_NS_XMP_DIMENSIONS = "http://ns.adobe.com/xap/1.0/sType/Dimensions#"
+    XMP_NS_XMP_TEXT = "http://ns.adobe.com/xap/1.0/t/"
+    XMP_NS_XMP_PAGED_FILE = "http://ns.adobe.com/xap/1.0/t/pg/"
+    XMP_NS_XMP_GRAPHICS = "http://ns.adobe.com/xap/1.0/g/"
+    XMP_NS_XMP_IMAGE = "http://ns.adobe.com/xap/1.0/g/img/"
+    XMP_NS_XMP_FONT = "http://ns.adobe.com/xap/1.0/sType/Font#"
+    XMP_NS_XMP_RESOURCE_EVENT = "http://ns.adobe.com/xap/1.0/sType/ResourceEvent#"
+    XMP_NS_XMP_RESOURCE_REF = "http://ns.adobe.com/xap/1.0/sType/ResourceRef#"
+    XMP_NS_XMP_ST_VERSION = "http://ns.adobe.com/xap/1.0/sType/Version#"
+    XMP_NS_XMP_ST_JOB = "http://ns.adobe.com/xap/1.0/sType/Job#"
+    XMP_NS_XMP_MANIFEST_ITEM = "http://ns.adobe.com/xap/1.0/sType/ManifestItem#"
+
+    # Deprecated XML namespace constants
+    XMP_NS_XMP_T = "http://ns.adobe.com/xap/1.0/t/"
+    XMP_NS_XMP_T_PG = "http://ns.adobe.com/xap/1.0/t/pg/"
+    XMP_NS_XMP_G_IMG = "http://ns.adobe.com/xap/1.0/g/img/"
+
+    XMP_NS_DC = "http://purl.org/dc/elements/1.1/"
+
+    XMP_NS_IPTC_CORE = "http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/"
+    XMP_NS_IPTC_EXT = "http://iptc.org/std/Iptc4xmpExt/2008-02-29/"
+
+    XMP_NS_DICOM = "http://ns.adobe.com/DICOM/"
+
+    XMP_NS_PLUS = "http://ns.useplus.org/ldf/xmp/1.0/"
+
+    XMP_NS_PDFA_SCHEMA = "http://www.aiim.org/pdfa/ns/schema#"
+    XMP_NS_PDFA_PROPERTY = "http://www.aiim.org/pdfa/ns/property#"
+    XMP_NS_PDFA_TYPE = "http://www.aiim.org/pdfa/ns/type#"
+    XMP_NS_PDFA_FIELD = "http://www.aiim.org/pdfa/ns/field#"
+    XMP_NS_PDFA_ID = "http://www.aiim.org/pdfa/ns/id/"
+    XMP_NS_PDFA_EXTENSION = "http://www.aiim.org/pdfa/ns/extension/"
+
+    XMP_NS_PDFX = "http://ns.adobe.com/pdfx/1.3/"
+    XMP_NS_PDFX_ID = "http://www.npes.org/pdfx/ns/id/"
+
+    XMP_NS_RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    XMP_NS_XML = "http://www.w3.org/XML/1998/namespace"
+  end
+end

data/lib/xmp_toolkit_ruby/plugins/LICENSE

@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Adobe
+All rights reserved.
+
+See: https://github.com/adobe/XMP-Toolkit-SDK
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/xmp_toolkit_ruby/plugins/PDF_Handler/i80386linux/i80386linux/PDF_Handler.resources/MODULE_IDENTIFIER.txt

@@ -0,0 +1 @@
+com.adobe.XMP.plugins.MiniPDFL

data/lib/xmp_toolkit_ruby/plugins/PDF_Handler/i80386linux/i80386linux/PDF_Handler.resources/XMPPLUGINUIDS.txt

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<PluginResource Architecture="x86">
+	<Handler
+		Name="adobe.coretech.xmp.minipdfl"
+		Version="1.00"
+		HandlerType="OwningHandler"
+		>
+		<CheckFormat
+			Offset="0"
+			Length="4"
+			ByteSeq="%PDF"
+		/>
+		<Extensions>
+			<Extension Name="pdf" />
+			<Extension Name="pdfl" />
+		</Extensions>
+		<HandlerFlags>
+			<HandlerFlag Name="kXMPFiles_CanInjectXMP" />
+			<HandlerFlag Name="kXMPFiles_CanExpand" />
+			<HandlerFlag Name="kXMPFiles_CanRewrite" />
+			<HandlerFlag Name="kXMPFiles_AllowsOnlyXMP" />
+			<HandlerFlag Name="kXMPFiles_ReturnsRawPacket" />
+			<HandlerFlag Name="kXMPFiles_HandlerOwnsFile" />
+			<HandlerFlag Name="kXMPFiles_AllowsSafeUpdate" />
+			<HandlerFlag Name="kXMPFiles_NeedsPreloading" />
+		</HandlerFlags>
+		<SerializeOptions>
+			<SerializeOption Name="kXMP_OmitPacketWrapper" />
+		</SerializeOptions>
+	</Handler>
+</PluginResource>

data/lib/xmp_toolkit_ruby/plugins/PDF_Handler/i80386linux/i80386linux_x64/PDF_Handler.resources/MODULE_IDENTIFIER.txt

@@ -0,0 +1 @@
+com.adobe.XMP.plugins.MiniPDFL