uniword 1.2.5 → 1.4.0

data/lib/uniword/wordprocessingml/font_replacer.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Wordprocessingml
+    # Replaces one font family with another across a document —
+    # Word's Home → Replace → Replace Fonts as an API.
+    #
+    # Covers style definitions and defaults, body content (paragraphs,
+    # tables, hyperlinks), headers and footers, footnotes, endnotes,
+    # comments, and numbering levels. Theme font references
+    # (asciiTheme/hAnsiTheme/...) are NOT rewritten — those are
+    # controlled by the theme's font scheme
+    # (see DocumentRoot#apply_font_scheme).
+    #
+    # @example Replace Calibri with Carlito throughout a document
+    #   replacer = FontReplacer.new(from: "Calibri", to: "Carlito")
+    #   replacer.replace(document)
+    #   puts replacer.count # number of rFonts values rewritten
+    class FontReplacer
+      # RunFonts attributes rewritten by font replacement.
+      FONT_ATTRIBUTES = %i[ascii h_ansi east_asia cs].freeze
+
+      # Create a replacer.
+      #
+      # @param from [String] Font family to replace (exact match,
+      #   Word semantics)
+      # @param to [String] Replacement font family
+      def initialize(from:, to:)
+        @from = from.to_s
+        @to = to.to_s
+        @count = 0
+      end
+
+      # Number of rFonts attribute values replaced so far.
+      #
+      # @return [Integer] Replacement count
+      attr_reader :count
+
+      # Replace @from with @to throughout the document (mutated).
+      #
+      # @param document [DocumentRoot] Document to rewrite
+      # @return [Integer] Replacement count
+      def replace(document)
+        replace_in_styles(document.styles_configuration)
+        replace_in_numbering(document.numbering_configuration)
+        replace_in_container(document.body)
+        part_containers(document).each do |container|
+          replace_in_paragraphs(container)
+        end
+        count
+      end
+
+      private
+
+      # Styles: docDefaults and every style definition.
+      def replace_in_styles(styles)
+        return unless styles
+
+        replace_in_run_properties(styles.doc_defaults&.rPrDefault&.rPr)
+        (styles.styles || []).each do |style|
+          replace_in_run_properties(style.rPr)
+        end
+      end
+
+      # Numbering: every level of every abstract definition.
+      def replace_in_numbering(numbering)
+        return unless numbering
+
+        (numbering.definitions || []).each do |definition|
+          (definition.levels || []).each do |level|
+            replace_in_run_properties(level.rPr)
+          end
+        end
+      end
+
+      # Containers outside the body: header/footer parts, note
+      # entries, and comments — model objects holding paragraphs.
+      def part_containers(document)
+        header_footer_containers(document) +
+          note_containers(document) + comment_containers(document)
+      end
+
+      def header_footer_containers(document)
+        (document.header_footer_parts || []).filter_map do |part|
+          part.content if part.content.is_a?(Lutaml::Model::Serializable)
+        end
+      end
+
+      def note_containers(document)
+        (document.footnotes&.footnote_entries || []) +
+          (document.endnotes&.endnote_entries || [])
+      end
+
+      def comment_containers(document)
+        document.comments&.comments || []
+      end
+
+      # Walk a container's paragraphs, recursing into (nested) tables.
+      def replace_in_container(container)
+        return unless container
+
+        replace_in_paragraphs(container)
+        (container.tables || []).each { |table| replace_in_table(table) }
+      end
+
+      def replace_in_table(table)
+        (table.rows || []).each do |row|
+          (row.cells || []).each { |cell| replace_in_container(cell) }
+        end
+      end
+
+      # Walk only paragraphs — for note/comment/header/footer parts,
+      # whose models do not expose nested tables.
+      def replace_in_paragraphs(container)
+        (container.paragraphs || []).each do |paragraph|
+          replace_in_paragraph(paragraph)
+        end
+      end
+
+      def replace_in_paragraph(paragraph)
+        replace_in_runs(paragraph.runs)
+        (paragraph.hyperlinks || []).each do |hyperlink|
+          replace_in_runs(hyperlink.runs)
+        end
+      end
+
+      def replace_in_runs(runs)
+        (runs || []).each do |run|
+          replace_in_run_properties(run.properties)
+        end
+      end
+
+      # Rewrite matching RunFonts attribute values in place.
+      def replace_in_run_properties(run_properties)
+        fonts = run_properties&.fonts
+        return unless fonts
+
+        FONT_ATTRIBUTES.each do |attr|
+          next unless fonts.method(attr).call == @from
+
+          fonts.method(:"#{attr}=").call(@to)
+          @count += 1
+        end
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/footnotes.rb

@@ -32,8 +32,11 @@ module Uniword
         end
 
         missing = footnote_entries.size - counts["footnote"]
+        return unless missing.positive?
+
+        order = Ooxml::ElementOrder.mutable_order(self)
         missing.times do
-          element_order << Lutaml::Xml::Element.new("Element", "footnote")
+          order << Lutaml::Xml::Element.new("Element", "footnote")
         end
       end
 

data/lib/uniword/wordprocessingml/hdr_shape_defaults.rb

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

data/lib/uniword/wordprocessingml/hyperlink.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require "uniword/ooxml/types/relationship_id"
 
 module Uniword
   module Wordprocessingml

data/lib/uniword/wordprocessingml/level.rb

@@ -17,20 +17,6 @@ module Uniword
       end
     end
 
-    # Tabs container for numbering level
-    #
-    # Element: <w:tabs>
-    class Tabs < Lutaml::Model::Serializable
-      attribute :tab, Tab, collection: true
-
-      xml do
-        element "tabs"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        mixed_content
-        map_element "tab", to: :tab, render_nil: false
-      end
-    end
-
     # Numbering level suffix type
     #
     # Element: <w:suff>
@@ -63,6 +49,10 @@ module Uniword
     #
     # Generated from OOXML schema: wordprocessingml.yml
     # Element: <w:lvl>
+    #
+    # Per ECMA-376 CT_Lvl, `w:ind` and `w:tabs` are NOT direct children of
+    # `w:lvl` — they belong to the level's `w:pPr`. They are therefore not
+    # mapped here; use `pPr.indentation` / `pPr.tabs`.
     class Level < Lutaml::Model::Serializable
       attribute :ilvl, :integer
       attribute :tentative, :string
@@ -75,8 +65,6 @@ module Uniword
       attribute :lvlText, LvlText
       attribute :lvlJc, LvlJc
       attribute :pPr, ParagraphProperties
-      attribute :tabs, Tabs
-      attribute :ind, Ind
       attribute :rPr, RunProperties
 
       xml do
@@ -95,8 +83,6 @@ module Uniword
         map_element "lvlText", to: :lvlText, render_nil: false
         map_element "lvlJc", to: :lvlJc, render_nil: false
         map_element "pPr", to: :pPr, render_nil: false
-        map_element "tabs", to: :tabs, render_nil: false
-        map_element "ind", to: :ind, render_nil: false
         map_element "rPr", to: :rPr, render_nil: false
       end
 
@@ -122,12 +108,12 @@ module Uniword
 
       # Get left indent (convenience method - returns integer)
       def left_indent_value
-        ind&.left&.to_i
+        pPr&.indentation&.left.to_i
       end
 
       # Get hanging indent (convenience method - returns integer)
       def hanging_indent_value
-        ind&.hanging&.to_i
+        pPr&.indentation&.hanging.to_i
       end
 
       # Get level text value (convenience method - returns string)

data/lib/uniword/wordprocessingml/math_pr.rb

@@ -1,17 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "math_font"
-require_relative "brk_bin"
-require_relative "brk_bin_sub"
-require_relative "small_frac"
-require_relative "disp_def"
-require_relative "l_margin"
-require_relative "r_margin"
-require_relative "def_jc"
-require_relative "wrap_indent"
-require_relative "int_lim"
-require_relative "nary_lim"
 
 module Uniword
   module Wordprocessingml

data/lib/uniword/wordprocessingml/numbering_definition.rb

@@ -80,8 +80,10 @@ module Uniword
               start: Uniword::Wordprocessingml::Start.new(val: 1),
               numFmt: Uniword::Wordprocessingml::NumFmt.new(val: "decimal"),
               lvlJc: Uniword::Wordprocessingml::LvlJc.new(val: "left"),
-              ind: Uniword::Wordprocessingml::Ind.new(
-                left: (720 * (i + 1)).to_s, hanging: "360",
+              pPr: Uniword::Wordprocessingml::ParagraphProperties.new(
+                indentation: Uniword::Properties::Indentation.new(
+                  left: 720 * (i + 1), hanging: 360,
+                ),
               ),
             )
           end
@@ -104,8 +106,10 @@ module Uniword
               numFmt: Uniword::Wordprocessingml::NumFmt.new(val: "bullet"),
               lvlText: Uniword::Wordprocessingml::LvlText.new(val: level_char),
               lvlJc: Uniword::Wordprocessingml::LvlJc.new(val: "left"),
-              ind: Uniword::Wordprocessingml::Ind.new(
-                left: (720 * (i + 1)).to_s, hanging: "360",
+              pPr: Uniword::Wordprocessingml::ParagraphProperties.new(
+                indentation: Uniword::Properties::Indentation.new(
+                  left: 720 * (i + 1), hanging: 360,
+                ),
               ),
               rPr: Uniword::Wordprocessingml::RunProperties.new(
                 fonts: Properties::RunFonts.new(ascii: "Symbol",
@@ -126,8 +130,10 @@ module Uniword
               start: Uniword::Wordprocessingml::Start.new(val: 1),
               numFmt: Uniword::Wordprocessingml::NumFmt.new(val: format),
               lvlJc: Uniword::Wordprocessingml::LvlJc.new(val: "left"),
-              ind: Uniword::Wordprocessingml::Ind.new(
-                left: (720 * (i + 1)).to_s, hanging: "360",
+              pPr: Uniword::Wordprocessingml::ParagraphProperties.new(
+                indentation: Uniword::Properties::Indentation.new(
+                  left: 720 * (i + 1), hanging: 360,
+                ),
               ),
             )
           end
@@ -144,8 +150,10 @@ module Uniword
               start: Uniword::Wordprocessingml::Start.new(val: 1),
               numFmt: Uniword::Wordprocessingml::NumFmt.new(val: format),
               lvlJc: Uniword::Wordprocessingml::LvlJc.new(val: "left"),
-              ind: Uniword::Wordprocessingml::Ind.new(
-                left: (720 * (i + 1)).to_s, hanging: "360",
+              pPr: Uniword::Wordprocessingml::ParagraphProperties.new(
+                indentation: Uniword::Properties::Indentation.new(
+                  left: 720 * (i + 1), hanging: 360,
+                ),
               ),
             )
           end

data/lib/uniword/wordprocessingml/numbering_elements.rb

@@ -30,21 +30,6 @@ module Uniword
       end
     end
 
-    # Indentation for numbering level
-    #
-    # Element: <w:ind>
-    class Ind < Lutaml::Model::Serializable
-      attribute :left, :string
-      attribute :hanging, :string
-
-      xml do
-        element "ind"
-        namespace Uniword::Ooxml::Namespaces::WordProcessingML
-        map_attribute "left", to: :left
-        map_attribute "hanging", to: :hanging
-      end
-    end
-
     # Run fonts for numbering
     #
     # Element: <w:rFonts>

data/lib/uniword/wordprocessingml/page_setup.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Wordprocessingml
+    # Applies uniform page setup across every section of a document —
+    # Word's Layout dialog as an API.
+    #
+    # Paper size (named presets), orientation (with dimension swap, like
+    # Word), and margins (twips, or strings with in/cm/mm suffix).
+    # Header/footer/gutter margins are left untouched.
+    #
+    # @example A4 landscape with 2 cm margins
+    #   setup = PageSetup.new(size: "a4", orientation: "landscape",
+    #                         margins: "2cm")
+    #   setup.apply(document)
+    #   setup.sections_updated # => 1
+    class PageSetup
+      # Named paper sizes in twips [width, height] (portrait).
+      PAPER_SIZES = {
+        "letter" => [12_240, 15_840],
+        "legal" => [12_240, 20_160],
+        "a4" => [11_906, 16_838],
+        "a5" => [8_391, 11_906],
+        "executive" => [10_440, 15_120],
+      }.freeze
+
+      TWIPS_PER_INCH = 1440
+      TWIPS_PER_CM = 567
+      TWIPS_PER_MM = 57
+
+      ORIENTATIONS = %w[portrait landscape].freeze
+
+      # @return [Integer] number of sections updated
+      attr_reader :sections_updated
+
+      # @param size [String, nil] Paper size name (see PAPER_SIZES)
+      # @param orientation [String, nil] "portrait" or "landscape"
+      # @param margins [Integer, String, nil] Uniform margin for all four
+      #   sides (twips, or "1in" / "2.5cm" / "25mm")
+      # @param side_margins [Hash] Per-side overrides
+      #   (:top, :right, :bottom, :left)
+      # @raise [ArgumentError] on unknown size, orientation, or margin
+      def initialize(size: nil, orientation: nil, margins: nil,
+                     **side_margins)
+        @size = normalize_size(size)
+        @orientation = normalize_orientation(orientation)
+        @margins = side_margins.to_h do |side, value|
+          [side, parse_margin(value)]
+        end
+        uniform = parse_margin(margins)
+        %i[top right bottom left].each do |side|
+          @margins[side] = uniform if @margins[side].nil?
+        end
+        @sections_updated = 0
+      end
+
+      # Apply the setup to every section in the document.
+      #
+      # @param document [DocumentRoot] Document to update (mutated)
+      # @return [Integer] number of sections updated
+      def apply(document)
+        each_section_properties(document) do |sect_pr|
+          apply_page_size(sect_pr) if @size || @orientation
+          apply_margins(sect_pr)
+          @sections_updated += 1
+        end
+        sections_updated
+      end
+
+      private
+
+      def normalize_size(size)
+        return nil if size.nil?
+
+        dims = PAPER_SIZES[size.to_s.downcase]
+        unless dims
+          raise ArgumentError,
+                "Unknown paper size '#{size}'. " \
+                "Available: #{PAPER_SIZES.keys.join(', ')}"
+        end
+
+        dims
+      end
+
+      def normalize_orientation(orientation)
+        return nil if orientation.nil?
+
+        value = orientation.to_s.downcase
+        return value if ORIENTATIONS.include?(value)
+
+        raise ArgumentError,
+              "Unknown orientation '#{orientation}'. " \
+              "Available: #{ORIENTATIONS.join(', ')}"
+      end
+
+      # Parse a margin value: Integer (twips) or String with an
+      # in/cm/mm/dxa suffix (bare numbers are inches).
+      def parse_margin(value)
+        case value
+        when nil then nil
+        when Numeric then value.round
+        when /\A([\d.]+)\s*(in|cm|mm|dxa|twips?)?\z/i
+          amount = Regexp.last_match(1).to_f
+          unit = Regexp.last_match(2)&.downcase || "in"
+          to_twips(amount, unit)
+        else
+          raise ArgumentError, "Invalid margin '#{value}' " \
+                               "(use twips, or '1in' / '2.5cm' / '25mm')"
+        end
+      end
+
+      def to_twips(amount, unit)
+        factor = case unit
+                 when "in" then TWIPS_PER_INCH
+                 when "cm" then TWIPS_PER_CM
+                 when "mm" then TWIPS_PER_MM
+                 else 1
+                 end
+        (amount * factor).round
+      end
+
+      def each_section_properties(document, &block)
+        body = document.body
+        return unless body
+
+        yield body.section_properties if body.section_properties
+        each_paragraph_section(body, &block)
+      end
+
+      def each_paragraph_section(body)
+        (body.paragraphs || []).each do |paragraph|
+          sect_pr = paragraph.properties&.section_properties
+          yield sect_pr if sect_pr
+        end
+      end
+
+      def apply_page_size(sect_pr)
+        width, height = target_dimensions(sect_pr)
+
+        sect_pr.page_size ||= PageSize.new
+        sect_pr.page_size.width = width
+        sect_pr.page_size.height = height
+        sect_pr.page_size.orientation = @orientation if @orientation
+      end
+
+      def target_dimensions(sect_pr)
+        width, height = current_dimensions(sect_pr)
+        width, height = @size if @size
+        width, height = orient(width, height) if @orientation
+        [width, height]
+      end
+
+      def current_dimensions(sect_pr)
+        size = sect_pr.page_size
+        [size&.width || PageDefaults.default_page_size.width,
+         size&.height || PageDefaults.default_page_size.height]
+      end
+
+      # Word swaps width/height when flipping orientation.
+      def orient(width, height)
+        if (@orientation == "landscape" && width < height) ||
+            (@orientation == "portrait" && width > height)
+          [height, width]
+        else
+          [width, height]
+        end
+      end
+
+      def apply_margins(sect_pr)
+        return if @margins.values.all?(&:nil?)
+
+        sect_pr.page_margins ||= PageMargins.new
+        @margins.each do |side, value|
+          next if value.nil?
+
+          sect_pr.page_margins.method(:"#{side}=").call(value)
+        end
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/paragraph_properties.rb

@@ -116,7 +116,8 @@ module Uniword
             with: { from: :yaml_widow_control_from, to: :yaml_widow_control_to }
       end
 
-      # YAML transform methods (instance methods - called via send on an instance)
+      # YAML transform methods (instance methods called by lutaml-model's
+      # `with:` transform mechanism)
       def yaml_style_from(instance, value)
         if value
           instance.style = [
@@ -200,21 +201,6 @@ module Uniword
         # Style reference - maps w:pStyle w:val="..." to style attribute
         map_element "pStyle", to: :style, render_nil: false
 
-        # Alignment - maps w:jc w:val="..." to alignment attribute
-        map_element "jc", to: :alignment, render_nil: false
-
-        # Spacing (complex object - WORKS)
-        map_element "spacing", to: :spacing, render_nil: false
-
-        # Indentation (complex object)
-        map_element "ind", to: :indentation, render_nil: false
-
-        # Outline level (wrapper object)
-        map_element "outlineLvl", to: :outline_level, render_nil: false
-
-        # Numbering properties (wrapped in w:numPr)
-        map_element "numPr", to: :numbering_properties, render_nil: false
-
         # Keep options (only render if true)
         map_element "keepNext", to: :keep_next_wrapper, render_nil: false,
                                 render_default: false
@@ -225,32 +211,51 @@ module Uniword
         map_element "widowControl", to: :widow_control_wrapper, render_nil: false,
                                     render_default: false
 
-        # Spacing options (only render if true)
-        map_element "contextualSpacing", to: :contextual_spacing, render_nil: false,
-                                         render_default: false
+        # Numbering properties (wrapped in w:numPr)
+        map_element "numPr", to: :numbering_properties, render_nil: false
+
+        # Suppress line numbers (only render if true)
         map_element "suppressLineNumbers", to: :suppress_line_numbers, render_nil: false,
                                            render_default: false
 
-        # Bidirectional (only render if true)
-        map_element "bidi", to: :bidirectional, render_nil: false,
-                            render_default: false
+        # Borders (complex object)
+        map_element "pBdr", to: :borders, render_nil: false
+
+        # Shading (complex object)
+        map_element "shd", to: :shading, render_nil: false
+
+        # Tabs (complex object - collection)
+        map_element "tabs", to: :tabs, render_nil: false
 
         # East Asian typography
         map_element "autoSpaceDE", to: :auto_space_de, render_nil: false,
                                    render_default: false
         map_element "autoSpaceDN", to: :auto_space_dn, render_nil: false,
                                    render_default: false
+
+        # Bidirectional (only render if true)
+        map_element "bidi", to: :bidirectional, render_nil: false,
+                            render_default: false
+
+        # Right indent adjustment
         map_element "adjustRightInd", to: :adjust_right_ind, render_nil: false,
                                       render_default: false
 
-        # Borders (complex object)
-        map_element "pBdr", to: :borders, render_nil: false
+        # Spacing (complex object - WORKS)
+        map_element "spacing", to: :spacing, render_nil: false
 
-        # Tabs (complex object - collection)
-        map_element "tabs", to: :tabs, render_nil: false
+        # Indentation (complex object)
+        map_element "ind", to: :indentation, render_nil: false
 
-        # Shading (complex object)
-        map_element "shd", to: :shading, render_nil: false
+        # Contextual spacing (only render if true)
+        map_element "contextualSpacing", to: :contextual_spacing, render_nil: false,
+                                         render_default: false
+
+        # Alignment - maps w:jc w:val="..." to alignment attribute
+        map_element "jc", to: :alignment, render_nil: false
+
+        # Outline level (wrapper object)
+        map_element "outlineLvl", to: :outline_level, render_nil: false
 
         # Run properties (for pPr/rPr - style overrides)
         map_element "rPr", to: :run_properties, render_nil: false

data/lib/uniword/wordprocessingml/rsids.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
-require_relative "rsid_root"
-require_relative "rsid"
 
 module Uniword
   module Wordprocessingml

data/lib/uniword/wordprocessingml/run.rb

@@ -18,6 +18,7 @@ module Uniword
       attribute :alternate_content, AlternateContent, default: nil
       attribute :footnote_reference, FootnoteReference
       attribute :endnote_reference, EndnoteReference
+      attribute :comment_reference, CommentReference
       attribute :field_char, FieldChar
       attribute :instr_text, InstrText
       attribute :position_tab, PositionTab
@@ -55,6 +56,8 @@ module Uniword
                                          render_nil: false
         map_element "endnoteReference", to: :endnote_reference,
                                         render_nil: false
+        map_element "commentReference", to: :comment_reference,
+                                        render_nil: false
         map_element "fldChar", to: :field_char, render_nil: false
         map_element "instrText", to: :instr_text, render_nil: false
         map_element "ptab", to: :position_tab, render_nil: false

data/lib/uniword/wordprocessingml/section_properties.rb

@@ -50,14 +50,14 @@ module Uniword
 
         map_element "headerReference", to: :header_references, render_nil: false
         map_element "footerReference", to: :footer_references, render_nil: false
+        map_element "footnotePr", to: :footnote_pr, render_nil: false
         map_element "pgSz", to: :page_size, render_nil: false
         map_element "pgMar", to: :page_margins, render_nil: false
         map_attribute "val", to: :type
         map_element "pgNumType", to: :page_numbering, render_nil: false
         map_element "cols", to: :columns, render_nil: false
-        map_element "docGrid", to: :doc_grid, render_nil: false
-        map_element "footnotePr", to: :footnote_pr, render_nil: false
         map_element "titlePg", to: :title_pg, render_nil: false
+        map_element "docGrid", to: :doc_grid, render_nil: false
         map_element "footnoteColumns", to: :footnote_columns, render_nil: false
       end
     end