xmp_toolkit_ruby 0.0.2 → 0.1.0

data/lib/xmp_toolkit_ruby/xmp_file.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module XmpToolkitRuby
+  require_relative "xmp_file_open_flags"
+
+  # XmpFile provides a high-level Ruby interface for managing XMP metadata
+  # in files such as JPEG, TIFF, PNG, and PDF. It wraps the underlying
+  # Adobe XMP SDK calls, offering simplified methods to open, read, update,
+  # and write XMP packets, as well as to retrieve file and packet information.
+  #
+  # == Core Features
+  # - Open files for read or update, with optional fallback flags
+  # - Read raw and parsed XMP metadata
+  # - Update metadata by bulk XML or by individual property/schema
+  # - Write changes back to the file
+  # - Retrieve file-level info (format, handler flags, open flags)
+  # - Retrieve packet-level info (packet size, padding)
+  # - Support for localized text properties (alt-text arrays)
+  #
+  # @example Read and print XMP data:
+  #   XmpFile.with_xmp_file("image.jpg") do |xmp|
+  #     p xmp.meta["xmp_data"]
+  #   end
+  #
+  # @example Update a custom property:
+  #   XmpFile.with_xmp_file("doc.pdf", open_flags: XmpFileOpenFlags::OPEN_FOR_UPDATE) do |xmp|
+  #     new_xml = '<x:xmpmeta xmlns:x="adobe:ns:meta/">...'</x>
+  #     xmp.update_meta(new_xml)
+  #   end
+  class XmpFile
+    # Path to the file on disk containing XMP metadata.
+    # @return [String]
+    attr_reader :file_path
+
+    # Flags used for the primary open operation. See XmpFileOpenFlags.
+    # @return [Integer]
+    attr_reader :open_flags
+
+    # Optional fallback flags if opening with primary flags fails.
+    # @return [Integer, nil]
+    attr_reader :fallback_flags
+
+    class << self
+      # Register a custom namespace URI for subsequent property operations.
+      #
+      # @param namespace [String] Full URI of the namespace, e.g. "http://ns.adobe.com/photoshop/1.0/"
+      # @param suggested_prefix [String] Short prefix to use in XML (e.g. "photoshop").
+      # @return [String] The actual prefix registered by the SDK.
+      # @raise [RuntimeError] if the XMP toolkit has not been initialized.
+      def register_namespace(namespace, suggested_prefix)
+        warn "XMP Toolkit not initialized; loading default plugins from \#{XmpToolkitRuby::PLUGINS_PATH}" unless XmpToolkitRuby::XmpToolkit.initialized?
+        XmpWrapper.register_namespace(namespace, suggested_prefix)
+      end
+
+      # Open a file with XMP support, yielding a managed XmpFile instance.
+      # This method ensures the XMP toolkit is initialized and terminated,
+      # and that the file is closed and written (if modified).
+      #
+      # @param file_path [String] Path to the target file.
+      # @param open_flags [Integer] Bitmask from XmpFileOpenFlags (default: OPEN_FOR_READ).
+      # @param plugin_path [String] Directory of XMP SDK plugins (default: PLUGINS_PATH).
+      # @param fallback_flags [Integer, nil] Alternate flags if primary fails.
+      # @param auto_terminate_toolkit [Boolean] Shutdown toolkit after block (default: true).
+      # @yield [xmp_file] Gives an XmpFile instance for metadata operations.
+      # @yieldparam xmp_file [XmpFile]
+      # @return [void]
+      # @raise [IOError] if file open fails and no fallback succeeds.
+      def with_xmp_file(
+        file_path,
+        open_flags: XmpFileOpenFlags::OPEN_FOR_READ,
+        plugin_path: XmpToolkitRuby::PLUGINS_PATH,
+        fallback_flags: nil,
+        auto_terminate_toolkit: true
+      )
+        XmpToolkitRuby.check_file!(file_path,
+                                   need_to_read: true,
+                                   need_to_write: XmpFileOpenFlags.contains?(open_flags, :open_for_update))
+
+        XmpToolkitRuby::XmpToolkit.initialize_xmp(plugin_path) unless XmpToolkitRuby.sdk_initialized?
+
+        xmp_file = new(file_path,
+                       open_flags: open_flags,
+                       fallback_flags: fallback_flags)
+        xmp_file.open
+        yield xmp_file
+      ensure
+        xmp_file.write if xmp_file && XmpFileOpenFlags.contains?(xmp_file.open_flags, :open_for_update)
+        xmp_file&.close
+        XmpToolkitRuby::XmpToolkit.terminate if auto_terminate_toolkit && XmpToolkitRuby.sdk_initialized?
+      end
+    end
+
+    # Initialize an XmpFile for a given path.
+    #
+    # @param file_path [String,Pathname] Local file path to open.
+    # @param open_flags [Integer] XmpFileOpenFlags bitmask (default: OPEN_FOR_READ).
+    # @param fallback_flags [Integer,nil] Alternate flags on failure.
+    # @raise [ArgumentError] if file_path is not readable.
+    # @example
+    #   XmpFile.new("photo.tif", open_flags: XmpFileOpenFlags::OPEN_FOR_UPDATE)
+    def initialize(file_path, open_flags: XmpFileOpenFlags::OPEN_FOR_READ, fallback_flags: nil)
+      @file_path = file_path.to_s
+      raise ArgumentError, "File path '#{@file_path}' must exist and be readable" unless File.readable?(@file_path)
+
+      @open_flags = open_flags
+      @fallback_flags = fallback_flags
+      @open = false
+      @xmp_wrapper = XmpWrapper.new
+    end
+
+    # Open the file for XMP operations.
+    # If initialization flags fail and fallback_flags is provided,
+    # attempts a second open with fallback flags.
+    #
+    # @return [void]
+    # @raise [IOError] if both primary and fallback open(...) fail.
+    # @note Emits warning if toolkit not initialized.
+    def open
+      return if open?
+
+      warn "XMP Toolkit not initialized; using default plugin path" unless XmpToolkitRuby::XmpToolkit.initialized?
+
+      begin
+        @xmp_wrapper.open(file_path, open_flags).tap { @open = true }
+      rescue IOError => e
+        @xmp_wrapper.close
+        @open = false
+        raise e unless fallback_flags
+
+        @xmp_wrapper.open(file_path, fallback_flags).tap { @open = true }
+      end
+    end
+
+    # @return [Boolean] Whether the file is currently open for XMP operations.
+    def open?
+      @open
+    end
+
+    # Retrieve a hash of file-level metadata and flags.
+    #
+    # @return [Hash{String=>Object}]
+    # @example
+    #   info = xmp.file_info
+    #   puts "Format: #{info['format']}"
+    def file_info
+      @file_info ||= begin
+                       info = @xmp_wrapper.file_info
+                       {
+                         "handler_flags" => XmpToolkitRuby::XmpFileHandlerFlags.flags_for(info["handler_flags"]),
+                         "handler_flags_orig" => info["handler_flags"],
+                         "format" => XmpToolkitRuby::XmpFileFormat.name_for(info["format"]),
+                         "format_orig" => info["format"],
+                         "open_flags" => XmpToolkitRuby::XmpFileOpenFlags.flags_for(info["open_flags"]),
+                         "open_flags_orig" => info["open_flags"]
+                       }
+                     end
+    end
+
+    # Retrieve low-level packet information (size, offset, padding).
+    #
+    # @return [Hash] Raw packet info as provided by the SDK.
+    def packet_info
+      @packet_info ||= @xmp_wrapper.packet_info
+    end
+
+    # Get parsed XMP metadata and packet boundaries.
+    #
+    # @return [Hash]
+    #   - "begin" [String]: Packet start marker timestamp
+    #   - "packet_id" [String]: Unique XMP packet ID
+    #   - "xmp_data" [String]: Inner RDF/XML content
+    #   - "xmp_data_orig" [String]: Full packet including processing instruction
+    #  rubocop:disable Metrics/AbcSize
+    def meta
+      raw = @xmp_wrapper.meta
+      return {} if raw.nil? || raw.empty?
+
+      doc = Nokogiri::XML(raw)
+      pis = doc.xpath("//processing-instruction('xpacket')")
+      begin_pi = pis.detect { |pi| pi.content.start_with?("begin=") }
+      attrs = begin_pi.content.scan(/(\w+)="([^"]*)"/).to_h
+      pis.remove
+
+      {
+        "begin" => attrs["begin"],
+        "packet_id" => attrs["id"],
+        "xmp_data" => doc.root.to_xml,
+        "xmp_data_orig" => raw
+      }
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    # Persist all pending XMP updates to the file.
+    #
+    # @raise [RuntimeError] unless file is open.
+    # @return [void]
+    def write
+      raise "File not open; cannot write" unless open?
+
+      @xmp_wrapper.write
+    end
+
+    # Bulk update XMP metadata using an RDF/XML string.
+    #
+    # @param xmp_data [String] Full RDF/XML payload or fragment
+    # @param mode [Symbol] :upsert (default) or :replace
+    # @return [void]
+    def update_meta(xmp_data, mode: :upsert)
+      open
+      @xmp_wrapper.update_meta(xmp_data, mode: mode)
+    end
+
+    # Update a single property in the XMP schema.
+    #
+    # @param namespace [String] Schema namespace URI
+    # @param property [String] Qualified property name (without prefix)
+    # @param value [String] New value for the property
+    # @return [void]
+    def update_property(namespace, property, value)
+      open
+      @xmp_wrapper.update_property(namespace, property, value)
+    end
+
+    # Retrieve the value of a simple XMP property.
+    #
+    # This will open the file (if not already open), query the underlying
+    # SDK for the given namespace + property, and return whatever value is stored.
+    #
+    # @param namespace [String] Namespace URI of the schema (e.g. "http://ns.adobe.com/photoshop/1.0/")
+    # @param property [String] Property name (without prefix), e.g. "CreatorTool"
+    # @return [String, nil] The value of the property, or nil if not set
+    # @raise [RuntimeError] if the file cannot be opened
+    def property(namespace, property)
+      open
+      @xmp_wrapper.property(namespace, property)
+    end
+
+    # Retrieve a localized (alt-text) value from an XMP array.
+    #
+    # Locates the alt-text array identified by
+    # `alt_text_name` in the given `schema_ns`, then returns the string
+    # matching the requested generic and specific language codes.
+    #
+    # @param schema_ns [String] Namespace URI of the alt-text schema
+    # @param alt_text_name [String] The name of the localized text array
+    # @param generic_lang [String] Base language code (e.g. "en")
+    # @param specific_lang [String] Locale variant (e.g. "en-US")
+    # @return [String, nil] The localized string for that locale, or nil if not found
+    # @raise [RuntimeError] if the file cannot be opened
+    def localized_property(schema_ns:, alt_text_name:, generic_lang:, specific_lang:)
+      open
+
+      @xmp_wrapper.localized_property(
+        schema_ns: schema_ns,
+        alt_text_name: alt_text_name,
+        generic_lang: generic_lang,
+        specific_lang: specific_lang
+      )
+    end
+
+    # Update an alternative-text (localized string) property.
+    #
+    # @param schema_ns [String] Namespace URI of the alt-text schema
+    # @param alt_text_name [String] Name of the alt-text array
+    # @param generic_lang [String] Base language (e.g. "en")
+    # @param specific_lang [String] Specific locale (e.g. "en-US")
+    # @param item_value [String] Localized string value
+    # @param options [Integer] Bitmask for array operations (see SDK)
+    # @return [void]
+    def update_localized_property(schema_ns:, alt_text_name:, generic_lang:, specific_lang:, item_value:, options:)
+      open
+      @xmp_wrapper.update_localized_property(
+        schema_ns: schema_ns,
+        alt_text_name: alt_text_name,
+        generic_lang: generic_lang,
+        specific_lang: specific_lang,
+        item_value: item_value,
+        options: options
+      )
+    end
+
+    # Close the file and clear internal state.
+    # @return [void]
+    def close
+      return unless open?
+
+      @open = false
+      @xmp_wrapper.close
+    end
+
+    private
+
+    # Internal helper to map raw handler flags to named symbols.
+    #
+    # @param handler_flags [Integer,nil]
+    # @return [Hash]
+    # @api private
+    def map_handler_flags(handler_flags)
+      return {} if handler_flags.nil?
+
+      {
+        "handler_flags" => XmpToolkitRuby::XmpFileHandlerFlags.flags_for(handler_flags),
+        "handler_flags_orig" => handler_flags
+      }
+    end
+  end
+end

data/lib/xmp_toolkit_ruby/xmp_file_open_flags.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module XmpToolkitRuby
+  module XmpFileOpenFlags
+    OPEN_FOR_READ = 0x0000_0001 # Open for read-only access
+    OPEN_FOR_UPDATE = 0x0000_0002 # Open for reading and writing
+    OPEN_ONLY_XMP = 0x0000_0004 # Only the XMP is wanted, allows space/time optimizations
+    FORCE_GIVEN_HANDLER = 0x0000_0008 # Force use of the given handler (format), do not verify format
+    OPEN_STRICTLY = 0x0000_0010 # Strictly use only designated file handler, no fallback
+    OPEN_USE_SMART_HANDLER = 0x0000_0020 # Require the use of a smart handler
+    OPEN_USE_PACKET_SCANNING = 0x0000_0040 # Force packet scanning, do not use smart handler
+    OPEN_LIMITED_SCANNING = 0x0000_0080 # Only scan files "known" to need scanning
+    OPEN_REPAIR_FILE = 0x0000_0100 # Attempt to repair a file opened for update
+    OPTIMIZE_FILE_LAYOUT = 0x0000_0200 # Optimize file layout when updating
+    PRESERVE_PDF_STATE = 0x0000_0400 # Preserve PDF document state when updating
+
+    FLAGS = {
+      open_for_read: OPEN_FOR_READ,
+      open_for_update: OPEN_FOR_UPDATE,
+      open_only_xmp: OPEN_ONLY_XMP,
+      force_given_handler: FORCE_GIVEN_HANDLER,
+      open_strictly: OPEN_STRICTLY,
+      open_use_smart_handler: OPEN_USE_SMART_HANDLER,
+      open_use_packet_scanning: OPEN_USE_PACKET_SCANNING,
+      open_limited_scanning: OPEN_LIMITED_SCANNING,
+      open_repair_file: OPEN_REPAIR_FILE,
+      optimize_file_layout: OPTIMIZE_FILE_LAYOUT,
+      preserve_pdf_state: PRESERVE_PDF_STATE
+    }.freeze
+
+    FLAGS_BY_VALUE = FLAGS.invert.freeze
+
+    class << self
+      def value_for(name)
+        key = name.is_a?(String) ? name.to_sym : name
+        FLAGS[key]
+      end
+
+      def name_for(hex_value)
+        FLAGS_BY_VALUE[hex_value]
+      end
+
+      def flags_for(bitmask)
+        FLAGS.select { |_, bit| bitmask.anybits?(bit) }.keys
+      end
+
+      def contains?(bitmask, flag)
+        raise ArgumentError, "Invalid flag type: #{flag.class}" unless flag.is_a?(Symbol) || flag.is_a?(String)
+
+        bitmask & value_for(flag) != 0
+      end
+
+      # Takes multiple flag names (symbols or strings) or constants,
+      # returns combined bitmask OR-ing all.
+      #
+      # Example:
+      #   bitmask_for(:open_for_read, :force_given_handler)
+      #   bitmask_for(OPEN_FOR_READ, FORCE_GIVEN_HANDLER)
+      def bitmask_for(*args)
+        args.reduce(0) do |mask, flag|
+          val = case flag
+                when Symbol, String then value_for(flag)
+                when Integer then flag
+                else
+                  raise ArgumentError, "Invalid flag type: #{flag.class}"
+                end
+          raise ArgumentError, "Unknown flag: #{flag.inspect}" unless val
+
+          mask | val
+        end
+      end
+    end
+  end
+end

data/lib/xmp_toolkit_ruby/xmp_value.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module XmpToolkitRuby
+  class XmpValue
+    attr_reader :value, :type
+
+    TYPES = %i[string bool int int64 float date].freeze
+
+    def initialize(value, type: nil)
+      @value = value
+      @type = type.to_sym
+
+      raise ArgumentError, "Invalid type: #{type}" unless TYPES.include?(@type)
+    end
+  end
+end

data/lib/xmp_toolkit_ruby.rb

@@ -5,6 +5,7 @@ require_relative "xmp_toolkit_ruby/xmp_toolkit_ruby"
 
 require "nokogiri"
 require "rbconfig"
+require "date"
 
 # The `XmpToolkitRuby` module serves as a Ruby interface to Adobe's XMP Toolkit,
 # a native C++ library. This module allows Ruby applications to read and write
@@ -30,10 +31,14 @@ require "rbconfig"
 #   new_xmp_data = "<x:xmpmeta xmlns:x='adobe:ns:meta/'><rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'></rdf:RDF></x:xmpmeta>"
 #   XmpToolkitRuby.xmp_to_file("path/to/image.jpg", new_xmp_data, override: true)
 #
+# rubocop:disable Metrics/ModuleLength
 module XmpToolkitRuby
   require_relative "xmp_toolkit_ruby/xmp_file_format"
   require_relative "xmp_toolkit_ruby/namespaces"
   require_relative "xmp_toolkit_ruby/xmp_file_handler_flags"
+  require_relative "xmp_toolkit_ruby/xmp_file"
+  require_relative "xmp_toolkit_ruby/xmp_value"
+  require_relative "xmp_toolkit_ruby/xmp_char_form"
 
   # The `PLUGINS_PATH` constant defines the directory where the XMP Toolkit
   # should look for its plugins, particularly the PDF handler.
@@ -96,9 +101,17 @@ module XmpToolkitRuby
       check_file! file_path, need_to_read: true, need_to_write: false
 
       with_init do
-        result = XmpToolkitRuby::XmpToolkit.read_xmp(file_path)
-        result ||= {}
-        result.merge(cleanup_xmp(result["xmp_data"])).merge(map_handler_flags(result["handler_flags"]))
+        XmpToolkitRuby::XmpFile.with_xmp_file(
+          file_path,
+          open_flags: XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_read, :open_use_smart_handler),
+          fallback_flags: XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_read, :open_use_packet_scanning)
+        ) do |xmp_file|
+          file_info = xmp_file.file_info
+          packet_info = xmp_file.packet_info
+          xmp_data = xmp_file.meta
+
+          file_info.merge(packet_info).merge(xmp_data)
+        end
       end
     end
 
@@ -123,24 +136,74 @@ module XmpToolkitRuby
     def xmp_to_file(file_path, xmp_data, override: false)
       check_file! file_path, need_to_read: true, need_to_write: true
 
-      with_init { XmpToolkitRuby::XmpToolkit.write_xmp(file_path, xmp_data, override ? :override : :upsert) }
+      with_init do
+        XmpToolkitRuby::XmpFile.with_xmp_file(
+          file_path,
+          open_flags: XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_update, :open_use_smart_handler),
+          fallback_flags: XmpToolkitRuby::XmpFileOpenFlags.bitmask_for(:open_for_update, :open_use_packet_scanning)
+        ) do |xmp_file|
+          xmp_file.update_meta xmp_data, mode: override ? :override : :upsert
+
+          file_info = xmp_file.file_info
+          packet_info = xmp_file.packet_info
+          xmp_data = xmp_file.meta
+
+          file_info.merge(packet_info).merge(xmp_data)
+        end
+      end
     end
 
     # Ensures the native XMP Toolkit is initialized before executing a block
-    # of code and terminated afterwards. This is crucial for managing the
+    # of code and terminated afterward. This is crucial for managing the
     # lifecycle of the underlying C++ library resources.
     #
     # This method should wrap any calls to the native `XmpToolkitRuby::XmpToolkit` methods.
     #
+    # @param path [String, nil] (nil) Optional path to the XMP Toolkit plugins directory.
+    #   If `nil` or not provided, it defaults to `PLUGINS_PATH`.
     # @yield The block of code to execute while the XMP Toolkit is initialized.
     # @return The result of the yielded block.
-    def with_init(&block)
-      XmpToolkitRuby::XmpToolkit.initialize_xmp
+    def with_init(path = nil, &block)
+      XmpToolkitRuby::XmpToolkit.initialize_xmp(path || PLUGINS_PATH) unless XmpToolkitRuby.sdk_initialized?
+
       block.call
     ensure
       XmpToolkitRuby::XmpToolkit.terminate
     end
 
+    # Checks if the XMP Toolkit SDK has been initialized.
+    # This method is useful for ensuring that the SDK is ready for use
+    #
+    def sdk_initialized?
+      XmpToolkitRuby::XmpToolkit.initialized?
+    end
+
+    # Validates file accessibility before performing read or write operations.
+    #
+    # Checks for:
+    # - Nil file path.
+    # - File existence.
+    # - File readability (if `need_to_read` is true).
+    # - File writability (if `need_to_write` is true).
+    #
+    # @param file_path [String] The path to the file to check.
+    # @param need_to_read [Boolean] (true) Whether the file needs to be readable.
+    # @param need_to_write [Boolean] (false) Whether the file needs to be writable.
+    # @raise [FileNotFoundError] If any of the checks fail.
+    # @return [void]
+    # @api private
+    def check_file!(file_path, need_to_read: true, need_to_write: false)
+      if file_path.nil?
+        raise FileNotFoundError, "File path cannot be nil"
+      elsif !File.exist?(file_path)
+        raise FileNotFoundError, "File not found: #{file_path}"
+      elsif need_to_read && !File.readable?(file_path)
+        raise FileNotFoundError, "File exists but is not readable: #{file_path}"
+      elsif need_to_write && !File.writable?(file_path)
+        raise FileNotFoundError, "File exists but is not writable: #{file_path}"
+      end
+    end
+
     private
 
     # Parses raw XMP data string to extract `xpacket` processing instruction
@@ -207,31 +270,6 @@ module XmpToolkitRuby
     end
 
     # rubocop: enable Metrics/AbcSize, Metrics/MethodLength
-
-    # Validates file accessibility before performing read or write operations.
-    #
-    # Checks for:
-    # - Nil file path.
-    # - File existence.
-    # - File readability (if `need_to_read` is true).
-    # - File writability (if `need_to_write` is true).
-    #
-    # @param file_path [String] The path to the file to check.
-    # @param need_to_read [Boolean] (true) Whether the file needs to be readable.
-    # @param need_to_write [Boolean] (false) Whether the file needs to be writable.
-    # @raise [FileNotFoundError] If any of the checks fail.
-    # @return [void]
-    # @api private
-    def check_file!(file_path, need_to_read: true, need_to_write: false)
-      if file_path.nil?
-        raise FileNotFoundError, "File path cannot be nil"
-      elsif !File.exist?(file_path)
-        raise FileNotFoundError, "File not found: #{file_path}"
-      elsif need_to_read && !File.readable?(file_path)
-        raise FileNotFoundError, "File exists but is not readable: #{file_path}"
-      elsif need_to_write && !File.writable?(file_path)
-        raise FileNotFoundError, "File exists but is not writable: #{file_path}"
-      end
-    end
   end
 end
+# rubocop: enable Metrics/ModuleLength

data/sig/xmp_toolkit_ruby/namespaces.rbs

@@ -0,0 +1,119 @@
+module XmpToolkitRuby
+  module Namespaces
+    XMP_NS_ADOBE_STOCK_PHOTO: ::String
+
+    XMP_NS_AESCART: ::String
+
+    XMP_NS_ASF: ::String
+
+    XMP_NS_BWF: ::String
+
+    XMP_NS_CAMERA_RAW: ::String
+
+    XMP_NS_CREATOR_ATOM: ::String
+
+    XMP_NS_DC: ::String
+
+    XMP_NS_DICOM: ::String
+
+    XMP_NS_DM: ::String
+
+    XMP_NS_EXIF: ::String
+
+    XMP_NS_EXIF_AUX: ::String
+
+    XMP_NS_EXIF_EX: ::String
+
+    XMP_NS_IPTC_CORE: ::String
+
+    XMP_NS_IPTC_EXT: ::String
+
+    XMP_NS_IXML: ::String
+
+    XMP_NS_JP2K: ::String
+
+    XMP_NS_JPEG: ::String
+
+    XMP_NS_PDF: ::String
+
+    XMP_NS_PDFA_EXTENSION: ::String
+
+    XMP_NS_PDFA_FIELD: ::String
+
+    XMP_NS_PDFA_ID: ::String
+
+    XMP_NS_PDFA_PROPERTY: ::String
+
+    XMP_NS_PDFA_SCHEMA: ::String
+
+    XMP_NS_PDFA_TYPE: ::String
+
+    XMP_NS_PDFUA_ID: ::String
+
+    XMP_NS_PDFX: ::String
+
+    XMP_NS_PDFX_ID: ::String
+
+    XMP_NS_PHOTOSHOP: ::String
+
+    XMP_NS_PLUS: ::String
+
+    XMP_NS_PNG: ::String
+
+    XMP_NS_PSALBUM: ::String
+
+    XMP_NS_RDF: ::String
+
+    XMP_NS_RIFFINFO: ::String
+
+    XMP_NS_SCRIPT: ::String
+
+    XMP_NS_SWF: ::String
+
+    XMP_NS_TIFF: ::String
+
+    XMP_NS_WAV: ::String
+
+    XMP_NS_XML: ::String
+
+    XMP_NS_XMP: ::String
+
+    XMP_NS_XMP_BJ: ::String
+
+    XMP_NS_XMP_DIMENSIONS: ::String
+
+    XMP_NS_XMP_FONT: ::String
+
+    XMP_NS_XMP_GRAPHICS: ::String
+
+    XMP_NS_XMP_G_IMG: ::String
+
+    XMP_NS_XMP_IDENTIFIER_QUAL: ::String
+
+    XMP_NS_XMP_IMAGE: ::String
+
+    XMP_NS_XMP_MANIFEST_ITEM: ::String
+
+    XMP_NS_XMP_MM: ::String
+
+    XMP_NS_XMP_NOTE: ::String
+
+    XMP_NS_XMP_PAGED_FILE: ::String
+
+    XMP_NS_XMP_RESOURCE_EVENT: ::String
+
+    XMP_NS_XMP_RESOURCE_REF: ::String
+
+    XMP_NS_XMP_RIGHTS: ::String
+
+    XMP_NS_XMP_ST_JOB: ::String
+
+    XMP_NS_XMP_ST_VERSION: ::String
+
+    XMP_NS_XMP_T: ::String
+
+    XMP_NS_XMP_TEXT: ::String
+
+    XMP_NS_XMP_T_PG: ::String
+  end
+end

data/sig/xmp_toolkit_ruby/xmp_char_form.rbs

@@ -0,0 +1,17 @@
+module XmpToolkitRuby
+  module XmpCharForm
+    # Returns the flags for a given bitmask.
+    def self.flags_for: (Integer bitmask) -> Array[Symbol]
+
+    # Returns the name for a given value.
+    def self.name_for: (Integer value) -> String
+
+    # Returns the value for a given name.
+    def self.value_for: (String name) -> Integer
+
+    # Mapping from character form names to their values.
+    CHAR_FORM: ::Hash[String, Integer]
+
+    # Mapping from character form values to their names.
+    CHAR_FORM_BY_VALUE: ::Hash[Integer, String]
+end