uniword 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea1c6924b201809b0adcd798ea5453ceb06a6628e9ea54ec30221d4d4b325ca4
-  data.tar.gz: 45d19527778e0c36b9acb7a2a7ce98e83ea9f841df619c2bf1eb3ae4f77fbc46
+  metadata.gz: 8b3b37b9a1642f94a634c42b754630ca35cd7167ddc1415223dd65848a379c48
+  data.tar.gz: 011ddc8e381521e2d161cd0cf9fd0dd9eee791e9f28026fd63e89cf9386bfa03
 SHA512:
-  metadata.gz: 9ff4355adebd0f8eb10843ca4ae83b43df148340b3ab562d1bd43b1317d6384fd0dd3fe713e741df9d57dbad2eca70684e946565dc9823bb923c75cc2f302226
-  data.tar.gz: 92b190e3421fce1634462ce0b6bdff183138c6eaefa41ef96cce9b441eba72661988a36ae652fa5df8afdd1ef3eeb3d62bdd9e7eb1cd09b10a7ae7863023b331
+  metadata.gz: 1c6c8785a7fe56480f0d7bdda19ec56e50704653016d4146c561e401c8e98b856cf99a1205411521b78cd19b701e794dfbc75c4d4c844b87e2b8fe3d44fb514e
+  data.tar.gz: 9275ea155ee7af2ee9cd0e24d6534a0124f0f8501583206fb98eb3c63e7736c280552336a47bad97a31e50b235805c5fba904d1a80c0cee9bbe6f216f7e49f02

data/lib/uniword/builder/comment_builder.rb

@@ -11,8 +11,9 @@ module Uniword
     class CommentBuilder
       attr_reader :model
 
-      def initialize(author:, comment_id: nil, date: nil, initials: nil)
-        @model = Comment.new(
+      def initialize(model: nil, author: nil, comment_id: nil, date: nil,
+initials: nil)
+        @model = model || Comment.new(
           author: author,
           comment_id: comment_id,
           date: date,
@@ -22,9 +23,7 @@ module Uniword
 
       # Wrap an existing Comment model
       def self.from_model(model)
-        builder = allocate
-        builder.instance_variable_set(:@model, model)
-        builder
+        new(model: model)
       end
 
       # Append text to the comment (creates a paragraph)

data/lib/uniword/builder.rb

@@ -148,15 +148,25 @@ module Uniword
       run
     end
 
-    # Factory: creates a Run with a tab character
+    # Factory: creates a Run containing a tab character.
+    # Use this with ParagraphBuilder#<< to append a tab to a paragraph.
     #
     # @return [Wordprocessingml::Run]
+    # @see .tab_element for the bare Tab element
     def self.tab
       run = Wordprocessingml::Run.new
-      run.tab = Wordprocessingml::Tab.new
+      run.tab = tab_element
       run
     end
 
+    # Factory: creates a bare Tab element for direct assignment to Run#tab.
+    # Most callers should use .tab instead, which wraps the Tab in a Run.
+    #
+    # @return [Wordprocessingml::Tab]
+    def self.tab_element
+      Wordprocessingml::Tab.new
+    end
+
     # Factory: creates a Run containing a line break
     #
     # @return [Wordprocessingml::Run]

data/lib/uniword/document_input.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Tagging module for document types accepted by DocumentWriter and FormatConverter.
+  module DocumentInput
+  end
+end

data/lib/uniword/document_writer.rb

@@ -136,11 +136,7 @@ module Uniword
     # @raise [ArgumentError] if document is invalid
     def validate_document(doc)
       raise ArgumentError, "Document cannot be nil" if doc.nil?
-
-      # Accept OOXML Document
-      return if doc.is_a?(Uniword::Wordprocessingml::DocumentRoot)
-      # Accept MHTML Document
-      return if doc.is_a?(Uniword::Mhtml::Document)
+      return if doc.is_a?(Uniword::DocumentInput)
 
       raise ArgumentError, "Must be a Document instance"
     end

data/lib/uniword/docx/package_serialization.rb

@@ -33,18 +33,14 @@ document_rels)
 document_rels)
         # Package infrastructure
         content["[Content_Types].xml"] =
-          content_types.to_xml(encoding: "UTF-8", declaration: true,
-                               standalone: true)
+          serialize_infrastructure(content_types)
         content["_rels/.rels"] =
-          package_rels.to_xml(encoding: "UTF-8", declaration: true,
-                              standalone: true)
+          serialize_infrastructure(package_rels)
 
         # Document properties
         if core_properties
           content["docProps/core.xml"] =
-            core_properties.to_xml(encoding: "UTF-8",
-                                   prefix: true,
-                                   standalone: true)
+            serialize_part(core_properties)
         end
         if app_properties
           content["docProps/app.xml"] =
@@ -78,70 +74,57 @@ document_rels)
         # Document parts
         if document
           content["word/document.xml"] =
-            document.to_xml(encoding: "UTF-8", prefix: true,
-                            standalone: true)
+            serialize_part(document)
         end
         if styles
           content["word/styles.xml"] =
-            styles.to_xml(encoding: "UTF-8", prefix: true,
-                          standalone: true)
+            serialize_part(styles)
         end
         if numbering
           content["word/numbering.xml"] =
-            numbering.to_xml(encoding: "UTF-8", prefix: true,
-                             standalone: true)
+            serialize_part(numbering)
         end
         if settings
           content["word/settings.xml"] =
-            settings.to_xml(encoding: "UTF-8", prefix: true,
-                            standalone: true)
+            serialize_part(settings)
         end
         if font_table
           content["word/fontTable.xml"] =
-            font_table.to_xml(encoding: "UTF-8", prefix: true,
-                              standalone: true)
+            serialize_part(font_table)
         end
         if web_settings
           content["word/webSettings.xml"] =
-            web_settings.to_xml(encoding: "UTF-8", prefix: true,
-                                standalone: true)
+            serialize_part(web_settings)
         end
         if document_rels
           content["word/_rels/document.xml.rels"] =
-            document_rels.to_xml(encoding: "UTF-8", declaration: true,
-                                 standalone: true)
+            serialize_infrastructure(document_rels)
         end
 
         # Theme
         if theme
           content["word/theme/theme1.xml"] =
-            theme.to_xml(encoding: "UTF-8", prefix: true,
-                         standalone: true)
+            serialize_part(theme)
         end
         if theme_rels
           content["word/theme/_rels/theme1.xml.rels"] =
-            theme_rels.to_xml(encoding: "UTF-8", declaration: true,
-                              standalone: true)
+            serialize_infrastructure(theme_rels)
         end
 
         # Notes
         if footnotes
           content["word/footnotes.xml"] =
-            footnotes.to_xml(encoding: "UTF-8", prefix: true,
-                             standalone: true)
+            serialize_part(footnotes)
         end
         if endnotes
           content["word/endnotes.xml"] =
-            endnotes.to_xml(encoding: "UTF-8", prefix: true,
-                            standalone: true)
+            serialize_part(endnotes)
         end
 
         # Bibliography sources
         if document&.bibliography_sources
           content["word/sources.xml"] =
-            document.bibliography_sources.to_xml(encoding: "UTF-8",
-                                                 declaration: true,
-                                                 standalone: true)
+            serialize_infrastructure(document.bibliography_sources)
         end
 
         # Headers and footers
@@ -150,6 +133,16 @@ document_rels)
         serialize_header_footer_parts(content)
       end
 
+      # Serialize an OOXML document part with standard encoding
+      def serialize_part(model)
+        model.to_xml(encoding: "UTF-8", prefix: true, standalone: true)
+      end
+
+      # Serialize package infrastructure (rels, content types) with declaration
+      def serialize_infrastructure(model)
+        model.to_xml(encoding: "UTF-8", declaration: true, standalone: true)
+      end
+
       private
 
       def inject_image_parts(content, content_types, document_rels)
@@ -451,8 +444,7 @@ document_rels)
         document.headers.each_value do |header_obj|
           idx += 1
           content["word/header#{idx}.xml"] =
-            header_obj.to_xml(encoding: "UTF-8", prefix: true,
-                              standalone: true)
+            serialize_part(header_obj)
         end
       end
 
@@ -463,8 +455,7 @@ document_rels)
         document.footers.each_value do |footer_obj|
           idx += 1
           content["word/footer#{idx}.xml"] =
-            footer_obj.to_xml(encoding: "UTF-8", prefix: true,
-                              standalone: true)
+            serialize_part(footer_obj)
         end
       end
 
@@ -473,8 +464,7 @@ document_rels)
 
         document.header_footer_parts.each do |part|
           content["word/#{part[:target]}"] =
-            part[:content].to_xml(encoding: "UTF-8", prefix: true,
-                                  standalone: true)
+            serialize_part(part[:content])
         end
       end
     end

data/lib/uniword/docx/reconciler.rb

@@ -85,15 +85,15 @@ module Uniword
         ].compact
 
         parts.each do |part|
-          part.instance_variable_set(:@pending_namespace_data, nil)
-          part.instance_variable_set(:@import_declaration_plan, nil)
+          part.pending_namespace_data = nil
+          part.import_declaration_plan = nil
+          part.pending_plan_root_element = nil
+          # TODO: @xml_input_namespaces has no public accessor in lutaml-model.
+          # Replace with public API once lutaml-model exposes one.
           part.instance_variable_set(:@xml_input_namespaces, nil)
-          part.instance_variable_set(:@pending_plan_root_element, nil)
         end
       end
 
-      # -- Section Properties --
-
       def reconcile_section_properties
         return unless package.document&.body
 

data/lib/uniword/drawingml/color_scheme.rb

@@ -313,7 +313,7 @@ module Uniword
         color_name = color_name.to_sym
         # Map folHlink to fol_hlink for attribute access
         attr_name = color_name == :folHlink ? :fol_hlink : color_name
-        color_obj = instance_variable_get("@#{attr_name}")
+        color_obj = public_send(attr_name)
         color_obj&.value
       end
 
@@ -345,7 +345,7 @@ module Uniword
 
         color_obj = color_class.new
         color_obj.rgb = value
-        instance_variable_set("@#{attr_name}", color_obj)
+        public_send(:"#{attr_name}=", color_obj)
         @colors_hash[color_name] = value
       end
 

data/lib/uniword/format_converter.rb

@@ -277,30 +277,15 @@ module Uniword
     # @param document [Object] Document (OOXML or MHTML)
     # @return [Hash] Statistics hash
     def document_stats(document)
-      # Handle OOXML document
-      if document.is_a?(Uniword::Wordprocessingml::DocumentRoot) || document.is_a?(Uniword::Wordprocessingml::Body)
+      if document.is_a?(Uniword::Wordprocessingml::Body)
         return {
           paragraphs: document.paragraphs.count,
-          tables: document.is_a?(Uniword::Wordprocessingml::DocumentRoot) ? document.tables.count : 0,
-          images: document.is_a?(Uniword::Wordprocessingml::DocumentRoot) ? document.images.count : 0
+          tables: 0,
+          images: 0
         }
       end
 
-      # Handle MHTML document - estimate from HTML content
-      html = if document.is_a?(Mhtml::Document) && document.raw_html
-               document.raw_html
-             elsif document.is_a?(Mhtml::Document) && document.html_content
-               document.html_content
-             end
-      if html
-        {
-          paragraphs: html.scan(/<p[\s>]/i).count,
-          tables: html.scan(/<table/i).count,
-          images: html.scan(/<img/i).count
-        }
-      else
-        { paragraphs: 0, tables: 0, images: 0 }
-      end
+      document.document_stats
     end
 
     # Validate conversion parameters

data/lib/uniword/has_run_position.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Tagging module for elements that track their position among sibling runs.
+  # Used by the MHTML renderer to interleave hyperlinks and math objects
+  # at the correct position within a paragraph.
+  module HasRunPosition
+  end
+end

data/lib/uniword/math/o_math.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
+require_relative "../has_run_position"
 
 module Uniword
   module Math
@@ -9,6 +10,8 @@ module Uniword
     # Generated from OOXML schema: math.yml
     # Element: <m:oMath>
     class OMath < Lutaml::Model::Serializable
+      include Uniword::HasRunPosition
+
       # Pattern 0: Attributes BEFORE xml mappings
       attribute :runs, MathRun, collection: true, initialize_empty: true
       attribute :functions, Function, collection: true, initialize_empty: true
@@ -32,6 +35,9 @@ module Uniword
       attribute :equation_arrays, EquationArray, collection: true,
                                                  initialize_empty: true
 
+      # Transient: position among sibling runs (used by MHTML renderer)
+      attribute :run_position, :integer
+
       xml do
         element "oMath"
         namespace Uniword::Ooxml::Namespaces::MathML

data/lib/uniword/mhtml/document.rb

@@ -2,6 +2,8 @@
 
 require "lutaml/model"
 
+require_relative "../document_input"
+
 module Uniword
   module Mhtml
     # MHTML Document — top-level model for .mht/.mhtml/.doc files.
@@ -17,6 +19,8 @@ module Uniword
     #     ├── word_document_settings (Metadata::WordDocumentSettings)
     #     └── filelist_xml (String)
     class Document < Lutaml::Model::Serializable
+      include Uniword::DocumentInput
+
       # MIME headers
       attribute :mime_version, :string, default: -> { "1.0" }
       attribute :boundary, :string
@@ -161,6 +165,20 @@ module Uniword
         "#<#{self.class} parts=#{parts.length} images=#{image_parts.length} " \
           "xml=#{xml_parts.length} theme=#{theme_part ? 'yes' : 'no'}>"
       end
+
+      # @return [Hash] Document statistics (paragraphs, tables, images)
+      def document_stats
+        html = raw_html || html_content
+        if html
+          {
+            paragraphs: html.scan(/<p[\s>]/i).count,
+            tables: html.scan(/<table/i).count,
+            images: html.scan(/<img/i).count,
+          }
+        else
+          { paragraphs: 0, tables: 0, images: 0 }
+        end
+      end
     end
   end
 end

data/lib/uniword/properties/bold.rb

@@ -1,40 +1,10 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require_relative "boolean_element_factory"
 
 module Uniword
   module Properties
-    # Bold formatting element
-    #
-    # OOXML: <w:b/> means bold=true (absence of val= means true)
-    # <w:b w:val="false"/> means bold=false
-    #
-    # Model: nil = true (no val attribute), 'false' = explicit false
-    class Bold < Lutaml::Model::Serializable
-      include Uniword::Properties::BooleanElement
-
-      attribute :val, :string, default: nil
-      include Uniword::Properties::BooleanValSetter
-
-      xml do
-        element "b"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Complex script bold
-    class BoldCs < Lutaml::Model::Serializable
-      include Uniword::Properties::BooleanElement
-
-      attribute :val, :string, default: nil
-      include Uniword::Properties::BooleanValSetter
-
-      xml do
-        element "bCs"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
+    BooleanElementFactory.define("b", "Bold")
+    BooleanElementFactory.define("bCs", "BoldCs")
   end
 end

data/lib/uniword/properties/boolean_element_factory.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Properties
+    # OOXML boolean element mixin for value/val getter logic only.
+    # The val= setter must be defined AFTER attribute :val to override
+    # the generated setter.
+    module BooleanElement
+      def value
+        val != "false"
+      end
+    end
+
+    # Helper to define val= override after attribute declaration.
+    # Uses alias_method to save the generated setter, then overrides it.
+    module BooleanValSetter
+      def self.included(base)
+        base.class_eval do
+          alias_method :__original_val_setter=, :val= if method_defined?(:val=)
+          define_method(:val=) do |v|
+            @val = if v.nil?
+                     nil
+                   elsif v == false || v.to_s == "false"
+                     "false"
+                   elsif v == true || v.to_s == "true"
+                     nil
+                   else
+                     v
+                   end
+            value_set_for(:val)
+          end
+        end
+      end
+    end
+
+    # Factory for OOXML boolean element classes.
+    #
+    # Generates a lutaml-model class that maps to an XML element like
+    # <w:b/> (true) or <w:b w:val="false"/> (false).
+    #
+    # @param element_name [String] XML element name (e.g. "b", "i", "strike")
+    # @param class_name [String] Ruby class name (e.g. "Bold", "Italic")
+    # @return [Class] The generated class, also assigned as a constant
+    #
+    # @example
+    #   BooleanElementFactory.define("b", "Bold")
+    #   BooleanElementFactory.define("bCs", "BoldCs")
+    module BooleanElementFactory
+      WML_NS = Uniword::Ooxml::Namespaces::WordProcessingML
+
+      def self.define(element_name, class_name)
+        klass = Class.new(Lutaml::Model::Serializable) do
+          include BooleanElement
+
+          attribute :val, :string, default: nil
+          include BooleanValSetter
+
+          xml do
+            element element_name
+            namespace WML_NS
+            map_attribute "val", to: :val, render_nil: false,
+                                 render_default: false
+          end
+        end
+
+        Properties.const_set(class_name, klass)
+        klass
+      end
+    end
+  end
+end

data/lib/uniword/properties/boolean_formatting.rb

@@ -1,228 +1,24 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require_relative "boolean_element_factory"
 
 module Uniword
   module Properties
-    # OOXML boolean element mixin for value/val getter logic only.
-    # The val= setter must be defined AFTER attribute :val to override
-    # the generated setter.
-    module BooleanElement
-      def value
-        @val != "false"
-      end
-
-      def value=(v)
-        @val = v ? nil : "false"
-      end
-    end
-
-    # Helper to define val= override after attribute declaration.
-    # Uses alias_method to save the generated setter, then overrides it.
-    module BooleanValSetter
-      def self.included(base)
-        base.class_eval do
-          # Save the generated val= method
-          alias_method :__original_val_setter=, :val= if method_defined?(:val=)
-          # Override val= with our custom logic
-          define_method(:val=) do |v|
-            @val = if v.nil?
-                     nil
-                   elsif v == false || v.to_s == "false"
-                     "false"
-                   elsif v == true || v.to_s == "true"
-                     nil
-                   else
-                     v
-                   end
-            value_set_for(:val) if @val
-          end
-        end
-      end
-    end
-
-    # Strike-through formatting
-    class Strike < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "strike"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Double strike-through formatting
-    class DoubleStrike < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "dstrike"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Small caps formatting
-    class SmallCaps < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "smallCaps"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # All caps formatting
-    class Caps < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "caps"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Hidden text
-    class Vanish < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "vanish"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Web hidden text (hidden from web view)
-    class WebHidden < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "webHidden"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # No proofing (disable spell/grammar check)
-    class NoProof < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "noProof"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Shadow formatting
-    class Shadow < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "shadow"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Emboss formatting
-    class Emboss < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "emboss"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Imprint formatting
-    class Imprint < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "imprint"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
+    # Run-level boolean formatting elements
+    BooleanElementFactory.define("strike", "Strike")
+    BooleanElementFactory.define("dstrike", "DoubleStrike")
+    BooleanElementFactory.define("smallCaps", "SmallCaps")
+    BooleanElementFactory.define("caps", "Caps")
+    BooleanElementFactory.define("vanish", "Vanish")
+    BooleanElementFactory.define("webHidden", "WebHidden")
+    BooleanElementFactory.define("noProof", "NoProof")
+    BooleanElementFactory.define("shadow", "Shadow")
+    BooleanElementFactory.define("emboss", "Emboss")
+    BooleanElementFactory.define("imprint", "Imprint")
 
     # Style-level boolean elements
-
-    # Quick format flag
-    class QuickFormat < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "qFormat"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Keep with next paragraph
-    class KeepNext < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "keepNext"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Keep lines together
-    class KeepLines < Lutaml::Model::Serializable
-      include BooleanElement
-
-      attribute :val, :string, default: nil
-      include BooleanValSetter
-
-      xml do
-        element "keepLines"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
+    BooleanElementFactory.define("qFormat", "QuickFormat")
+    BooleanElementFactory.define("keepNext", "KeepNext")
+    BooleanElementFactory.define("keepLines", "KeepLines")
   end
 end

data/lib/uniword/properties/italic.rb

@@ -1,40 +1,10 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
+require_relative "boolean_element_factory"
 
 module Uniword
   module Properties
-    # Italic formatting element
-    #
-    # OOXML: <w:i/> means italic=true (absence of val= means true)
-    # <w:i w:val="false"/> means italic=false
-    #
-    # Model: nil = true (no val attribute), 'false' = explicit false
-    class Italic < Lutaml::Model::Serializable
-      include Uniword::Properties::BooleanElement
-
-      attribute :val, :string, default: nil
-      include Uniword::Properties::BooleanValSetter
-
-      xml do
-        element "i"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
-
-    # Complex script italic
-    class ItalicCs < Lutaml::Model::Serializable
-      include Uniword::Properties::BooleanElement
-
-      attribute :val, :string, default: nil
-      include Uniword::Properties::BooleanValSetter
-
-      xml do
-        element "iCs"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "val", to: :val, render_nil: false, render_default: false
-      end
-    end
+    BooleanElementFactory.define("i", "Italic")
+    BooleanElementFactory.define("iCs", "ItalicCs")
   end
 end

data/lib/uniword/properties.rb

@@ -23,10 +23,13 @@ module Uniword
     autoload :NumberingProperties, "uniword/properties/numbering_properties"
     autoload :Tabs, "uniword/properties/tabs"
 
+    # Boolean element infrastructure
+    autoload :BooleanElement, "uniword/properties/boolean_element_factory"
+    autoload :BooleanValSetter, "uniword/properties/boolean_element_factory"
+    autoload :BooleanElementFactory,
+             "uniword/properties/boolean_element_factory"
+
     # Boolean formatting classes (from boolean_formatting.rb)
-    # Note: BooleanElement and BooleanValSetter are also in boolean_formatting.rb
-    autoload :BooleanElement, "uniword/properties/boolean_formatting"
-    autoload :BooleanValSetter, "uniword/properties/boolean_formatting"
     autoload :Strike, "uniword/properties/boolean_formatting"
     autoload :DoubleStrike, "uniword/properties/boolean_formatting"
     autoload :SmallCaps, "uniword/properties/boolean_formatting"
@@ -49,7 +52,9 @@ module Uniword
 
     # Bold and Italic (from bold.rb and italic.rb)
     autoload :Bold, "uniword/properties/bold"
+    autoload :BoldCs, "uniword/properties/bold"
     autoload :Italic, "uniword/properties/italic"
+    autoload :ItalicCs, "uniword/properties/italic"
 
     # Complex objects
     autoload :Spacing, "uniword/properties/spacing"

data/lib/uniword/theme/theme_xml_parser.rb

@@ -79,7 +79,7 @@ module Uniword
 
           # Set the color using the appropriate attribute
           attr_name = color_name == "folHlink" ? :fol_hlink : color_name.to_sym
-          scheme.instance_variable_set("@#{attr_name}", color_obj)
+          scheme.public_send(:"#{attr_name}=", color_obj)
         end
 
         # Sync hash interface

data/lib/uniword/transformation/mhtml_element_renderer.rb

@@ -543,11 +543,11 @@ module Uniword
         parts.join
       end
 
-      # Build position-indexed map from elements that have @_run_position markers
+      # Build position-indexed map from elements that have run_position markers
       def build_position_map(elements, fallback_pos)
         by_pos = {}
         elements.each do |el|
-          pos = el.instance_variable_get(:@_run_position)
+          pos = el.run_position if el.is_a?(Uniword::HasRunPosition)
           pos ||= fallback_pos
           by_pos[pos] ||= []
           by_pos[pos] << el

data/lib/uniword/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uniword
-  VERSION = "1.0.7"
+  VERSION = "1.0.9"
 end

data/lib/uniword/wordprocessingml/document_root.rb

@@ -2,6 +2,7 @@
 
 require "lutaml/model"
 
+require_relative "../document_input"
 require_relative "document_root/feature_facade"
 
 module Uniword
@@ -12,6 +13,7 @@ module Uniword
     # Element: <w:document>
     class DocumentRoot < Lutaml::Model::Serializable
       include FeatureFacade
+      include Uniword::DocumentInput
 
       attribute :mc_ignorable, Uniword::Ooxml::Types::McIgnorable
       attribute :body, Body, default: -> { Body.new }
@@ -210,6 +212,15 @@ module Uniword
         end.compact
       end
 
+      # @return [Hash] Document statistics (paragraphs, tables, images)
+      def document_stats
+        {
+          paragraphs: paragraphs.count,
+          tables: tables.count,
+          images: images.count,
+        }
+      end
+
       # Check if document structure is valid.
       # Runs structural checks via Validation::StructuralValidator.
       # Use the verify CLI command for full OPC + XSD + semantic validation.

data/lib/uniword/wordprocessingml/hyperlink.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
+require_relative "../has_run_position"
 
 module Uniword
   module Wordprocessingml
@@ -9,12 +10,17 @@ module Uniword
     # Generated from OOXML schema: wordprocessingml.yml
     # Element: <w:hyperlink>
     class Hyperlink < Lutaml::Model::Serializable
+      include Uniword::HasRunPosition
+
       attribute :id, :string
       attribute :anchor, :string
       attribute :tooltip, :string
       attribute :history, Uniword::Properties::HistoryValue
       attribute :runs, Run, collection: true, initialize_empty: true
 
+      # Transient: position among sibling runs (used by MHTML renderer)
+      attribute :run_position, :integer
+
       xml do
         element "hyperlink"
         namespace Uniword::Ooxml::Namespaces::WordProcessingML

data/lib/uniword/wordprocessingml/run.rb

@@ -178,34 +178,22 @@ module Uniword
       def merge_properties(base, override)
         merged = RunProperties.new
 
-        # Get all attribute names from RunProperties class
         RunProperties.attributes.each_key do |attr_name|
           override_val = override.public_send(attr_name)
           base_val = base.public_send(attr_name)
 
-          # Use override if it's non-nil AND not using default value
-          # For boolean properties like Bold, check if it was explicitly set
           use_override = if override_val.is_a?(Lutaml::Model::Serializable)
-                           # Check if the property has any non-default/non-nil values
                            override_val.class.attributes.any? do |k, _|
-                             iv = override_val.instance_variable_get(:"@#{k}")
-                             iv && !override_val.using_default?(k)
+                             !override_val.using_default?(k)
                            end
                          else
                            !override_val.nil?
                          end
 
-          begin
-            if use_override
-              merged.public_send(:"#{attr_name}=", override_val)
-            elsif base_val
-              merged.public_send(:"#{attr_name}=", base_val)
-            end
-          rescue StandardError => e
-            Uniword.logger&.debug do
-              "Skipping attribute #{attr_name}: #{e.message}"
-            end
-          end
+          value = use_override ? override_val : base_val
+          next unless value
+
+          merged.public_send(:"#{attr_name}=", value)
         end
 
         merged

data/lib/uniword/wordprocessingml/style.rb

@@ -251,10 +251,6 @@ module Uniword
       def run_properties
         rPr
       end
-
-      def to_xml(options = {})
-        super
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uniword
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.9
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-08 00:00:00.000000000 Z
+date: 2026-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -771,6 +771,7 @@ files:
 - lib/uniword/diff/package_diff_result.rb
 - lib/uniword/diff/package_differ.rb
 - lib/uniword/document_factory.rb
+- lib/uniword/document_input.rb
 - lib/uniword/document_variables.rb
 - lib/uniword/document_variables/data_type.rb
 - lib/uniword/document_variables/default_value.rb
@@ -966,6 +967,7 @@ files:
 - lib/uniword/glossary/glossary_document.rb
 - lib/uniword/glossary/style_id.rb
 - lib/uniword/glossary/text_box.rb
+- lib/uniword/has_run_position.rb
 - lib/uniword/header.rb
 - lib/uniword/headers_footers.rb
 - lib/uniword/headers_footers/manager.rb
@@ -1157,7 +1159,6 @@ files:
 - lib/uniword/ooxml/types/dcterms_modified_type.rb
 - lib/uniword/ooxml/types/dcterms_w3cdtf_type.rb
 - lib/uniword/ooxml/types/mc_ignorable_type.rb
-- lib/uniword/ooxml/types/on_off_type.rb
 - lib/uniword/ooxml/types/ooxml_boolean.rb
 - lib/uniword/ooxml/types/ooxml_boolean_optional.rb
 - lib/uniword/ooxml/types/relationship_id.rb
@@ -1232,6 +1233,7 @@ files:
 - lib/uniword/properties/auto_space_de.rb
 - lib/uniword/properties/auto_space_dn.rb
 - lib/uniword/properties/bold.rb
+- lib/uniword/properties/boolean_element_factory.rb
 - lib/uniword/properties/boolean_formatting.rb
 - lib/uniword/properties/border.rb
 - lib/uniword/properties/borders.rb

data/lib/uniword/ooxml/types/on_off_type.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Uniword
-  module Ooxml
-    module Types
-      # OOXML On/Off (boolean) type for attributes.
-      #
-      # OOXML uses "0" and "1" for boolean attribute values, not "false"/"true".
-      # When an attribute is not present (nil), it should remain nil, not be
-      # serialized as "0". This preserves the original document structure.
-      #
-      # @example Serialize a boolean attribute
-      #   # Ruby true → XML "1"
-      #   # Ruby false → XML "0"
-      #   # Ruby nil → attribute not rendered
-      class OnOffType < Lutaml::Model::Type::String
-        # Bypass parent's initialize to avoid infinite recursion.
-        # Parent calls self.class.cast(value) which calls self.new(value).
-        def initialize(value)
-          @value = value
-        end
-
-        # Cast value to OnOffType instance (for attribute serialization).
-        # nil remains nil (not present in source), preserving original structure.
-        # Already-wrapped OnOffType instances are returned as-is.
-        def self.cast(value, _options = {})
-          return nil if value.nil?
-          return value if value.is_a?(OnOffType)
-
-          raw = case value
-                when true, "true", "1", 1
-                  true
-                when false, "false", "0", 0
-                  false
-                else
-                  false
-                end
-          new(raw)
-        end
-
-        # Convert stored boolean to OOXML "1" or "0"
-        def to_xml
-          return nil if @value.nil?
-
-          @value == true ? "1" : "0"
-        end
-
-        # Fallback to_s also returns "1"/"0" for compatibility
-        def to_s
-          return "" if @value.nil?
-
-          to_xml
-        end
-
-        # Return the raw boolean value for Ruby comparisons
-        def to_bool
-          @value == true
-        end
-      end
-    end
-  end
-end