uniword 1.0.11 → 1.2.4

data/lib/uniword/ooxml/relationships/package_relationships.rb

@@ -24,6 +24,13 @@ module Uniword
         # Generate package-level .rels file
         #
         # @return [PackageRelationships] Relationships object for _rels/.rels
+        def self.next_available_rid(relationships)
+          max = relationships.relationships.filter_map do |r|
+            r.id[/\ArId(\d+)\z/, 1]&.to_i
+          end.max || 0
+          "rId#{max + 1}"
+        end
+
         def self.generate_package_rels
           new(
             relationships: [

data/lib/uniword/presentationml/slide_id.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "../properties/relationship_id"
 
 module Uniword
   module Presentationml

data/lib/uniword/presentationml/slide_master_id.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "../properties/relationship_id"
 
 module Uniword
   module Presentationml

data/lib/uniword/properties/bold.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "boolean_element_factory"
-
 module Uniword
   module Properties
     BooleanElementFactory.define("b", "Bold")

data/lib/uniword/properties/boolean_formatting.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "boolean_element_factory"
-
 module Uniword
   module Properties
     # Run-level boolean formatting elements

data/lib/uniword/properties/borders.rb

@@ -28,8 +28,8 @@ module Uniword
         namespace Ooxml::Namespaces::WordProcessingML
 
         map_element "top", to: :top, render_nil: false
-        map_element "bottom", to: :bottom, render_nil: false
         map_element "left", to: :left, render_nil: false
+        map_element "bottom", to: :bottom, render_nil: false
         map_element "right", to: :right, render_nil: false
         map_element "between", to: :between, render_nil: false
         map_element "bar", to: :bar, render_nil: false

data/lib/uniword/properties/italic.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "boolean_element_factory"
-
 module Uniword
   module Properties
     BooleanElementFactory.define("i", "Italic")

data/lib/uniword/properties/numbering_properties.rb

@@ -17,8 +17,8 @@ module Uniword
         element "numPr"
         namespace Ooxml::Namespaces::WordProcessingML
 
-        map_element "numId", to: :num_id, render_nil: false
         map_element "ilvl", to: :ilvl, render_nil: false
+        map_element "numId", to: :num_id, render_nil: false
       end
     end
   end

data/lib/uniword/properties/style_reference.rb

@@ -17,6 +17,19 @@ module Uniword
         map_attribute "val", to: :value
       end
 
+      # Cast raw style-id strings into references (mirrors Text.cast), so
+      # `properties.style = "Heading1"` stores a proper StyleReference
+      def self.cast(value)
+        case value
+        when StyleReference, nil
+          value
+        when String
+          new(value: value)
+        else
+          super
+        end
+      end
+
       # Compare with another StyleReference or a string
       def ==(other)
         if other.is_a?(StyleReference)

data/lib/uniword/quality/rules/heading_hierarchy_rule.rb

@@ -72,7 +72,7 @@ module Uniword
       # @param paragraph [Paragraph] The paragraph to check
       # @return [Integer, nil] Heading level (1-9) or nil if not a heading
       def extract_heading_level(paragraph)
-        style_name = paragraph.properties&.style
+        style_name = paragraph.style
         return nil unless style_name
 
         match = style_name.to_s.match(HEADING_PATTERN)

data/lib/uniword/quality/rules/style_consistency_rule.rb

@@ -76,7 +76,7 @@ module Uniword
       # @param paragraph [Paragraph] The paragraph to check
       # @return [Boolean] true if has style
       def has_style?(paragraph)
-        style = paragraph.properties&.style
+        style = paragraph.style
         style&.value && !style.value.empty?
       end
 

data/lib/uniword/review/review_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "accept_reject"
-
 module Uniword
   module Review
     # Orchestrator for comments and tracked changes in a document.

data/lib/uniword/template/helpers/loop_helper.rb

@@ -105,12 +105,12 @@ module Uniword
           # recursively process all text nodes
           return unless element.is_a?(Uniword::Wordprocessingml::Run)
 
-          text = element.text
+          text = element.text_string
           # Simple variable replacement ({{var}})
           text.scan(/\{\{([^@].+?)\}\}/).each do |match|
             var_name = match[0]
             value = resolver.resolve(var_name)
-            element.text = text.gsub("{{#{var_name}}}", value.to_s)
+            element.substitute("{{#{var_name}}}", value.to_s)
           end
         end
       end

data/lib/uniword/template/variable_resolver.rb

@@ -175,7 +175,20 @@ module Uniword
 
         return false if left_num.nil? || right_num.nil?
 
-        left_num.public_send(operator, right_num)
+        case operator
+        when :== then left_num == right_num
+        when :!= then left_num != right_num
+        when :>  then left_num > right_num
+        when :>= then left_num >= right_num
+        when :<  then left_num < right_num
+        when :<= then left_num <= right_num
+        when :+  then left_num + right_num
+        when :-  then left_num - right_num
+        when :*  then left_num * right_num
+        when :/  then left_num / right_num
+        else
+          raise ArgumentError, "Unsupported operator: #{operator.inspect}"
+        end
       end
 
       # Convert value to number

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.public_send(:"#{attr_name}=", color_obj)
+          scheme.assign_color_by_name(attr_name, color_obj)
         end
 
         # Sync hash interface

data/lib/uniword/toc/toc_generator.rb

@@ -142,14 +142,7 @@ module Uniword
       # @param paragraph [Wordprocessingml::Paragraph] Paragraph to inspect
       # @return [String, nil] Style name or nil
       def resolve_style_name(paragraph)
-        style_ref = paragraph.properties&.style
-        return nil unless style_ref
-
-        if style_ref.is_a?(Uniword::Properties::StyleReference)
-          style_ref.value
-        else
-          style_ref.to_s
-        end
+        paragraph.style&.value
       end
 
       # Extract text content from a paragraph.
@@ -197,9 +190,7 @@ module Uniword
       def build_title_paragraph
         para = Wordprocessingml::Paragraph.new
         para.properties = Wordprocessingml::ParagraphProperties.new
-        para.properties.style = Uniword::Properties::StyleReference.new(
-          value: "TOCHeading",
-        )
+        para.properties.style = "TOCHeading"
 
         run = Wordprocessingml::Run.new
         run.text = "Table of Contents"
@@ -251,9 +242,7 @@ module Uniword
       def build_entry_paragraph(entry)
         para = Wordprocessingml::Paragraph.new
         para.properties = Wordprocessingml::ParagraphProperties.new
-        para.properties.style = Uniword::Properties::StyleReference.new(
-          value: "TOC#{entry.level}",
-        )
+        para.properties.style = "TOC#{entry.level}"
 
         run = Wordprocessingml::Run.new
         run.text = entry.text

data/lib/uniword/transformation/mhtml_element_renderer.rb

@@ -69,7 +69,8 @@ module Uniword
       # Convert OOXML Run to HTML
       def run_to_html(run)
         # Handle breaks and drawings first (these never get style wrapping)
-        return break_to_html(run.break) if run.break
+        # (parsed runs hold [] for absent collections, so check emptiness)
+        return break_to_html(run.break) if Array(run.break).any?
         if run.drawings && !run.drawings.empty?
           return drawing_to_html(run.drawings.first)
         end
@@ -105,7 +106,8 @@ module Uniword
             # Skip wrapping for internal OOXML styles that shouldn't produce
             # visible HTML class wrappers
             is_internal_style = %w[stem hyperlink].include?(style_id)
-            is_stem_spacer = (style_id == "stem") && run.text.to_s.strip.empty?
+            is_stem_spacer = (style_id == "stem") &&
+              run.text_string.strip.empty?
             unless is_internal_style || is_stem_spacer
               style_val = run_style_to_class(props.style.value)
               content = %(<span class="#{style_val}">#{content}</span>)
@@ -125,7 +127,7 @@ module Uniword
         elsif run.tab
           tab_to_html(run)
         else
-          text = run.text.to_s
+          text = run.text_string
           return "" if text.empty?
 
           escape_html(text)
@@ -142,13 +144,15 @@ module Uniword
         %(<span class="MsoEndnoteReference"><span style="mso-special-character:endnote"></span></span>)
       end
 
-      # Convert OOXML Break to HTML
-      def break_to_html(brk)
-        if brk.type == "page"
-          %(<br clear="all" style="mso-special-character:line-break;page-break-before:always" />)
-        else
-          %(<br />)
-        end
+      # Convert OOXML Breaks to HTML, one <br> per Break element
+      def break_to_html(breaks)
+        Array(breaks).map do |brk|
+          if brk.type == "page"
+            %(<br clear="all" style="mso-special-character:line-break;page-break-before:always" />)
+          else
+            %(<br />)
+          end
+        end.join
       end
 
       # Convert OOXML FieldChar to HTML span
@@ -272,7 +276,9 @@ module Uniword
         end
       end
 
-      # Convert OOXML OMath to HTML (wrapped in stem span)
+      # Convert an OOXML OMath model to HTML (wrapped in stem span).
+      # Accepts Omml::Models::CTOMath/OMath/OMathPara (the typed attribute
+      # values on Paragraph) — anything responding to `to_xml` works.
       def omath_to_html(o_math)
         xml = o_math.to_xml
         # Strip XML declaration and namespace prefixes for clean inline HTML
@@ -491,23 +497,87 @@ module Uniword
 
       private
 
-      # Get paragraph content including runs, hyperlinks, SDTs, and oMath
-      # Interleaves all element types in correct order using position markers.
+      # Render paragraph content (runs, hyperlinks, SDTs, oMath) in the
+      # document order captured by `paragraph.element_order`.
+      #
+      # Walking element_order (rather than `build_position_map` keyed on
+      # run_position) keeps MHTML positioning in lockstep with the DOCX
+      # serializer, which is the single source of truth for interleaving.
+      # It also handles inline math, which is now an Omml::Models::CTOMath
+      # instance without a run_position attribute.
       def paragraph_content_to_html(paragraph)
+        order = paragraph.element_order
+        return paragraph_content_to_html_legacy(paragraph) if order.nil? || order.empty?
+
+        run_idx = 0
+        hl_idx = 0
+        omath_idx = 0
+        omp_idx = 0
+        sdt_idx = 0
+
+        parts = []
+        order.each do |entry|
+          next unless entry.element?
+
+          case entry.name
+          when "r"
+            collect_run_at(paragraph, run_idx, parts)
+            run_idx += 1
+          when "hyperlink"
+            hl = paragraph.hyperlinks[hl_idx]
+            parts << hyperlink_to_html(hl) if hl
+            hl_idx += 1
+          when "oMath"
+            om = paragraph.o_maths[omath_idx]
+            parts << omath_to_html(om) if om
+            omath_idx += 1
+          when "oMathPara"
+            omp = paragraph.o_math_paras[omp_idx]
+            parts << omath_to_html(omp) if omp
+            omp_idx += 1
+          when "sdt"
+            sdt = paragraph.sdts[sdt_idx]
+            parts << sdt_to_inline_html(sdt) if sdt
+            sdt_idx += 1
+          end
+        end
+
+        # Defensive: emit any math/SDTs not represented in element_order.
+        paragraph.o_math_paras.each_with_index do |omp, i|
+          next if i < omp_idx
+
+          parts << omath_to_html(omp)
+        end
+        paragraph.sdts.each_with_index do |sdt, i|
+          next if i < sdt_idx
+
+          parts << sdt_to_inline_html(sdt)
+        end
+
+        parts.join
+      end
+
+      def collect_run_at(paragraph, idx, parts)
+        run = paragraph.runs[idx]
+        return unless run
+
+        parts << if run.is_a?(Uniword::Wordprocessingml::StructuredDocumentTag)
+                   sdt_to_inline_html(run)
+                 else
+                   run_to_html(run)
+                 end
+      end
+
+      # Fallback for Paragraphs constructed without element_order tracking
+      # (older code paths). Preserves the previous behavior of appending
+      # inline math/hyperlinks at the end.
+      def paragraph_content_to_html_legacy(paragraph)
         run_count = paragraph.runs.size
 
-        # Build position-indexed maps of hyperlinks and oMaths
         hl_by_pos = build_position_map(paragraph.hyperlinks, run_count)
-        omath_by_pos = build_position_map(paragraph.o_maths, run_count)
 
         parts = []
         paragraph.runs.each_with_index do |run, idx|
-          # Insert any oMaths that should appear at this position
-          if omath_by_pos.key?(idx)
-            omath_by_pos[idx].each { |om| parts << omath_to_html(om) }
-          end
-
-          # Insert any hyperlinks that should appear at this position
           if hl_by_pos.key?(idx)
             hl_by_pos[idx].each { |hl| parts << hyperlink_to_html(hl) }
           end
@@ -519,26 +589,13 @@ module Uniword
                    end
         end
 
-        # Append any remaining oMaths at the end
-        if omath_by_pos.key?(run_count)
-          omath_by_pos[run_count].each { |om| parts << omath_to_html(om) }
-        end
-
-        # Append any remaining hyperlinks at the end
         if hl_by_pos.key?(run_count)
           hl_by_pos[run_count].each { |hl| parts << hyperlink_to_html(hl) }
         end
 
-        paragraph.o_math_paras.each do |omp|
-          # Block math: render each oMath inside the oMathPara
-          omp.o_maths.each do |om|
-            parts << omath_to_html(om)
-          end
-        end
-
-        paragraph.sdts.each do |sdt|
-          parts << sdt_to_inline_html(sdt)
-        end
+        paragraph.o_maths.each { |om| parts << omath_to_html(om) }
+        paragraph.o_math_paras.each { |omp| parts << omath_to_html(omp) }
+        paragraph.sdts.each { |sdt| parts << sdt_to_inline_html(sdt) }
 
         parts.join
       end

data/lib/uniword/transformation/mhtml_metadata_builder.rb

@@ -184,7 +184,7 @@ module Uniword
           para_chars = 0
 
           element.runs.each do |run|
-            text = run.text.to_s
+            text = run.text_string
             characters += text.length
             para_chars += text.length
             words += text.split.length

data/lib/uniword/transformation/ooxml_to_html_converter.rb

@@ -54,7 +54,7 @@ module Uniword
       # @param run [Uniword::Wordprocessingml::Run]
       # @return [String] HTML text content with inline formatting
       def self.run_to_html(run)
-        text = escape_html(run.text || "")
+        text = escape_html(run.text_string)
         return text if text.empty?
 
         props = run.properties
@@ -135,12 +135,10 @@ module Uniword
       # @param paragraph [Uniword::Wordprocessingml::Paragraph]
       # @return [String] HTML class/style attribute or empty string
       def self.paragraph_style(paragraph)
-        return "" unless paragraph.properties
-
-        style = paragraph.properties.style
+        style = paragraph.style
         return "" unless style
 
-        " class=\"#{escape_html(style)}\""
+        " class=\"#{escape_html(style.to_s)}\""
       end
 
       # Convert OOXML font size (half-points) to HTML font size

data/lib/uniword/validation/checkers/internal_link_checker.rb

@@ -133,10 +133,9 @@ module Uniword
           return [] unless document.is_a?(Uniword::Wordprocessingml::DocumentRoot)
 
           document.paragraphs.select do |p|
-            p.is_a?(Lutaml::Model::Serializable) && p.class.attributes.key?(:style) && p.style&.match?(/^Heading/)
+            p.style&.to_s&.match?(/^Heading/)
           end.filter_map do |p|
-            # Generate bookmark from heading text
-            p.is_a?(Lutaml::Model::Serializable) && p.class.attributes.key?(:text) ? heading_to_bookmark(p.text) : nil
+            heading_to_bookmark(p.text)
           end
         end
 

data/lib/uniword/version.rb

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

data/lib/uniword/visitor/text_extractor.rb

@@ -103,7 +103,8 @@ module Uniword
       # @param run [Run] The run to visit
       # @return [void]
       def visit_run(run)
-        @text_parts << run.text if run.text
+        text = run.text_string
+        @text_parts << text unless text.empty?
       end
 
       # Visit an image element.

data/lib/uniword/watermark/manager.rb

@@ -108,11 +108,11 @@ module Uniword
         return false unless paragraph.properties
         return false unless paragraph.properties.is_a?(Uniword::Wordprocessingml::ParagraphProperties)
 
-        paragraph.properties.style.to_s == "UniwordWatermark"
+        paragraph.style == "UniwordWatermark"
       end
 
       def extract_watermark_text(paragraph)
-        paragraph.runs.map { |r| r.text.to_s }.join
+        paragraph.runs.map(&:text_string).join
       end
     end
   end

data/lib/uniword/wordprocessingml/allow_png.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Wordprocessingml
+    class AllowPng < Lutaml::Model::Serializable
+      xml do
+        element "allowPNG"
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/body.rb

@@ -66,53 +66,70 @@ module Uniword
         sync_element_order
       end
 
+      # Record a programmatically-added element in element_order.
+      # Called by DocumentBuilder to preserve insertion order when
+      # interleaving paragraphs, tables, and SDTs.
+      def append_to_element_order(element_name)
+        entry = Lutaml::Xml::Element.new("Element", element_name)
+        if element_order.nil? || element_order.empty?
+          self.element_order = [entry]
+        else
+          self.element_order = element_order + [entry]
+        end
+      end
+
       private
 
       def sync_element_order
         return if element_order.nil? || element_order.empty?
 
-        counts = element_order.each_with_object(Hash.new(0)) do |e, h|
-          h[e.name] += 1
-        end
-
-        needed = false
-        needed = true if paragraphs.size > counts["p"]
-        needed = true if tables.size > counts["tbl"]
-        needed = true if structured_document_tags.size > counts["sdt"]
-        needed = true if bookmark_starts.size > counts["bookmarkStart"]
-        needed = true if bookmark_ends.size > counts["bookmarkEnd"]
-        needed = true if section_properties && counts["sectPr"].zero?
+        # lutaml-model freezes element_order after XML parsing.
+        # Build a mutable copy to append missing elements.
+        new_entries = []
 
-        return unless needed
-
-        dup_element_order_if_frozen
+        # 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
 
-        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"])
+        # Collect missing paragraphs
+        (paragraphs.size - ordered_p_count).times do
+          new_entries << Lutaml::Xml::Element.new("Element", "p")
+        end
 
-        return unless section_properties && counts["sectPr"].zero?
+        # Collect missing tables
+        (tables.size - ordered_tbl_count).times do
+          new_entries << Lutaml::Xml::Element.new("Element", "tbl")
+        end
 
-        element_order << build_order_element("sectPr")
-      end
+        # Collect missing structured document tags
+        (structured_document_tags.size - ordered_sdt_count).times do
+          new_entries << Lutaml::Xml::Element.new("Element", "sdt")
+        end
 
-      def dup_element_order_if_frozen
-        return unless element_order.frozen?
+        # Collect missing bookmark starts
+        (bookmark_starts.size - ordered_bookmark_start_count).times do
+          new_entries << Lutaml::Xml::Element.new("Element", "bookmarkStart")
+        end
 
-        self.element_order = element_order.dup
-      end
+        # Collect missing bookmark ends
+        (bookmark_ends.size - ordered_bookmark_end_count).times do
+          new_entries << Lutaml::Xml::Element.new("Element", "bookmarkEnd")
+        end
 
-      def append_missing_elements(name, count)
-        count.times { element_order << build_order_element(name) }
-      end
+        # Ensure section_properties is in element_order if present
+        if section_properties && element_order.none? { |e| e.name == "sectPr" }
+          new_entries << Lutaml::Xml::Element.new("Element", "sectPr")
+        end
 
-      def build_order_element(name)
-        Lutaml::Xml::Element.new("Element", name)
+        # Replace frozen array with mutable copy containing new entries
+        self.element_order = element_order + new_entries unless new_entries.empty?
       end
     end
   end

data/lib/uniword/wordprocessingml/body_div.rb

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

data/lib/uniword/wordprocessingml/div_border.rb

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