uniword 1.0.0

data/lib/uniword/ooxml/schema/ooxml_schema.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    module Schema
+      # OOXML Schema loaded from external YAML configuration.
+      #
+      # Responsibility: Load and provide access to OOXML element definitions.
+      # Single Responsibility - schema management only.
+      #
+      # Follows "Configuration over Convention" - schema is defined in
+      # external YAML files following ISO/IEC 29500 specification.
+      #
+      # @example Load schema
+      #   schema = OoxmlSchema.load('config/ooxml/schema_main.yml')
+      #   definition = schema.definition_for(Paragraph)
+      #
+      # @example Get element definition
+      #   para_def = schema.element('paragraph')
+      #   puts para_def.tag  # => 'w:p'
+      class OoxmlSchema
+        attr_reader :version, :namespace, :elements
+
+        # Load schema from YAML file or multi-file loader
+        #
+        # @param schema_file [String, nil] Path to schema YAML file or nil for default
+        # @return [OoxmlSchema] Loaded schema
+        # @raise [ConfigurationError] if schema file invalid
+        #
+        # @example Load main schema (legacy single file)
+        #   schema = OoxmlSchema.load('config/ooxml/schema_main.yml')
+        #
+        # @example Load multi-file schema (default)
+        #   schema = OoxmlSchema.load
+        def self.load(schema_file = nil)
+          schema_file ||= default_loader_path
+
+          # Check if this is a loader configuration or direct schema file
+          if loader_config?(schema_file)
+            load_from_loader(schema_file)
+          else
+            # Legacy single-file loading
+            config = Configuration::ConfigurationLoader.load_file(schema_file)
+            new(config)
+          end
+        end
+
+        # Load schema from multi-file loader configuration
+        #
+        # @param loader_file [String] Path to schema loader YAML
+        # @return [OoxmlSchema] Loaded schema
+        def self.load_from_loader(loader_file)
+          loader_config = Configuration::ConfigurationLoader.load_file(loader_file)
+          combined_schema = aggregate_schema_files(loader_config, loader_file)
+          new(combined_schema)
+        end
+
+        # Initialize schema from configuration hash
+        #
+        # @param config [Hash] Parsed YAML configuration
+        def initialize(config)
+          validate_schema_config(config)
+
+          @version = config.dig(:schema, :version)
+          @namespace = config.dig(:schema, :namespace)
+          @elements = build_element_definitions(config[:elements] || {})
+        end
+
+        # Get element definition by element class or name
+        #
+        # @param element_class_or_name [Class, Symbol, String] Element class or name
+        # @return [ElementDefinition] Element definition
+        # @raise [ArgumentError] if element not found in schema
+        #
+        # @example Get by class
+        #   definition = schema.definition_for(Paragraph)
+        #
+        # @example Get by name
+        #   definition = schema.definition_for(:paragraph)
+        def definition_for(element_class_or_name)
+          name = normalize_name(element_class_or_name)
+          @elements[name] || raise_element_not_found(name)
+        end
+
+        # Get element definition by name (alias for definition_for)
+        #
+        # @param name [Symbol] Element name
+        # @return [ElementDefinition] Element definition
+        def element(name)
+          @elements[name.to_sym]
+        end
+
+        # Check if schema has definition for element
+        #
+        # @param element_class_or_name [Class, Symbol] Element class or name
+        # @return [Boolean] true if defined
+        def has_element?(element_class_or_name)
+          name = normalize_name(element_class_or_name)
+          @elements.key?(name)
+        end
+
+        # Get all element names
+        #
+        # @return [Array<Symbol>] Array of element names
+        def element_names
+          @elements.keys
+        end
+
+        # Get count of defined elements
+        #
+        # @return [Integer] Number of elements in schema
+        def element_count
+          @elements.count
+        end
+
+        private
+
+        # Build element definitions from configuration
+        #
+        # @param elements_config [Hash] Elements configuration hash
+        # @return [Hash<Symbol, ElementDefinition>] Element definitions
+        def build_element_definitions(elements_config)
+          elements_config.transform_values do |definition|
+            ElementDefinition.new(definition)
+          end
+        end
+
+        # Normalize element class or name to symbol
+        #
+        # @param element_class_or_name [Class, Symbol, String] Element identifier
+        # @return [Symbol] Normalized element name
+        def normalize_name(element_class_or_name)
+          case element_class_or_name
+          when Class
+            # Convert Uniword::Paragraph → :paragraph
+            element_class_or_name.name.split('::').last.downcase.to_sym
+          when Symbol
+            element_class_or_name
+          when String
+            element_class_or_name.to_sym
+          else
+            raise ArgumentError,
+                  "Expected Class, Symbol, or String, got #{element_class_or_name.class}"
+          end
+        end
+
+        # Validate schema configuration structure
+        #
+        # @param config [Hash] Schema configuration
+        # @raise [ConfigurationError] if invalid
+        def validate_schema_config(config)
+          unless config.is_a?(Hash)
+            raise Configuration::ConfigurationError,
+                  'Schema configuration must be a Hash'
+          end
+
+          unless config[:schema]
+            raise Configuration::ConfigurationError,
+                  "Schema configuration must have 'schema' section"
+          end
+
+          return if config[:elements]
+
+          raise Configuration::ConfigurationError,
+                "Schema configuration must have 'elements' section"
+        end
+
+        # Raise error for element not found
+        #
+        # @param name [Symbol] Element name
+        # @raise [ArgumentError]
+        def raise_element_not_found(name)
+          raise ArgumentError,
+                "No schema definition for element: #{name}. " \
+                "Available elements: #{element_names.join(', ')}"
+        end
+
+        # Check if file is a loader configuration
+        #
+        # @param file_path [String] Path to file
+        # @return [Boolean] true if loader config
+        def self.loader_config?(file_path)
+          file_path.end_with?('schema_loader.yml')
+        end
+
+        # Aggregate multiple schema files into single schema
+        #
+        # @param loader_config [Hash] Loader configuration
+        # @param loader_file [String] Path to loader file
+        # @return [Hash] Combined schema configuration
+        def self.aggregate_schema_files(loader_config, loader_file)
+          base_path = File.dirname(loader_file)
+          all_elements = {}
+
+          # Load each schema file and merge elements
+          loader_config[:schema_files].each do |schema_file|
+            file_path = File.join(base_path, schema_file)
+
+            next unless File.exist?(file_path)
+
+            file_config = Configuration::ConfigurationLoader.load_file(file_path)
+
+            # Merge elements from this file
+            all_elements.merge!(file_config[:elements]) if file_config[:elements]
+          end
+
+          # Build combined schema configuration
+          {
+            schema: {
+              version: loader_config[:version],
+              namespace: loader_config[:namespaces]&.dig(:w)
+            },
+            elements: all_elements
+          }
+        end
+
+        # Get default loader path
+        #
+        # @return [String] Path to default schema loader
+        def self.default_loader_path
+          File.expand_path('../../../../config/ooxml/schema_loader.yml', __dir__)
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/schema.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# OOXML Schema Support Module
+#
+# Contains classes for working with OOXML schema definitions.
+module Uniword
+  module Ooxml
+    module Schema
+      autoload :OoxmlSchema, "#{__dir__}/schema/ooxml_schema"
+      autoload :ElementSerializer, "#{__dir__}/schema/element_serializer"
+      autoload :ElementDefinition, "#{__dir__}/schema/element_definition"
+      autoload :AttributeDefinition, "#{__dir__}/schema/attribute_definition"
+      autoload :ChildDefinition, "#{__dir__}/schema/child_definition"
+    end
+  end
+end

data/lib/uniword/ooxml/schema_library.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Ooxml
+    # Schema Library (shared-customXmlSchemaProperties.xsd)
+    #
+    # Defines a library of XML schemas used by custom XML markup.
+    # Appears in word/settings.xml as <sl:schemaLibrary>.
+    #
+    # Namespace: http://schemas.openxmlformats.org/schemaLibrary/2006/main
+    # Prefix: sl
+    class SchemaLibEntry < Lutaml::Model::Serializable
+      attribute :uri, :string, default: -> { '' }
+      attribute :manifest_location, :string
+
+      xml do
+        element 'schema'
+        namespace Namespaces::SchemaLibrary
+
+        map_attribute 'uri', to: :uri
+        map_attribute 'manifestLocation', to: :manifest_location
+      end
+    end
+
+    class SchemaLibrary < Lutaml::Model::Serializable
+      attribute :schemas, SchemaLibEntry, collection: true, initialize_empty: true
+
+      xml do
+        element 'schemaLibrary'
+        namespace Namespaces::SchemaLibrary
+
+        map_element 'schema', to: :schemas, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/styleset_package.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    # Specialized package handler for StyleSet (.dotx) files
+    #
+    # StyleSets are stored in .dotx Word template files with style
+    # definitions in word/styles.xml. This class bridges the package
+    # infrastructure with StyleSet model serialization.
+    #
+    # @example Load a StyleSet
+    #   package = StyleSetPackage.new(path: 'Distinctive.dotx')
+    #   styleset = package.load_content
+    #   puts styleset.name
+    #   package.cleanup
+    #
+    # @example Save a StyleSet
+    #   package = StyleSetPackage.new(path: 'template.dotx')
+    #   package.extract
+    #   package.save_content(my_styleset)
+    #   package.package('output.dotx')
+    #   package.cleanup
+    class StyleSetPackage < DotxPackage
+      # Domain model loaded from package
+      attr_reader :styleset
+
+      # Load StyleSet from package
+      #
+      # Extracts package and parses word/styles.xml into StyleSet model.
+      # Uses existing StyleSetXmlParser for XML parsing.
+      #
+      # @return [StyleSet] Loaded StyleSet model
+      # @raise [ArgumentError] if package is invalid
+      def load_content
+        extract
+
+        # Read styles XML
+        styles_xml = read_styles
+
+        # Parse into StyleSet using existing parser
+        parser = StyleSets::StyleSetXmlParser.new
+        @styleset = parser.parse(styles_xml)
+
+        # Store source file reference
+        @styleset.source_file = path
+
+        @styleset
+      end
+
+      # Save StyleSet to package
+      #
+      # Serializes StyleSet model to word/styles.xml using lutaml-model.
+      # Preserves other package files unchanged.
+      #
+      # @param styleset [StyleSet] StyleSet model to save
+      # @return [void]
+      # @raise [RuntimeError] if package not extracted
+      def save_content(styleset)
+        raise 'Must extract before saving' unless extracted_dir
+
+        @styleset = styleset
+
+        # Serialize StyleSet to XML using lutaml-model
+        styles_xml = serialize_styleset(styleset)
+
+        # Write to package
+        write_styles(styles_xml)
+      end
+
+      # Convenience: Load StyleSet from file
+      #
+      # @param path [String] Path to .dotx file
+      # @return [StyleSet] Loaded StyleSet
+      def self.load_from_file(path)
+        package = new(path: path)
+        styleset = package.load_content
+        package.cleanup
+        styleset
+      end
+
+      # Convenience: Save StyleSet to file
+      #
+      # Creates new .dotx package with StyleSet, using template as base.
+      #
+      # @param styleset [StyleSet] StyleSet to save
+      # @param output_path [String] Output .dotx file path
+      # @param template_path [String] Template .dotx to base on
+      # @return [String] Path to created file
+      def self.save_to_file(styleset, output_path, template_path:)
+        package = new(path: template_path)
+        package.extract
+        package.save_content(styleset)
+        package.package(output_path)
+        package.cleanup
+
+        output_path
+      end
+
+      private
+
+      # Serialize StyleSet to XML
+      #
+      # Uses lutaml-model serialization with proper namespaces.
+      # This should generate XML compatible with word/styles.xml format.
+      #
+      # @param styleset [StyleSet] StyleSet to serialize
+      # @return [String] Serialized XML
+      def serialize_styleset(styleset)
+        # Create StylesConfiguration from StyleSet
+        config = StylesConfiguration.new
+
+        # Copy styles from styleset
+        styleset.styles.each do |style|
+          config.styles << style
+        end
+
+        # Serialize to XML using lutaml-model
+        config.to_xml
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/theme_package.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    # Specialized package handler for Theme (.thmx) files
+    #
+    # Themes are stored in .thmx PowerPoint theme files with the main
+    # theme definition at theme/theme/theme1.xml. This class bridges
+    # the package infrastructure with Theme model serialization.
+    #
+    # @example Load a Theme
+    #   package = ThemePackage.new(path: 'Atlas.thmx')
+    #   theme = package.load_content
+    #   puts theme.name
+    #   package.cleanup
+    #
+    # @example Save a Theme
+    #   package = ThemePackage.new(path: 'template.thmx')
+    #   package.extract
+    #   package.save_content(my_theme)
+    #   package.package('output.thmx')
+    #   package.cleanup
+    class ThemePackage
+      # Source file path
+      attr_accessor :path
+
+      # Extracted content (Hash of file paths => content)
+      attr_accessor :extracted_content
+
+      # Domain model loaded from package
+      attr_reader :theme
+
+      # Initialize with file path
+      #
+      # @param path [String] Path to .thmx file
+      def initialize(path:)
+        @path = path
+        @extracted_content = nil
+        @theme = nil
+      end
+
+      # Extract ZIP package
+      #
+      # @return [void]
+      def extract
+        extractor = Infrastructure::ZipExtractor.new
+        @extracted_content = extractor.extract(@path)
+      end
+
+      # Check if extracted
+      #
+      # @return [Boolean]
+      def extracted_dir
+        @extracted_content
+      end
+
+      # Cleanup extracted content (no-op since we use memory)
+      #
+      # @return [void]
+      def cleanup
+        @extracted_content = nil
+      end
+
+      # Read theme XML from extracted package
+      #
+      # @return [String] Theme XML content
+      def read_theme
+        raise 'Must extract before reading' unless @extracted_content
+
+        @extracted_content['theme/theme/theme1.xml']
+      end
+
+      # Load Theme from package
+      #
+      # Extracts package and parses theme/theme/theme1.xml into Theme model.
+      # Uses lutaml-model deserialization for XML parsing.
+      #
+      # @return [Theme] Loaded Theme model
+      # @raise [ArgumentError] if package is invalid
+      def load_content
+        extract unless @extracted_content
+
+        # Read theme XML
+        theme_xml = read_theme
+
+        # Parse into Theme using lutaml-model
+        @theme = Drawingml::Theme.from_xml(theme_xml)
+
+        # Store source file reference
+        @theme.source_file = path if @theme
+
+        @theme
+      end
+
+      # Save Theme to package
+      #
+      # Serializes Theme model to theme/theme/theme1.xml using lutaml-model.
+      # Preserves media files and variants unchanged.
+      #
+      # @param theme [Theme] Theme model to save
+      # @return [void]
+      # @raise [RuntimeError] if package not extracted
+      def save_content(theme)
+        raise 'Must extract before saving' unless @extracted_content
+
+        @theme = theme
+
+        # Serialize Theme to XML using lutaml-model with prefix: true
+        # to preserve namespace prefixes for cross-namespace elements
+        theme_xml = theme.to_xml(prefix: true)
+
+        # Update content hash
+        @extracted_content['theme/theme/theme1.xml'] = theme_xml
+      end
+
+      # Package extracted content into ZIP file
+      #
+      # @param output_path [String] Path to output .thmx file
+      # @return [void]
+      # @raise [RuntimeError] if package not extracted
+      def package(output_path)
+        raise 'Must extract before packaging' unless @extracted_content
+
+        packager = Infrastructure::ZipPackager.new
+        packager.package(@extracted_content, output_path)
+      end
+
+      # Convenience: Load Theme from file
+      #
+      # @param path [String] Path to .thmx file
+      # @return [Theme] Loaded Theme
+      def self.load_from_file(path)
+        package = new(path: path)
+        theme = package.load_content
+        package.cleanup
+        theme
+      end
+
+      # Convenience: Save Theme to file
+      #
+      # Creates new .thmx package with Theme, using template as base.
+      #
+      # @param theme [Theme] Theme to save
+      # @param output_path [String] Output .thmx file path
+      # @param template_path [String] Template .thmx to base on
+      # @return [String] Path to created file
+      def self.save_to_file(theme, output_path, template_path:)
+        package = new(path: template_path)
+        package.extract
+        package.save_content(theme)
+        package.package(output_path)
+        package.cleanup
+
+        output_path
+      end
+
+      private
+
+      # Load media files from package
+      #
+      # @return [Hash] filename => MediaFile objects
+      def load_media_files
+        media = {}
+
+        media_files.each do |file_path|
+          filename = File.basename(file_path)
+          content = read_media(filename)
+
+          media[filename] = Themes::MediaFile.new(
+            filename: filename,
+            content: content,
+            source_path: file_path
+          )
+        end
+
+        media
+      end
+
+      # Save media files to package
+      #
+      # @param media_files [Hash] filename => MediaFile objects
+      # @return [void]
+      def save_media_files(media_files)
+        media_files.each do |filename, media_file|
+          write_media(filename, media_file.content)
+        end
+      end
+
+      # Load theme variants from package
+      #
+      # @return [Hash] variant_id => ThemeVariant
+      def load_variants
+        variant_hash = {}
+
+        variants.each do |variant_id|
+          variant_xml = read_variant(variant_id)
+          variant = Themes::ThemeVariant.new(variant_id, theme_xml: variant_xml)
+          variant_hash[variant_id] = variant
+        end
+
+        variant_hash
+      end
+
+      # Save theme variants to package
+      #
+      # @param variants [Hash] variant_id => ThemeVariant
+      # @return [void]
+      def save_variants(variants)
+        variants.each do |variant_id, variant|
+          # Get variant's theme XML
+          variant_xml = if variant.theme
+                          variant.theme.to_xml
+                        else
+                          variant.theme_xml
+                        end
+
+          write_variant(variant_id, variant_xml) if variant_xml
+        end
+      end
+    end
+  end
+end