uniword 1.0.8 → 1.0.10

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,66 @@
+# 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.
+    module BooleanValSetter
+      def self.included(base)
+        base.define_method(:val=) do |v|
+          @val = case v
+                 when nil then nil
+                 when false, "false" then "false"
+                 when true, "true" then nil
+                 else v
+                 end
+          value_set_for(:val)
+        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,224 +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
-    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)
-          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/schema/schema_loader.rb

@@ -85,6 +85,6 @@ module Uniword
     end
 
     # Raised when a schema file cannot be found
-    class SchemaNotFoundError < StandardError; end
+    class SchemaNotFoundError < Uniword::Error; end
   end
 end

data/lib/uniword/transformation/mhtml_element_renderer.rb

@@ -547,7 +547,7 @@ module Uniword
       def build_position_map(elements, fallback_pos)
         by_pos = {}
         elements.each do |el|
-          pos = el.run_position if el.is_a?(Uniword::Wordprocessingml::Hyperlink) || el.is_a?(Uniword::Math::OMath)
+          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.8"
+  VERSION = "1.0.10"
 end

data/lib/uniword/wordprocessingml/attached_template.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "../properties/relationship_id"
+
+module Uniword
+  module Wordprocessingml
+    class AttachedTemplate < Lutaml::Model::Serializable
+      attribute :r_id, Properties::RelationshipIdValue
+
+      xml do
+        element "attachedTemplate"
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        map_attribute "id", to: :r_id
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/body.rb

@@ -71,48 +71,30 @@ module Uniword
       def sync_element_order
         return if element_order.nil? || element_order.empty?
 
-        # Count how many p/tbl/sdt entries exist in element_order
-        ordered_p_count = element_order.count { |e| e.name == "p" }
-        ordered_tbl_count = element_order.count { |e| e.name == "tbl" }
-        ordered_sdt_count = element_order.count { |e| e.name == "sdt" }
-        ordered_bookmark_start_count = element_order.count do |e|
-          e.name == "bookmarkStart"
-        end
-        ordered_bookmark_end_count = element_order.count do |e|
-          e.name == "bookmarkEnd"
-        end
-
-        # Add missing paragraphs
-        (paragraphs.size - ordered_p_count).times do
-          element_order << Lutaml::Xml::Element.new("Element", "p")
+        counts = element_order.each_with_object(Hash.new(0)) do |e, h|
+          h[e.name] += 1
         end
 
-        # Add missing tables
-        (tables.size - ordered_tbl_count).times do
-          element_order << Lutaml::Xml::Element.new("Element", "tbl")
-        end
+        append_missing_elements("p", paragraphs.size - counts["p"])
+        append_missing_elements("tbl", tables.size - counts["tbl"])
+        append_missing_elements("sdt",
+                                structured_document_tags.size - counts["sdt"])
+        append_missing_elements("bookmarkStart",
+                                bookmark_starts.size - counts["bookmarkStart"])
+        append_missing_elements("bookmarkEnd",
+                                bookmark_ends.size - counts["bookmarkEnd"])
 
-        # Add missing structured document tags
-        (structured_document_tags.size - ordered_sdt_count).times do
-          element_order << Lutaml::Xml::Element.new("Element", "sdt")
-        end
+        return unless section_properties && counts["sectPr"].zero?
 
-        # Add missing bookmark starts
-        (bookmark_starts.size - ordered_bookmark_start_count).times do
-          element_order << Lutaml::Xml::Element.new("Element", "bookmarkStart")
-        end
-
-        # Add missing bookmark ends
-        (bookmark_ends.size - ordered_bookmark_end_count).times do
-          element_order << Lutaml::Xml::Element.new("Element", "bookmarkEnd")
-        end
+        element_order << build_order_element("sectPr")
+      end
 
-        # Ensure section_properties is in element_order if present
-        return unless section_properties && element_order.none? do |e|
-          e.name == "sectPr"
-        end
+      def append_missing_elements(name, count)
+        count.times { element_order << build_order_element(name) }
+      end
 
-        element_order << Lutaml::Xml::Element.new("Element", "sectPr")
+      def build_order_element(name)
+        Lutaml::Xml::Element.new("Element", name)
       end
     end
   end

data/lib/uniword/wordprocessingml/brk_bin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Wordprocessingml
+    class BrkBin < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element "brkBin"
+        namespace Uniword::Ooxml::Namespaces::MathML
+        map_attribute "val", to: :val
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/brk_bin_sub.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Wordprocessingml
+    class BrkBinSub < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element "brkBinSub"
+        namespace Uniword::Ooxml::Namespaces::MathML
+        map_attribute "val", to: :val
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/character_spacing_control.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Wordprocessingml
+    class CharacterSpacingControl < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        element "characterSpacingControl"
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        map_attribute "val", to: :val
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/clr_scheme_mapping.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Wordprocessingml
+    class ClrSchemeMapping < Lutaml::Model::Serializable
+      attribute :bg1, :string
+      attribute :t1, :string
+      attribute :bg2, :string
+      attribute :t2, :string
+      attribute :accent1, :string
+      attribute :accent2, :string
+      attribute :accent3, :string
+      attribute :accent4, :string
+      attribute :accent5, :string
+      attribute :accent6, :string
+      attribute :hyperlink, :string
+      attribute :followed_hyperlink, :string
+
+      xml do
+        element "clrSchemeMapping"
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        map_attribute "bg1", to: :bg1
+        map_attribute "t1", to: :t1
+        map_attribute "bg2", to: :bg2
+        map_attribute "t2", to: :t2
+        map_attribute "accent1", to: :accent1
+        map_attribute "accent2", to: :accent2
+        map_attribute "accent3", to: :accent3
+        map_attribute "accent4", to: :accent4
+        map_attribute "accent5", to: :accent5
+        map_attribute "accent6", to: :accent6
+        map_attribute "hyperlink", to: :hyperlink
+        map_attribute "followedHyperlink", to: :followed_hyperlink
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/compat.rb

@@ -14,12 +14,25 @@ module Uniword
       end
     end
 
+    # Do not use HTML paragraph auto spacing (empty marker element)
+    #
+    # Element: <w:doNotUseHTMLParagraphAutoSpacing>
+    # Parent: <w:compat>
+    class DoNotUseHTMLParagraphAutoSpacing < Lutaml::Model::Serializable
+      xml do
+        element "doNotUseHTMLParagraphAutoSpacing"
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+      end
+    end
+
     # Compatibility settings
     #
     # Generated from OOXML schema: wordprocessingml.yml
     # Element: <w:compat>
     class Compat < Lutaml::Model::Serializable
       attribute :use_fe_layout, UseFELayout
+      attribute :do_not_use_html_paragraph_auto_spacing,
+                DoNotUseHTMLParagraphAutoSpacing
       attribute :compatSetting, CompatSetting, collection: true,
                                                initialize_empty: true
 
@@ -29,6 +42,9 @@ module Uniword
         mixed_content
 
         map_element "useFELayout", to: :use_fe_layout, render_nil: false
+        map_element "doNotUseHTMLParagraphAutoSpacing",
+                    to: :do_not_use_html_paragraph_auto_spacing,
+                    render_nil: false
         map_element "compatSetting", to: :compatSetting, render_nil: false
       end
     end