uniword 1.7.1 → 1.7.2

data/lib/uniword/wordprocessingml/run_properties/yaml_transforms.rb

@@ -8,63 +8,73 @@ module Uniword
       # Handles bidirectional conversion between flat YAML keys
       # (bold, italic, size, etc.) and the wrapper objects used
       # internally by the OOXML model.
+      #
+      # Every writer assigns through YamlWriter#yaml_put; see that module
+      # for why.
       module YamlTransforms
+        include YamlWriter
+
         # --- Boolean transforms ---
+        #
+        # Toggles read through BooleanElement#on?, the same reading the XML
+        # and predicate consumers get.
 
         def yaml_bold_from(instance, value)
           instance.bold = Properties::Bold.new(value: value) unless value.nil?
         end
 
-        def yaml_bold_to(_instance, _doc)
-          bold&.value
+        def yaml_bold_to(instance, doc)
+          yaml_put(doc, "bold", instance.bold&.on?)
         end
 
         def yaml_italic_from(instance, value)
           instance.italic = Properties::Italic.new(value: value) unless value.nil?
         end
 
-        def yaml_italic_to(_instance, _doc)
-          italic&.value
+        def yaml_italic_to(instance, doc)
+          yaml_put(doc, "italic", instance.italic&.on?)
         end
 
         def yaml_strike_from(instance, value)
           instance.strike = Properties::Strike.new(value: value) unless value.nil?
         end
 
-        def yaml_strike_to(_instance, _doc)
-          strike&.value
+        def yaml_strike_to(instance, doc)
+          yaml_put(doc, "strike", instance.strike&.on?)
         end
 
         def yaml_double_strike_from(instance, value)
           instance.double_strike = Properties::DoubleStrike.new(value: value) unless value.nil?
         end
 
-        def yaml_double_strike_to(_instance, _doc)
-          double_strike&.value
+        def yaml_double_strike_to(instance, doc)
+          yaml_put(doc, "double_strike", instance.double_strike&.on?)
         end
 
         def yaml_small_caps_from(instance, value)
           instance.small_caps = Properties::SmallCaps.new(value: value) unless value.nil?
         end
 
-        def yaml_small_caps_to(_instance, _doc)
-          small_caps&.value
+        def yaml_small_caps_to(instance, doc)
+          yaml_put(doc, "small_caps", instance.small_caps&.on?)
         end
 
         def yaml_caps_from(instance, value)
           instance.caps = Properties::Caps.new(value: value) unless value.nil?
         end
 
-        def yaml_caps_to(_instance, _doc)
-          caps&.value
+        # "caps" and "all_caps" are two spellings of one property, so both
+        # rules write the canonical key rather than emitting it twice.
+        def yaml_caps_to(instance, doc)
+          yaml_put(doc, "caps", instance.caps&.on?)
         end
 
         def yaml_hidden_from(instance, value)
           instance.hidden = Properties::Vanish.new(value: value) unless value.nil?
         end
 
-        def yaml_hidden_to(_instance, _doc)
-          hidden&.value
+        def yaml_hidden_to(instance, doc)
+          yaml_put(doc, "hidden", instance.hidden&.on?)
         end
 
         # --- Numeric transforms ---
@@ -73,16 +83,16 @@ module Uniword
           instance.size = Properties::FontSize.new(value: value.to_i) if value
         end
 
-        def yaml_size_to(_instance, _doc)
-          size&.value
+        def yaml_size_to(instance, doc)
+          yaml_put(doc, "size", instance.size&.value)
         end
 
         def yaml_character_spacing_from(instance, value)
           instance.character_spacing = Properties::CharacterSpacing.new(value: value.to_i) if value
         end
 
-        def yaml_character_spacing_to(_instance, _doc)
-          character_spacing&.value
+        def yaml_character_spacing_to(instance, doc)
+          yaml_put(doc, "character_spacing", instance.character_spacing&.value)
         end
 
         # --- String transforms ---
@@ -91,24 +101,24 @@ module Uniword
           instance.underline = Properties::Underline.new(value: value) if value
         end
 
-        def yaml_underline_to(_instance, _doc)
-          underline&.value
+        def yaml_underline_to(instance, doc)
+          yaml_put(doc, "underline", instance.underline&.value)
         end
 
         def yaml_color_from(instance, value)
           instance.color = Properties::ColorValue.new(value: value) if value
         end
 
-        def yaml_color_to(_instance, _doc)
-          color&.value
+        def yaml_color_to(instance, doc)
+          yaml_put(doc, "color", instance.color&.value)
         end
 
         def yaml_highlight_from(instance, value)
           instance.highlight = Properties::Highlight.new(value: value) if value
         end
 
-        def yaml_highlight_to(_instance, _doc)
-          highlight&.value
+        def yaml_highlight_to(instance, doc)
+          yaml_put(doc, "highlight", instance.highlight&.value)
         end
 
         # --- Font transforms ---
@@ -118,8 +128,10 @@ module Uniword
           instance.fonts.ascii = value if value
         end
 
-        def yaml_font_to(_instance, _doc)
-          fonts&.ascii
+        # "font" and "font_ascii" both name w:rFonts/@w:ascii; write the
+        # short spelling once.
+        def yaml_font_to(instance, doc)
+          yaml_put(doc, "font", instance.fonts&.ascii)
         end
 
         def yaml_font_ascii_from(instance, value)
@@ -127,8 +139,8 @@ module Uniword
           instance.fonts.ascii = value if value
         end
 
-        def yaml_font_ascii_to(_instance, _doc)
-          fonts&.ascii
+        def yaml_font_ascii_to(instance, doc)
+          yaml_font_to(instance, doc)
         end
 
         def yaml_font_east_asia_from(instance, value)
@@ -136,8 +148,8 @@ module Uniword
           instance.fonts.east_asia = value if value
         end
 
-        def yaml_font_east_asia_to(_instance, _doc)
-          fonts&.east_asia
+        def yaml_font_east_asia_to(instance, doc)
+          yaml_put(doc, "font_east_asia", instance.fonts&.east_asia)
         end
 
         def yaml_font_h_ansi_from(instance, value)
@@ -145,8 +157,8 @@ module Uniword
           instance.fonts.h_ansi = value if value
         end
 
-        def yaml_font_h_ansi_to(_instance, _doc)
-          fonts&.h_ansi
+        def yaml_font_h_ansi_to(instance, doc)
+          yaml_put(doc, "font_h_ansi", instance.fonts&.h_ansi)
         end
 
         def yaml_font_cs_from(instance, value)
@@ -154,8 +166,8 @@ module Uniword
           instance.fonts.cs = value if value
         end
 
-        def yaml_font_cs_to(_instance, _doc)
-          fonts&.cs
+        def yaml_font_cs_to(instance, doc)
+          yaml_put(doc, "font_cs", instance.fonts&.cs)
         end
 
         # --- Effect transforms ---
@@ -164,40 +176,45 @@ module Uniword
           instance.emboss = Properties::Emboss.new(value: value) unless value.nil?
         end
 
-        def yaml_emboss_to(_instance, _doc)
-          emboss&.value
+        def yaml_emboss_to(instance, doc)
+          yaml_put(doc, "emboss", instance.emboss&.on?)
         end
 
         def yaml_imprint_from(instance, value)
           instance.imprint = Properties::Imprint.new(value: value) unless value.nil?
         end
 
-        def yaml_imprint_to(_instance, _doc)
-          imprint&.value
+        def yaml_imprint_to(instance, doc)
+          yaml_put(doc, "imprint", instance.imprint&.on?)
         end
 
         def yaml_shadow_from(instance, value)
           instance.shadow = Properties::Shadow.new(value: value) unless value.nil?
         end
 
-        def yaml_shadow_to(_instance, _doc)
-          shadow&.value
+        def yaml_shadow_to(instance, doc)
+          yaml_put(doc, "shadow", instance.shadow&.on?)
         end
 
+        # The YAML key "outline" carries w:outlineLvl, not the w:outline
+        # toggle. Kept as-is so existing style YAML keeps loading.
         def yaml_outline_from(instance, value)
           instance.outline_level = Properties::OutlineLevel.new(value: value) unless value.nil?
         end
 
-        def yaml_outline_to(_instance, _doc)
-          outline_level.value if outline_level.is_a?(Properties::OutlineLevel)
+        def yaml_outline_to(instance, doc)
+          level = instance.outline_level
+          return unless level.is_a?(Properties::OutlineLevel)
+
+          yaml_put(doc, "outline", level.value)
         end
 
         def yaml_vertical_align_from(instance, value)
           instance.vertical_align = Properties::VerticalAlign.new(value: value) if value
         end
 
-        def yaml_vertical_align_to(_instance, _doc)
-          vertical_align&.value
+        def yaml_vertical_align_to(instance, doc)
+          yaml_put(doc, "vertical_align", instance.vertical_align&.value)
         end
       end
     end

data/lib/uniword/wordprocessingml/run_properties.rb

@@ -24,6 +24,12 @@ module Uniword
 
       # Pattern 0: ATTRIBUTES FIRST, then XML mappings
 
+      # Paragraph-mark revision markers. Only valid when this rPr is
+      # the w:pPr/w:rPr (CT_ParaRPr); Word marks a deleted or inserted
+      # paragraph mark with w:del / w:ins there during change tracking.
+      attribute :del, DeletedParagraphMark, default: nil
+      attribute :ins, InsertedParagraphMark, default: nil
+
       # Simple element wrapper objects (default: nil so unset properties are nil)
       attribute :style, Properties::RunStyleReference, default: nil
       attribute :size, Properties::FontSize, default: nil
@@ -126,6 +132,10 @@ module Uniword
         # outline, shadow, emboss, imprint, noProof, snapToGrid, vanish, webHidden,
         # color, spacing, w, kern, position, sz, szCs, highlight, u, effect, bdr,
         # shd, fitText, vertAlign, rtl, cs, em, lang, eastAsianLayout, specVanish, oMath
+        # CT_ParaRPr additionally opens with ins, del, moveFrom, moveTo before
+        # the shared sequence; the paragraph-mark revision markers come first.
+        map_element "ins", to: :ins, render_nil: false
+        map_element "del", to: :del, render_nil: false
         map_element "rStyle", to: :style, render_nil: false
         map_element "rFonts", to: :fonts, render_nil: false
         map_element "b", to: :bold, render_nil: false

data/lib/uniword/wordprocessingml/structured_document_tag/showing_placeholder_header.rb

@@ -5,12 +5,23 @@ require "lutaml/model"
 module Uniword
   module Wordprocessingml
     class StructuredDocumentTag
-      # Showing placeholder header flag for Structured Document Tag (empty element)
-      # Reference XML: <w:showingPlcHdr/>
+      # Showing placeholder header flag for Structured Document Tag
+      # Reference XML: <w:showingPlcHdr/> or <w:showingPlcHdr w:val="0"/>
+      #
+      # This is an ST_OnOff toggle like every other one. It used to map no
+      # w:val at all, so an explicitly-off flag round-tripped as on and the
+      # four spellings were indistinguishable.
       class ShowingPlaceholderHeader < Lutaml::Model::Serializable
+        include Uniword::Properties::BooleanElement
+
+        attribute :val, :string, default: nil
+        include Uniword::Properties::BooleanValSetter
+
         xml do
           element "showingPlcHdr"
           namespace Ooxml::Namespaces::WordProcessingML
+          map_attribute "val", to: :val, render_nil: false,
+                               render_default: false
         end
       end
     end

data/lib/uniword/wordprocessingml/structured_document_tag/temporary.rb

@@ -5,13 +5,24 @@ require "lutaml/model"
 module Uniword
   module Wordprocessingml
     class StructuredDocumentTag
-      # Temporary flag for Structured Document Tag (empty element)
+      # Temporary flag for Structured Document Tag
       # Indicates the SDT should be removed when content is first edited
-      # Reference XML: <w:temporary/>
+      # Reference XML: <w:temporary/> or <w:temporary w:val="0"/>
+      #
+      # This is an ST_OnOff toggle like every other one. It used to map no
+      # w:val at all, so an explicitly-off flag round-tripped as on and the
+      # six spellings were indistinguishable.
       class Temporary < Lutaml::Model::Serializable
+        include Uniword::Properties::BooleanElement
+
+        attribute :val, :string, default: nil
+        include Uniword::Properties::BooleanValSetter
+
         xml do
           element "temporary"
           namespace Ooxml::Namespaces::WordProcessingML
+          map_attribute "val", to: :val, render_nil: false,
+                               render_default: false
         end
       end
     end

data/lib/uniword/wordprocessingml/style.rb

@@ -9,6 +9,8 @@ module Uniword
     # Generated from OOXML schema: wordprocessingml.yml
     # Element: <w:style>
     class Style < Lutaml::Model::Serializable
+      include YamlWriter
+
       # Pattern 0: ATTRIBUTES FIRST
       attribute :type, :string
       attribute :styleId, :string
@@ -50,53 +52,57 @@ module Uniword
       end
 
       # YAML transform methods (instance methods called by lutaml-model's
-      # `with:` transform mechanism)
+      # `with:` transform mechanism). The `_from` readers build wrapper
+      # objects; the `_to` writers assign through YamlWriter#yaml_put rather
+      # than returning a value — see that module for why.
       def yaml_name_from(instance, value)
         instance.name = StyleName.new(val: value) if value
       end
 
-      def yaml_name_to(instance, _doc)
-        instance.name&.val
+      def yaml_name_to(instance, doc)
+        yaml_put(doc, "name", instance.name&.val)
       end
 
       def yaml_quick_format_from(instance, value)
         instance.qFormat = Properties::QuickFormat.new(value: value) unless value.nil?
       end
 
-      def yaml_quick_format_to(instance, _doc)
-        instance.qFormat&.value
+      # w:qFormat is an ST_OnOff toggle, read through BooleanElement#on?
+      # like every other one.
+      def yaml_quick_format_to(instance, doc)
+        yaml_put(doc, "quick_format", instance.qFormat&.on?)
       end
 
       def yaml_based_on_from(instance, value)
         instance.basedOn = BasedOn.new(val: value) if value
       end
 
-      def yaml_based_on_to(instance, _doc)
-        instance.basedOn&.val
+      def yaml_based_on_to(instance, doc)
+        yaml_put(doc, "based_on", instance.basedOn&.val)
       end
 
       def yaml_next_style_from(instance, value)
         instance.nextStyle = Next.new(val: value) if value
       end
 
-      def yaml_next_style_to(instance, _doc)
-        instance.nextStyle&.val
+      def yaml_next_style_to(instance, doc)
+        yaml_put(doc, "next_style", instance.nextStyle&.val)
       end
 
       def yaml_linked_style_from(instance, value)
         instance.link = Link.new(val: value) if value
       end
 
-      def yaml_linked_style_to(instance, _doc)
-        instance.link&.val
+      def yaml_linked_style_to(instance, doc)
+        yaml_put(doc, "linked_style", instance.link&.val)
       end
 
       def yaml_ui_priority_from(instance, value)
         instance.uiPriority = UiPriority.new(val: value.to_s) if value
       end
 
-      def yaml_ui_priority_to(instance, _doc)
-        instance.uiPriority&.val&.to_i
+      def yaml_ui_priority_to(instance, doc)
+        yaml_put(doc, "ui_priority", instance.uiPriority&.val&.to_i)
       end
 
       xml do
@@ -152,19 +158,18 @@ module Uniword
       end
 
       def quick_format
-        val = qFormat
-        return true if val == true
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
+        boolean_flag(qFormat) == true
       end
 
+      # Word splits one paragraph's spacing across several w:spacing elements,
+      # and Word readers resolve conflicts last-wins, so take the last entry
+      # that actually carries the value.
       def spacing_before
-        pPr&.spacing&.before || pPr&.spacing_before
+        Array(pPr&.spacing).filter_map(&:before).last || pPr&.spacing_before
       end
 
       def spacing_after
-        pPr&.spacing&.after || pPr&.spacing_after
+        Array(pPr&.spacing).filter_map(&:after).last || pPr&.spacing_after
       end
 
       def alignment
@@ -172,23 +177,11 @@ module Uniword
       end
 
       def keep_next
-        return false unless pPr
-
-        val = pPr.keep_next_wrapper
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
+        boolean_flag(pPr&.keep_next_wrapper) == true
       end
 
       def keep_lines
-        return false unless pPr
-
-        val = pPr.keep_lines_wrapper
-        return false if val.nil?
-
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
+        boolean_flag(pPr&.keep_lines_wrapper) == true
       end
 
       def outline_level
@@ -200,13 +193,11 @@ module Uniword
       end
 
       def bold
-        return nil unless rPr
-
-        val = rPr.bold
-        return nil if val.nil?
+        boolean_flag(rPr&.bold)
+      end
 
-        val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-        val == true
+      def italic
+        boolean_flag(rPr&.italic)
       end
 
       def font_size
@@ -252,6 +243,18 @@ module Uniword
       def run_properties
         rPr
       end
+
+      private
+
+      # ST_OnOff toggles arrive as BooleanElement wrappers when parsed and as
+      # plain booleans when built. Returns nil when the toggle is absent, so
+      # readers wanting a strict false-when-absent contract compare == true.
+      def boolean_flag(element)
+        return nil if element.nil?
+        return element.on? if element.is_a?(Uniword::Properties::BooleanElement)
+
+        element == true
+      end
     end
   end
 end

data/lib/uniword/wordprocessingml/table_row_properties.rb

@@ -38,18 +38,13 @@ module Uniword
         map_element "jc", to: :jc, render_nil: false
       end
 
-      def initialize(attrs = {})
-        # Handle table_header: keyword for docx-js API compatibility
-        if attrs.key?(:table_header)
-          val = attrs.delete(:table_header)
-          attrs[:tbl_header] = coerce_to_val_int(val)
-        end
-        super
-      end
-
-      private
-
-      def coerce_to_val_int(val)
+      # Coerce a table_header value (true/false/Integer/ValInt) into the
+      # w:tblHeader model value: false and 0 mean "off", which the
+      # element expresses by absence.
+      #
+      # @param val [Object] raw table_header value
+      # @return [ValInt, nil]
+      def self.coerce_table_header(val)
         case val
         when ValInt then val
         when true, 1 then ValInt.new(value: 1)
@@ -59,6 +54,15 @@ module Uniword
         else ValInt.new(value: val.to_i)
         end
       end
+
+      def initialize(attrs = {})
+        # Handle table_header: keyword for docx-js API compatibility
+        if attrs.key?(:table_header)
+          val = attrs.delete(:table_header)
+          attrs[:tbl_header] = self.class.coerce_table_header(val)
+        end
+        super
+      end
     end
   end
 end

data/lib/uniword/wordprocessingml/yaml_writer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Wordprocessingml
+    # Internal helper for the models that map YAML keys through `with:`
+    # transforms.
+    #
+    # lutaml-model hands a `to:` method the accumulating hash and throws its
+    # return value away, so every writer has to assign into that hash.
+    # Returning the value instead made to_yaml emit "--- {}" for a fully
+    # populated model.
+    module YamlWriter
+      # Write one YAML key, skipping the ones this model does not set.
+      #
+      # @param doc [Hash] Accumulating YAML hash
+      # @param key [String] YAML key to write
+      # @param value [Object, nil] Value, or nil to leave the key out
+      # @return [void]
+      def yaml_put(doc, key, value)
+        doc[key] = value unless value.nil?
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml.rb

@@ -36,6 +36,12 @@ module Uniword
     autoload :Insertion, "uniword/wordprocessingml/insertion"
     autoload :Deletion, "uniword/wordprocessingml/deletion"
 
+    # Tracked paragraph marks (CT_TrackChange inside pPr/rPr)
+    autoload :DeletedParagraphMark,
+             "uniword/wordprocessingml/deleted_paragraph_mark"
+    autoload :InsertedParagraphMark,
+             "uniword/wordprocessingml/inserted_paragraph_mark"
+
     autoload :NoBreakHyphen, "uniword/wordprocessingml/no_break_hyphen"
     autoload :LastRenderedPageBreak,
              "uniword/wordprocessingml/last_rendered_page_break"
@@ -89,10 +95,13 @@ module Uniword
     # Document settings and defaults
     autoload :Settings, "uniword/wordprocessingml/settings"
     autoload :ProofState, "uniword/wordprocessingml/proof_state"
-    autoload :StylePaneFormatFilter, "uniword/wordprocessingml/style_pane_format_filter"
+    autoload :StylePaneFormatFilter,
+             "uniword/wordprocessingml/style_pane_format_filter"
     autoload :DefaultTabStop, "uniword/wordprocessingml/default_tab_stop"
-    autoload :CharacterSpacingControl, "uniword/wordprocessingml/character_spacing_control"
-    autoload :DoNotDisplayPageBoundaries, "uniword/wordprocessingml/do_not_display_page_boundaries"
+    autoload :CharacterSpacingControl,
+             "uniword/wordprocessingml/character_spacing_control"
+    autoload :DoNotDisplayPageBoundaries,
+             "uniword/wordprocessingml/do_not_display_page_boundaries"
     autoload :TrackChanges, "uniword/wordprocessingml/track_changes"
     autoload :Rsids, "uniword/wordprocessingml/rsids"
     autoload :RsidRoot, "uniword/wordprocessingml/rsid_root"
@@ -115,7 +124,8 @@ module Uniword
     autoload :DecimalSymbol, "uniword/wordprocessingml/decimal_symbol"
     autoload :ListSeparator, "uniword/wordprocessingml/list_separator"
     autoload :W14DocId, "uniword/wordprocessingml/w14_doc_id"
-    autoload :W15ChartTrackingRefBased, "uniword/wordprocessingml/w15_chart_tracking_ref_based"
+    autoload :W15ChartTrackingRefBased,
+             "uniword/wordprocessingml/w15_chart_tracking_ref_based"
     autoload :W15DocId, "uniword/wordprocessingml/w15_doc_id"
     autoload :AttachedTemplate, "uniword/wordprocessingml/attached_template"
     autoload :HdrShapeDefaults, "uniword/wordprocessingml/hdr_shape_defaults"
@@ -238,6 +248,9 @@ module Uniword
     autoload :HideMark, "uniword/wordprocessingml/hide_mark"
     autoload :TextDirection, "uniword/wordprocessingml/text_direction"
 
+    # Shared YAML serialization helper mixed into the models below
+    autoload :YamlWriter, "uniword/wordprocessingml/yaml_writer"
+
     # Properties classes (consolidated from Ooxml::WordProcessingML)
     autoload :ParagraphProperties,
              "uniword/wordprocessingml/paragraph_properties"

data/lib/uniword.rb

@@ -94,6 +94,8 @@ module Uniword
   autoload :DependencyError, "uniword/errors"
   autoload :UnsupportedOperationError, "uniword/errors"
   autoload :ConversionError, "uniword/errors"
+  autoload :MissingVariablesError, "uniword/errors"
+  autoload :FidelityError, "uniword/errors"
 
   # Styles (moved to wordprocessingml/styles/)
   autoload :Styles, "uniword/wordprocessingml/styles"
@@ -147,11 +149,16 @@ module Uniword
   # Plugin system (validators, transformers, CLI commands).
   autoload :Plugin, "uniword/plugin"
 
+  # Plain-text (Markdown / AsciiDoc) conversion via Coradoc. The
+  # coradoc gems are optional at runtime and lazily required.
+  autoload :Converter, "uniword/converter"
+
   # CLI
   module Cli
     autoload :Completions, "uniword/cli/completions"
     autoload :HelpSwitch, "uniword/cli/help_switch"
     autoload :NoColor, "uniword/cli/no_color"
+    autoload :PlainTextCommand, "uniword/cli/plain_text_command"
   end
   autoload :CLI, "uniword/cli/main"
   autoload :GenerateCLI, "uniword/cli/generate_cli"
@@ -165,6 +172,8 @@ module Uniword
   autoload :ResourcesCLI, "uniword/cli/resources_cli"
   autoload :ThemeCLI, "uniword/cli/theme_cli"
   autoload :ReviewCLI, "uniword/cli/review_cli"
+  autoload :CommentsCLI, "uniword/cli/comments_cli"
+  autoload :RevisionsCLI, "uniword/cli/revisions_cli"
   autoload :TocCLI, "uniword/cli/toc_cli"
   autoload :ImagesCLI, "uniword/cli/images_cli"
   autoload :SpellcheckCLI, "uniword/cli/spellcheck_cli"