uniword 1.0.0

data/lib/uniword/customxml/prefix_mappings.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Namespace prefix mappings for XPath expressions
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:prefix_mappings>
+    class PrefixMappings < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'prefix_mappings'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/schema_reference.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Schema reference entry (CT_DatastoreSchemaRef)
+    #
+    # Element: <ds:schemaRef>
+    # Namespace: http://schemas.openxmlformats.org/officeDocument/2006/customXml
+    class SchemaRef < Lutaml::Model::Serializable
+      attribute :uri, :string
+
+      xml do
+        element 'schemaRef'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'uri', to: :uri
+      end
+    end
+
+    # Schema references container (CT_DatastoreSchemaRefs)
+    #
+    # Element: <ds:schemaRefs>
+    # Namespace: http://schemas.openxmlformats.org/officeDocument/2006/customXml
+    class SchemaRefs < Lutaml::Model::Serializable
+      attribute :refs, SchemaRef, collection: true, initialize_empty: true
+
+      xml do
+        element 'schemaRefs'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+        mixed_content
+
+        map_element 'schemaRef', to: :refs, render_nil: false
+      end
+    end
+
+    # Backward-compatible alias
+    SchemaReference = SchemaRef
+  end
+end

data/lib/uniword/customxml/showing_placeholder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Flag indicating whether placeholder is displayed
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:showing_plc_hdr>
+    class ShowingPlaceholder < Lutaml::Model::Serializable
+      include Uniword::Properties::BooleanElement
+
+      attribute :val, :string, default: nil
+      include Uniword::Properties::BooleanValSetter
+
+      xml do
+        element 'showing_plc_hdr'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+        map_attribute 'val', to: :val, render_nil: false, render_default: false
+      end
+    end
+  end
+end

data/lib/uniword/customxml/showing_placeholder_header.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Flag indicating whether placeholder header is shown
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:showing_placeholder_header>
+    class ShowingPlaceholderHeader < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'showing_placeholder_header'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Smart tag element for context-aware metadata
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag>
+    class SmartTag < Lutaml::Model::Serializable
+      attribute :uri, :string
+      attribute :element, :string
+      attribute :smart_tag_pr, SmartTagProperties
+      attribute :content, :string, collection: true, initialize_empty: true
+
+      xml do
+        element 'smart_tag'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+        mixed_content
+
+        map_attribute 'uri', to: :uri
+        map_attribute 'element', to: :element
+        map_element 'smartTagPr', to: :smart_tag_pr, render_nil: false
+        map_element '', to: :content, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_attribute.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Attribute for smart tag elements
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_attribute>
+    class SmartTagAttribute < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :val, :string
+
+      xml do
+        element 'smart_tag_attribute'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'name', to: :name
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_element.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Element name for smart tag type
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_element>
+    class SmartTagElement < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'smart_tag_element'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_name.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Name for smart tag type
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_name>
+    class SmartTagName < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'smart_tag_name'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_properties.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Properties for smart tag elements
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_properties>
+    class SmartTagProperties < Lutaml::Model::Serializable
+      attribute :attr, SmartTagAttribute, collection: true, initialize_empty: true
+
+      xml do
+        element 'smart_tag_properties'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+        mixed_content
+
+        map_element 'attr', to: :attr, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Smart tag type definition with namespace and element information
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_type>
+    class SmartTagType < Lutaml::Model::Serializable
+      attribute :namespace_uri, :string
+      attribute :name, :string
+      attribute :url, :string
+
+      xml do
+        element 'smart_tag_type'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'namespaceuri', to: :namespace_uri
+        map_attribute 'name', to: :name
+        map_attribute 'url', to: :url
+      end
+    end
+  end
+end

data/lib/uniword/customxml/smart_tag_uri.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Namespace URI for smart tag
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:smart_tag_uri>
+    class SmartTagUri < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'smart_tag_uri'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/store_item_id.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Identifier for a data store item
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:store_item_id>
+    class StoreItemId < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'store_item_id'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/x_path.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # XPath expression for data selection
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:xpath>
+    class XPath < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'xpath'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml/x_path_expression.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # XPath expression for data selection
+    #
+    # Generated from OOXML schema: customxml.yml
+    # Element: <cxml:xpath>
+    class XPathExpression < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element 'xpath'
+        namespace Uniword::Ooxml::Namespaces::CustomXml
+
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/customxml.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Customxml namespace module
+# This file explicitly autoloads all Customxml classes
+# Using explicit autoload instead of dynamic Dir[] for maintainability
+#
+# Custom XML markup and smart tags
+# Generated from OOXML schema
+
+require 'lutaml/model'
+
+module Uniword
+  module Customxml
+    # Autoload all Customxml classes (34)
+    autoload :CustomXml, 'uniword/customxml/custom_xml'
+    autoload :CustomXmlAttribute, 'uniword/customxml/custom_xml_attribute'
+    autoload :CustomXmlBlock, 'uniword/customxml/custom_xml_block'
+    autoload :CustomXmlCell, 'uniword/customxml/custom_xml_cell'
+    autoload :CustomXmlDelRangeStart, 'uniword/customxml/custom_xml_del_range_start'
+    autoload :CustomXmlInsRangeEnd, 'uniword/customxml/custom_xml_ins_range_end'
+    autoload :CustomXmlInsRangeStart, 'uniword/customxml/custom_xml_ins_range_start'
+    autoload :CustomXmlMoveFromRangeEnd, 'uniword/customxml/custom_xml_move_from_range_end'
+    autoload :CustomXmlMoveFromRangeStart, 'uniword/customxml/custom_xml_move_from_range_start'
+    autoload :CustomXmlMoveToRangeEnd, 'uniword/customxml/custom_xml_move_to_range_end'
+    autoload :CustomXmlMoveToRangeStart, 'uniword/customxml/custom_xml_move_to_range_start'
+    autoload :CustomXmlProperties, 'uniword/customxml/custom_xml_properties'
+    autoload :CustomXmlRow, 'uniword/customxml/custom_xml_row'
+    autoload :CustomXmlRun, 'uniword/customxml/custom_xml_run'
+    autoload :DataBinding, 'uniword/customxml/data_binding'
+    autoload :DataStoreItem, 'uniword/customxml/data_store_item'
+    autoload :ElementName, 'uniword/customxml/element_name'
+    autoload :Name, 'uniword/customxml/name'
+    autoload :NamespaceUri, 'uniword/customxml/namespace_uri'
+    autoload :Placeholder, 'uniword/customxml/placeholder'
+    autoload :PlaceholderText, 'uniword/customxml/placeholder_text'
+    autoload :PrefixMappings, 'uniword/customxml/prefix_mappings'
+    autoload :SchemaRef, 'uniword/customxml/schema_reference'
+    autoload :SchemaRefs, 'uniword/customxml/schema_reference'
+    autoload :SchemaReference, 'uniword/customxml/schema_reference'
+    autoload :ShowingPlaceholder, 'uniword/customxml/showing_placeholder'
+    autoload :ShowingPlaceholderHeader, 'uniword/customxml/showing_placeholder_header'
+    autoload :SmartTag, 'uniword/customxml/smart_tag'
+    autoload :SmartTagAttribute, 'uniword/customxml/smart_tag_attribute'
+    autoload :SmartTagElement, 'uniword/customxml/smart_tag_element'
+    autoload :SmartTagName, 'uniword/customxml/smart_tag_name'
+    autoload :SmartTagProperties, 'uniword/customxml/smart_tag_properties'
+    autoload :SmartTagType, 'uniword/customxml/smart_tag_type'
+    autoload :SmartTagUri, 'uniword/customxml/smart_tag_uri'
+    autoload :StoreItemId, 'uniword/customxml/store_item_id'
+    autoload :XPath, 'uniword/customxml/x_path'
+    autoload :XPathExpression, 'uniword/customxml/x_path_expression'
+  end
+end

data/lib/uniword/document_factory.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+# All classes autoloaded via lib/uniword.rb
+# No require_relative needed - autoload handles lazy loading
+
+module Uniword
+  # Factory for creating Document instances.
+  #
+  # Responsibility: Handle document creation from various sources.
+  # Follows Single Responsibility Principle - creation logic separated from
+  # Document class itself.
+  #
+  # @example Create document from file
+  #   document = Uniword::DocumentFactory.from_file("document.docx")
+  #
+  # @example Create empty document
+  #   document = Uniword::DocumentFactory.create
+  #
+  # @example Create with specific format
+  #   document = Uniword::DocumentFactory.from_file("doc.mhtml", format: :mhtml)
+  class DocumentFactory
+    class << self
+      # Create a new empty document.
+      #
+      # @return [Wordprocessingml::DocumentRoot] A new empty document
+      #
+      # @example Create empty document
+      #   document = DocumentFactory.create
+      def create
+        Wordprocessingml::DocumentRoot.new
+      end
+
+      # Create a document from a file.
+      #
+      # @param path [String] The file path
+      # @param format [Symbol] The format (:auto, :docx, :mhtml)
+      # @return [Document] The loaded document
+      # @raise [ArgumentError] if path is invalid
+      # @raise [ArgumentError] if format is not supported
+      #
+      # @example Load DOCX file
+      #   document = DocumentFactory.from_file("document.docx")
+      #
+      # @example Load with explicit format
+      #   document = DocumentFactory.from_file("doc.mht", format: :mhtml)
+      def from_file(path, format: :auto)
+        # Handle binary strings (for docx gem compatibility)
+        # Convert to StringIO if it's a binary string (contains null bytes or has binary encoding)
+        if path.is_a?(String) && (path.encoding == Encoding::ASCII_8BIT || path.include?("\x00"))
+          path = StringIO.new(path)
+        end
+
+        validate_path(path)
+
+        format = detect_format(path) if format == :auto
+
+        case format
+        when :docx, :docm
+          package = Ooxml::DocxPackage.from_file(path)
+          doc = package.document
+          copy_package_parts_to_document(package, doc)
+          doc
+        when :dotx, :dotm
+          Ooxml::DotxPackage.from_file(path)
+        when :mhtml
+          mhtml_doc = Mhtml::MhtmlPackage.from_file(path)
+          # Convert Mhtml::Document to DocumentRoot for uniform API
+          if mhtml_doc.is_a?(Mhtml::Document)
+            Transformation::Transformer.new.mhtml_to_docx(mhtml_doc)
+          else
+            mhtml_doc
+          end
+        else
+          raise ArgumentError, "Unsupported format: #{format}"
+        end
+      rescue ArgumentError
+        # Re-raise validation errors as-is
+        raise
+      rescue Zip::Error => e
+        raise CorruptedFileError.new(path.to_s, "Invalid ZIP structure: #{e.message}")
+      rescue Nokogiri::XML::SyntaxError => e
+        raise CorruptedFileError.new(path.to_s, "Invalid XML: #{e.message}")
+      rescue StandardError => e
+        # Re-raise our custom errors
+        raise if e.is_a?(Uniword::Error)
+
+        # Wrap other errors
+        raise CorruptedFileError.new(path.to_s, e.message)
+      end
+
+      # Create a document from binary data (IO/StringIO stream or binary string).
+      # Compatible with docx gem API
+      #
+      # @param stream [IO, StringIO, String] The binary stream or data
+      # @param format [Symbol] The format (:auto, :docx, :mhtml)
+      # @return [Document] The loaded document (Generated::Wordprocessingml::DocumentRoot)
+      #
+      # @example Load from stream
+      #   stream = StringIO.new(File.binread("doc.docx"))
+      #   document = DocumentFactory.from_file_data(stream)
+      #
+      # @example Load from binary string
+      #   data = File.binread("doc.docx")
+      #   document = DocumentFactory.from_file_data(data)
+      def from_file_data(stream, format: :auto)
+        # Convert binary string to StringIO if needed
+        stream = StringIO.new(stream) if stream.is_a?(String)
+
+        # Use from_file which already supports IO/StringIO
+        from_file(stream, format: format)
+      end
+
+      # Create a Theme from a theme file (.thmx).
+      #
+      # IMPORTANT: This returns a Theme object, NOT a Document!
+      # Theme files (.thmx) are standalone packages containing only theme data.
+      #
+      # @param path [String] The file path to .thmx file
+      # @param format [Symbol] The format (:auto, :thmx)
+      # @return [Theme] The loaded theme
+      # @raise [ArgumentError] if path is invalid or not a theme format
+      #
+      # @example Load theme file
+      #   theme = DocumentFactory.from_theme_file("celestial.thmx")
+      #   theme.name # => "Celestial"
+      def from_theme_file(path, format: :auto)
+        validate_path(path)
+
+        format = detect_format(path) if format == :auto
+
+        case format
+        when :thmx
+          Ooxml::ThmxPackage.from_file(path)
+        else
+          raise ArgumentError, "Not a theme format: #{format}. Use from_file() for documents."
+        end
+      rescue ArgumentError
+        # Re-raise validation errors as-is
+        raise
+      rescue Zip::Error => e
+        raise CorruptedFileError.new(path.to_s, "Invalid ZIP structure: #{e.message}")
+      rescue Nokogiri::XML::SyntaxError => e
+        raise CorruptedFileError.new(path.to_s, "Invalid XML: #{e.message}")
+      rescue StandardError => e
+        # Re-raise our custom errors
+        raise if e.is_a?(Uniword::Error)
+
+        # Wrap other errors
+        raise CorruptedFileError.new(path.to_s, e.message)
+      end
+
+      # Detect the format of a file.
+      #
+      # Uses FormatDetector for signature-based detection with extension fallback.
+      #
+      # @param path [String] The file path
+      # @return [Symbol] The detected format (:docx, :mhtml)
+      # @raise [ArgumentError] if format cannot be detected
+      #
+      # @example Detect format
+      #   format = DocumentFactory.detect_format("document.docx")
+      #   # => :docx
+      def detect_format(path)
+        detector = FormatDetector.new
+        detector.detect(path)
+      end
+
+      # Copy package parts to document for round-trip preservation
+      #
+      # @param package [Ooxml::DocxPackage] The source package
+      # @param document [Wordprocessingml::DocumentRoot] The target document
+      # @return [void]
+      def copy_package_parts_to_document(package, document)
+        return unless document.is_a?(Uniword::Wordprocessingml::DocumentRoot)
+
+        document.styles_configuration = package.styles if package.styles
+        document.numbering_configuration = package.numbering if package.numbering
+        document.settings = package.settings if package.settings
+        document.font_table = package.font_table if package.font_table
+        document.web_settings = package.web_settings if package.web_settings
+        document.theme = package.theme if package.theme
+        document.core_properties = package.core_properties if package.core_properties
+        document.app_properties = package.app_properties if package.app_properties
+        document.document_rels = package.document_rels if package.document_rels
+        document.theme_rels = package.theme_rels if package.theme_rels
+        document.package_rels = package.package_rels if package.package_rels
+        document.content_types = package.content_types if package.content_types
+        document.custom_properties = package.custom_properties if package.custom_properties
+        document.custom_xml_items = package.custom_xml_items if package.custom_xml_items
+        document.footnotes = package.footnotes if package.footnotes
+        document.endnotes = package.endnotes if package.endnotes
+      end
+
+      private
+
+      # Validate file path or stream.
+      #
+      # @param path [String, IO, StringIO] The path or stream to validate
+      # @return [void]
+      # @raise [FileNotFoundError] if file doesn't exist
+      # @raise [ArgumentError] if path is nil or empty
+      def validate_path(path)
+        raise ArgumentError, 'Path cannot be nil' if path.nil?
+
+        # Allow IO and StringIO objects (for docx gem compatibility)
+        return if path.is_a?(IO) || path.is_a?(StringIO)
+
+        # For strings, validate
+        raise ArgumentError, 'Path cannot be empty' if path.respond_to?(:empty?) && path.empty?
+        raise FileNotFoundError, path unless File.exist?(path)
+      end
+    end
+  end
+end

data/lib/uniword/document_properties/app_version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module DocumentProperties
+    # Application version
+    #
+    # Generated from OOXML schema: document_properties.yml
+    # Element: <ep:AppVersion>
+    class AppVersion < Lutaml::Model::Serializable
+      attribute :content, :string
+
+      xml do
+        element 'AppVersion'
+        namespace Uniword::Ooxml::Namespaces::ExtendedProperties
+
+        map_element '', to: :content, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/document_properties/application.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module DocumentProperties
+    # Application name that created the document
+    #
+    # Generated from OOXML schema: document_properties.yml
+    # Element: <ep:Application>
+    class Application < Lutaml::Model::Serializable
+      attribute :content, :string
+
+      xml do
+        element 'Application'
+        namespace Uniword::Ooxml::Namespaces::ExtendedProperties
+
+        map_element '', to: :content, render_nil: false
+      end
+    end
+  end
+end