uniword 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3edc29b5332204a6bf88fdd016239deab4b9694b8f02a823482fc0d5c3e857b
-  data.tar.gz: b02521733dd3189181864a89824e30c23eb04cd2112abaded49e6bf8643a43b9
+  metadata.gz: 34ddbf784b5b85ba8aedc6b4df9b255763e2b8014bcdea0124563e261555b32b
+  data.tar.gz: e4ef3fce0529a6db2642cbf547c28628512834339ce636f15d90c30dccba7eb2
 SHA512:
-  metadata.gz: ee58e9718495648ea4516db97b921cb973e79787b5745cb852593614f1ab136716f7fceecf7de9a8b093f1dd361c43282cb3841dd9acd6b32c51f3c0d6afd2ff
-  data.tar.gz: d55e30fb35e6b199429a8f1d5379319945a281bc2a81f132b2f2efe558ee212cc33c4af90a0fd2884cd211414a34faad9269b0fa44d75005d3cb61bc10cfd00f
+  metadata.gz: ae06c93c3b13ffffc70b0bddc7137945e4a035f2a4f75e315406547166c4423cdfe8ff8835b47ae5df50be9c6a021f500b89bd17512ae646cb3dd4c890bf8d8b
+  data.tar.gz: 7a37bcf5e4cc1ece3a92ad962757a48613be7f960890bd52017dcf8343bb1989172c7b9bd931a384dfe4bcee58c24de27b80b76e9dd4d3eca09280b078f8e3f1

data/lib/uniword/builder/chart_builder.rb

@@ -28,13 +28,16 @@ module Uniword
     #   end
     class ChartBuilder
       CHART_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart"
+      DRAWINGML_MAIN_NS =
+        "http://schemas.openxmlformats.org/drawingml/2006/main"
+      OFFICE_DOCUMENT_RELS_NS =
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
       CHART_REL_TYPE = Ooxml::PartRegistry.find_by_key(:chart).rel_type
       CHART_CONTENT_TYPE =
         Ooxml::PartRegistry.find_by_key(:chart).content_type
 
-      attr_reader :chart_type, :title_text, :series_list
-
-      attr_reader :show_legend, :width, :height, :series_list
+      attr_reader :chart_type, :title_text, :series_list, :show_legend, :width,
+                  :height
 
       def initialize(chart_type: :bar)
         @chart_type = chart_type
@@ -101,16 +104,15 @@ module Uniword
       #
       # @return [String] Chart XML
       def build_xml
-        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-          xml["c"].chartSpace("xmlns:c" => CHART_NS,
-                              "xmlns:a" =>
-                                "http://schemas.openxmlformats.org/drawingml/2006/main",
-                              "xmlns:r" =>
-                                "http://schemas.openxmlformats.org/officeDocument/2006/relationships") do
-            build_chart_xml(xml)
-          end
-        end
-        builder.to_xml
+        @document = Moxml.new.create_document
+        @document.add_child(@document.create_declaration("1.0", "UTF-8"))
+        root = @document.create_element("c:chartSpace")
+        root.add_namespace("c", CHART_NS)
+        root.add_namespace("a", DRAWINGML_MAIN_NS)
+        root.add_namespace("r", OFFICE_DOCUMENT_RELS_NS)
+        @document.root = root
+        build_chart(root)
+        @document.to_xml
       end
 
       # Register chart on a document and create the Drawing element
@@ -147,166 +149,159 @@ module Uniword
       include DeterministicId
 
       # Build the inner chart XML
-      def build_chart_xml(xml)
-        xml["c"].chart do
-          if @title_text
-            xml["c"].title do
-              xml["c"].tx do
-                xml["c"].rich do
-                  xml["a"].bodyPr
-                  xml["a"].lstStyle
-                  xml["a"].p do
-                    xml["a"].r do
-                      xml["a"].t(@title_text)
-                    end
-                  end
-                end
-              end
-              xml["c"].overlay("val" => "0")
-            end
-          end
-
-          xml["c"].autoTitleDeleted("val" => "0")
-
-          xml["c"].plotArea do
-            build_chart_type(xml)
-
-            unless @chart_type == :pie
-              build_axis(xml, "catAx", "10", "b", "20")
-              build_axis(xml, "valAx", "20", "l", "10")
-            end
-          end
-
-          if @show_legend
-            xml["c"].legend do
-              xml["c"].legendPos("val" => @legend_position)
-              xml["c"].overlay("val" => "0")
-            end
-          end
-
-          xml["c"].plotVisOnly("val" => "1")
+      def build_chart(parent)
+        chart = add_element(parent, "c:chart")
+        if @title_text
+          title = add_element(chart, "c:title")
+          tx = add_element(title, "c:tx")
+          rich = add_element(tx, "c:rich")
+          add_element(rich, "a:bodyPr")
+          add_element(rich, "a:lstStyle")
+          p_el = add_element(rich, "a:p")
+          r_el = add_element(p_el, "a:r")
+          add_text(add_element(r_el, "a:t"), @title_text)
+          add_element(title, "c:overlay", "val" => "0")
+        end
+
+        add_element(chart, "c:autoTitleDeleted", "val" => "0")
+
+        plot_area = add_element(chart, "c:plotArea")
+        build_chart_type(plot_area)
+
+        unless @chart_type == :pie
+          build_axis(plot_area, "catAx", "10", "b", "20")
+          build_axis(plot_area, "valAx", "20", "l", "10")
+        end
+
+        if @show_legend
+          legend = add_element(chart, "c:legend")
+          add_element(legend, "c:legendPos", "val" => @legend_position)
+          add_element(legend, "c:overlay", "val" => "0")
         end
+
+        add_element(chart, "c:plotVisOnly", "val" => "1")
+        chart
       end
 
       # Build the specific chart type element
-      def build_chart_type(xml)
+      def build_chart_type(parent)
         case @chart_type
         when :bar
-          xml["c"].barChart do
-            xml["c"].barDir("val" => "col")
-            xml["c"].grouping("val" => "clustered")
-            xml["c"].varyColors("val" => "0")
-            build_all_series(xml)
-            xml["c"].axId("val" => "10")
-            xml["c"].axId("val" => "20")
-          end
+          chart = add_element(parent, "c:barChart")
+          add_element(chart, "c:barDir", "val" => "col")
+          add_element(chart, "c:grouping", "val" => "clustered")
+          add_element(chart, "c:varyColors", "val" => "0")
+          build_all_series(chart)
+          add_element(chart, "c:axId", "val" => "10")
+          add_element(chart, "c:axId", "val" => "20")
         when :line
-          xml["c"].lineChart do
-            xml["c"].grouping("val" => "standard")
-            xml["c"].varyColors("val" => "0")
-            build_all_series(xml)
-            xml["c"].axId("val" => "10")
-            xml["c"].axId("val" => "20")
-          end
+          chart = add_element(parent, "c:lineChart")
+          add_element(chart, "c:grouping", "val" => "standard")
+          add_element(chart, "c:varyColors", "val" => "0")
+          build_all_series(chart)
+          add_element(chart, "c:axId", "val" => "10")
+          add_element(chart, "c:axId", "val" => "20")
         when :pie
-          xml["c"].pieChart do
-            xml["c"].varyColors("val" => "1")
-            build_all_series(xml)
-          end
+          chart = add_element(parent, "c:pieChart")
+          add_element(chart, "c:varyColors", "val" => "1")
+          build_all_series(chart)
         end
       end
 
       # Build all series XML blocks
-      def build_all_series(xml)
+      def build_all_series(parent)
         @series_list.each_with_index do |s, i|
-          build_series(xml, s, i)
+          build_series(parent, s, i)
         end
       end
 
       # Build a single series XML block
-      def build_series(xml, series, index)
-        xml["c"].ser do
-          xml["c"].idx("val" => index)
-          xml["c"].order("val" => index)
-          xml["c"].tx do
-            xml["c"].strRef do
-              xml["c"].f("Sheet1!$B$#{index + 1}")
-              xml["c"].strCache do
-                xml["c"].ptCount("val" => 1)
-                xml["c"].pt("idx" => 0) { xml["c"].v(series[:name]) }
-              end
-            end
-          end
-          build_categories(xml)
-          build_values(xml, series[:data])
-        end
+      def build_series(parent, series, index)
+        ser = add_element(parent, "c:ser")
+        add_element(ser, "c:idx", "val" => index)
+        add_element(ser, "c:order", "val" => index)
+        tx = add_element(ser, "c:tx")
+        str_ref = add_element(tx, "c:strRef")
+        add_text(add_element(str_ref, "c:f"), "Sheet1!$B$#{index + 1}")
+        str_cache = add_element(str_ref, "c:strCache")
+        add_element(str_cache, "c:ptCount", "val" => 1)
+        pt = add_element(str_cache, "c:pt", "idx" => 0)
+        add_text(add_element(pt, "c:v"), series[:name])
+        build_categories(ser)
+        build_values(ser, series[:data])
+        ser
       end
 
       # Build category data XML
-      def build_categories(xml)
+      def build_categories(parent)
         return if @categories.empty?
 
-        xml["c"].cat do
-          xml["c"].strRef do
-            xml["c"].f("Sheet1!$A$2:$A$100")
-            xml["c"].strCache do
-              xml["c"].ptCount("val" => @categories.size)
-              @categories.each_with_index do |cat, idx|
-                xml["c"].pt("idx" => idx) { xml["c"].v(cat) }
-              end
-            end
-          end
+        cat = add_element(parent, "c:cat")
+        str_ref = add_element(cat, "c:strRef")
+        add_text(add_element(str_ref, "c:f"), "Sheet1!$A$2:$A$100")
+        str_cache = add_element(str_ref, "c:strCache")
+        add_element(str_cache, "c:ptCount", "val" => @categories.size)
+        @categories.each_with_index do |category, idx|
+          pt = add_element(str_cache, "c:pt", "idx" => idx)
+          add_text(add_element(pt, "c:v"), category)
         end
       end
 
       # Build values data XML
-      def build_values(xml, data)
-        xml["c"].val do
-          xml["c"].numRef do
-            xml["c"].f("Sheet1!$C$2:$C$100")
-            xml["c"].numCache do
-              xml["c"].formatCode("General")
-              xml["c"].ptCount("val" => data.size)
-              data.each_with_index do |val, idx|
-                xml["c"].pt("idx" => idx) { xml["c"].v(val.to_s) }
-              end
-            end
-          end
+      def build_values(parent, data)
+        val = add_element(parent, "c:val")
+        num_ref = add_element(val, "c:numRef")
+        add_text(add_element(num_ref, "c:f"), "Sheet1!$C$2:$C$100")
+        num_cache = add_element(num_ref, "c:numCache")
+        add_text(add_element(num_cache, "c:formatCode"), "General")
+        add_element(num_cache, "c:ptCount", "val" => data.size)
+        data.each_with_index do |value, idx|
+          pt = add_element(num_cache, "c:pt", "idx" => idx)
+          add_text(add_element(pt, "c:v"), value.to_s)
         end
       end
 
       # Build a chart axis
-      def build_axis(xml, tag, id, position, cross_id)
+      def build_axis(parent, tag, id, position, cross_id)
         case tag
         when "catAx"
-          xml["c"].catAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:catAx"), id, position,
+                             cross_id)
         when "valAx"
-          xml["c"].valAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:valAx"), id, position,
+                             cross_id)
         when "serAx"
-          xml["c"].serAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:serAx"), id, position,
+                             cross_id)
         else
           raise ArgumentError, "Unknown axis type: #{tag}"
         end
       end
 
-      def write_axis_content(xml, id, position, cross_id)
-        xml["c"].axId("val" => id)
-        xml["c"].scaling do
-          xml["c"].orientation("val" => "minMax")
-        end
-        xml["c"].delete("val" => "0")
-        xml["c"].axPos("val" => position)
-        xml["c"].majorGridlines
-        xml["c"].numFmt("formatCode" => "General",
-                        "sourceLinked" => "1")
-        xml["c"].tickLblPos("val" => "nextTo")
-        xml["c"].crossAx("val" => cross_id)
+      def write_axis_content(axis, id, position, cross_id)
+        add_element(axis, "c:axId", "val" => id)
+        scaling = add_element(axis, "c:scaling")
+        add_element(scaling, "c:orientation", "val" => "minMax")
+        add_element(axis, "c:delete", "val" => "0")
+        add_element(axis, "c:axPos", "val" => position)
+        add_element(axis, "c:majorGridlines")
+        add_element(axis, "c:numFmt", "formatCode" => "General",
+                                      "sourceLinked" => "1")
+        add_element(axis, "c:tickLblPos", "val" => "nextTo")
+        add_element(axis, "c:crossAx", "val" => cross_id)
+      end
+
+      # Append an element with attributes to a parent node.
+      def add_element(parent, name, attributes = {})
+        element = @document.create_element(name)
+        attributes.each { |key, value| element[key] = value }
+        parent.add_child(element)
+        element
+      end
+
+      # Append a text node to a parent node.
+      def add_text(parent, content)
+        parent.add_child(@document.create_text(content))
       end
 
       # Create a Drawing element with chart reference

data/lib/uniword/diff/package_differ.rb

@@ -200,8 +200,8 @@ canon_profile: :spec_friendly)
       def compare_xml(part_name, old_xml, new_xml)
         changes = []
 
-        old_doc = Nokogiri::XML(old_xml)
-        new_doc = Nokogiri::XML(new_xml)
+        old_doc = Moxml.parse(old_xml)
+        new_doc = Moxml.parse(new_xml)
 
         # Compare namespace declarations
         changes.concat(
@@ -219,7 +219,7 @@ canon_profile: :spec_friendly)
         )
 
         changes
-      rescue Nokogiri::XML::SyntaxError
+      rescue Moxml::ParseError
         changes
       end
 
@@ -243,8 +243,8 @@ canon_profile: :spec_friendly)
                                    compression_name(new_e.compression_method)]
           end
 
-          old_text = old_e.internal_file_attributes & 1 != 0
-          new_text = new_e.internal_file_attributes & 1 != 0
+          old_text = old_e.internal_file_attributes.anybits?(1)
+          new_text = new_e.internal_file_attributes.anybits?(1)
           if old_text != new_text
             diffs[:internal_attr] = [old_text ? "text" : "binary",
                                      new_text ? "text" : "binary"]
@@ -361,7 +361,7 @@ canon_profile: :spec_friendly)
           return issues
         end
 
-        doc = Nokogiri::XML(rels_xml)
+        doc = Moxml.parse(rels_xml)
         doc.xpath("//xmlns:Relationship").each do |rel|
           target = rel["Target"]&.sub(%r{^/}, "")
           next unless target
@@ -376,7 +376,7 @@ canon_profile: :spec_friendly)
         end
 
         issues
-      rescue Nokogiri::XML::SyntaxError
+      rescue Moxml::ParseError
         issues
       end
 
@@ -386,7 +386,7 @@ canon_profile: :spec_friendly)
       # @return [Hash{String => String}, nil]
       def parse_content_types(zip)
         ct_xml = zip.read("[Content_Types].xml")
-        doc = Nokogiri::XML(ct_xml)
+        doc = Moxml.parse(ct_xml)
         overrides = {}
         doc.xpath("//xmlns:Override").each do |node|
           overrides[node["PartName"]] = node["ContentType"]
@@ -397,7 +397,7 @@ canon_profile: :spec_friendly)
         nil
       end
 
-      # --- Legacy structural comparison methods (kept for backward compat) ---
+      # --- Structural comparison methods ---
 
       # Compare namespace declarations between two XML documents.
       #
@@ -532,28 +532,29 @@ canon_profile: :spec_friendly)
 
       # Extract namespace prefix-to-URI mapping from an element.
       #
-      # @param element [Nokogiri::XML::Element]
+      # @param element [Moxml::Element]
       # @return [Hash{String => String}]
       def namespace_hash(element)
         return {} unless element
 
         result = {}
-        element.namespace_definitions.each do |ns|
+        element.namespaces.each do |ns|
           prefix = ns.prefix || ""
-          result[prefix] = ns.href
+          result[prefix] = ns.uri
         end
         result
       end
 
       # Extract attribute name-to-value mapping from an element.
       #
-      # @param element [Nokogiri::XML::Element]
+      # @param element [Moxml::Element]
       # @return [Hash{String => String}]
       def attribute_hash(element)
         return {} unless element
 
         result = {}
-        element.attributes.each do |name, attr|
+        element.attributes.each do |attr|
+          name = attr.name
           key = attr.namespace ? "#{attr.namespace.prefix}:#{name}" : name
           result[key] = attr.value
         end
@@ -562,7 +563,7 @@ canon_profile: :spec_friendly)
 
       # Count elements by qualified name.
       #
-      # @param doc [Nokogiri::XML::Document]
+      # @param doc [Moxml::Document]
       # @return [Hash{String => Integer}]
       def element_counts(doc)
         counts = Hash.new(0)

data/lib/uniword/docx/package_integrity_checker.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "nokogiri"
 require "set"
 
 module Uniword
@@ -83,15 +82,15 @@ module Uniword
       # Memoized strict parse of one entry.
       #
       # @param name [String] Entry path
-      # @return [Nokogiri::XML::Document, nil] Parsed document, or nil when
+      # @return [Moxml::Document, nil] Parsed document, or nil when
       #   the entry is malformed (OPC-008 already recorded)
       def parsed_part(name)
         return @parsed_parts[name] if @parsed_parts.key?(name)
 
         @parsed_parts[name] =
           begin
-            Nokogiri::XML(@content[name], &:strict)
-          rescue Nokogiri::XML::SyntaxError => e
+            Moxml.parse(@content[name])
+          rescue Moxml::ParseError => e
             add_issue("OPC-008", name,
                       "Malformed XML in #{name}: #{e.message}")
             nil
@@ -180,19 +179,19 @@ module Uniword
 
       # Collect (attribute local name, value) pairs for r:id/r:embed/r:link.
       #
-      # @param doc [Nokogiri::XML::Document] Parsed XML part
+      # @param doc [Moxml::Document] Parsed XML part
       # @return [Array<Array(String, String)>] Reference pairs
       def relationship_references(doc)
         refs = []
         doc.traverse do |node|
           next unless node.element?
 
-          node.attribute_nodes.each do |attr|
-            next unless attr.namespace&.href == OFFICE_RELS_NS
-            next unless R_REF_ATTRIBUTES.include?(attr.node_name)
+          node.attributes.each do |attr|
+            next unless attr.namespace&.uri == OFFICE_RELS_NS
+            next unless R_REF_ATTRIBUTES.include?(attr.name)
 
             value = attr.value
-            refs << [attr.node_name, value] unless value.empty?
+            refs << [attr.name, value] unless value.empty?
           end
         end
         refs
@@ -243,8 +242,8 @@ module Uniword
 
       # Relationship elements of a parsed .rels document.
       #
-      # @param doc [Nokogiri::XML::Document] Parsed .rels part
-      # @return [Nokogiri::XML::NodeSet] Relationship elements
+      # @param doc [Moxml::Document] Parsed .rels part
+      # @return [Moxml::NodeSet] Relationship elements
       def relationship_nodes(doc)
         doc.xpath("//xmlns:Relationship", "xmlns" => RELS_NS)
       end

data/lib/uniword/docx/reconciler/body.rb

@@ -87,6 +87,7 @@ module Uniword
               backfill_paragraphs(part.content.paragraphs, rsid,
                                   "#{abbrev}:#{idx}")
             end
+            ensure_w14_ignorable(part.content)
           end
         end
 

data/lib/uniword/docx/reconciler/helpers.rb

@@ -15,7 +15,7 @@ module Uniword
         # -- ID generation --
 
         def generate_rsid
-          "00#{hex_derive("rsid", 3)}"
+          "00#{hex_derive('rsid', 3)}"
         end
 
         def generate_hex_id(seed = 0)
@@ -24,7 +24,7 @@ module Uniword
 
         def hex_derive(seed, byte_count)
           Digest::SHA256.hexdigest(
-            "#{document_fingerprint}:#{seed}"
+            "#{document_fingerprint}:#{seed}",
           )[0...(byte_count * 2)].upcase
         end
 
@@ -43,7 +43,7 @@ module Uniword
 
         # -- Traversal --
 
-        def walk_body_paragraphs(body)
+        def walk_body_paragraphs(body, &block)
           if body.element_order && !body.element_order.empty?
             p_idx = 0
             tbl_idx = 0
@@ -54,18 +54,20 @@ module Uniword
                 p_idx += 1
               when "tbl"
                 if body.tables[tbl_idx]
-                  walk_table_paragraphs(body.tables[tbl_idx]) { |p| yield p }
+                  walk_table_paragraphs(body.tables[tbl_idx], &block)
                 end
                 tbl_idx += 1
               end
             end
           else
-            body.paragraphs.each { |p| yield p }
-            body.tables&.each { |tbl| walk_table_paragraphs(tbl) { |p| yield p } }
+            body.paragraphs.each(&block)
+            body.tables&.each do |tbl|
+              walk_table_paragraphs(tbl, &block)
+            end
           end
         end
 
-        def walk_body_tables(body)
+        def walk_body_tables(body, &block)
           return unless body
 
           if body.element_order && !body.element_order.empty?
@@ -77,7 +79,7 @@ module Uniword
               tbl_idx += 1
             end
           else
-            body.tables&.each { |tbl| yield tbl }
+            body.tables&.each(&block)
           end
         end
 
@@ -89,11 +91,12 @@ module Uniword
           end
         end
 
-        def walk_table_paragraphs(table)
+        def walk_table_paragraphs(table, &block)
           return unless table
+
           table.rows&.each do |row|
             row.cells&.each do |cell|
-              cell.paragraphs.each { |p| yield p }
+              cell.paragraphs.each(&block)
             end
           end
         end
@@ -152,6 +155,18 @@ module Uniword
           end
         end
 
+        # The paragraph backfill above emits w14:paraId/textId; part
+        # roots that never declared w14 ignorable must list it or
+        # strict MCE consumers reject those attributes.
+        def ensure_w14_ignorable(root)
+          prefixes = root.mc_ignorable.to_s.split(/\s+/)
+          return if prefixes.include?("w14")
+
+          root.mc_ignorable = Ooxml::Types::McIgnorable.new(
+            (prefixes + ["w14"]).join(" "),
+          )
+        end
+
         # Merge adjacent runs with identical formatting and consolidate
         # standalone tab/br runs into following text runs (F4 + F5).
         # Respects element_order: only merges runs that are truly adjacent
@@ -165,7 +180,7 @@ module Uniword
           runs[1..].each_with_index do |run, idx|
             prev = merged.last
             if run_indices.include?(idx) &&
-               run_properties_match?(prev, run) && can_merge?(prev, run)
+                run_properties_match?(prev, run) && can_merge?(prev, run)
               merge_run_into(prev, run)
             else
               merged << run
@@ -180,7 +195,7 @@ module Uniword
         # in element_order (no non-run elements between them).
         def adjacent_run_indices(paragraph)
           eo = paragraph.element_order
-          return (0...paragraph.runs.size - 1).to_a unless eo && !eo.empty?
+          return (0...(paragraph.runs.size - 1)).to_a unless eo && !eo.empty?
 
           indices = Set.new
           run_count = 0

data/lib/uniword/docx/reconciler/parts.rb

@@ -50,6 +50,11 @@ module Uniword
             val: profile.list_separator,
           )
 
+          # CT_Settings places w:rsids between w:compat and m:mathPr;
+          # fixtures carrying rsids last serialize it after the
+          # appended siblings and fail strict sequence validation.
+          Ooxml::ElementOrder.move_once(settings, "rsids", after: "compat")
+
           # w:updateFields set by the user/API: ensure it serializes —
           # parsed settings carry a stored element_order that lacks it.
           if settings.update_fields