uniword 1.7.1 → 1.7.3

data/lib/uniword/wordprocessingml/paragraph_properties.rb

@@ -9,6 +9,8 @@ module Uniword
     # Represents w:pPr element containing paragraph-level formatting.
     # Used in StyleSets and document paragraph elements.
     class ParagraphProperties < Lutaml::Model::Serializable
+      include YamlWriter
+
       # Pattern 0: ATTRIBUTES FIRST, then XML mappings
 
       # Simple element attributes (OOXML w:val attributes stored in
@@ -22,8 +24,9 @@ module Uniword
       attribute :outline_level, Properties::OutlineLevel
       attribute :numbering_properties, Properties::NumberingProperties
 
-      # Complex spacing object
-      attribute :spacing, Properties::Spacing
+      # Complex spacing objects. Word can emit more than one w:spacing in a
+      # single w:pPr, so this is a collection.
+      attribute :spacing, Properties::Spacing, collection: true
 
       # Complex indentation object
       attribute :indentation, Properties::Indentation
@@ -64,10 +67,15 @@ module Uniword
 
       # Spacing options
       attribute :contextual_spacing, Properties::ContextualSpacing
-      attribute :suppress_line_numbers, :boolean, default: -> { false }
+
+      # w:suppressLineNumbers and w:bidi are ST_OnOff elements, not plain
+      # booleans. Declared as :boolean they read "" for every spelling, so an
+      # explicitly-off flag was indistinguishable from an on one, and a
+      # parsed element was dropped on the way back out.
+      attribute :suppress_line_numbers_wrapper, Properties::SuppressLineNumbers
 
       # Bidirectional text
-      attribute :bidirectional, :boolean, default: -> { false }
+      attribute :bidirectional_wrapper, Properties::Bidi
 
       # East Asian typography
       attribute :auto_space_de, Properties::AutoSpaceDE
@@ -104,11 +112,15 @@ module Uniword
                     to: :yaml_page_break_before_to }
         map "outline_level",
             with: { from: :yaml_outline_level_from, to: :yaml_outline_level_to }
-        map "suppress_line_numbers", to: :suppress_line_numbers
+        map "suppress_line_numbers",
+            with: { from: :yaml_suppress_line_numbers_from,
+                    to: :yaml_suppress_line_numbers_to }
         map "contextual_spacing",
             with: { from: :yaml_contextual_spacing_from,
                     to: :yaml_contextual_spacing_to }
-        map "bidirectional", to: :bidirectional
+        map "bidirectional",
+            with: { from: :yaml_bidirectional_from,
+                    to: :yaml_bidirectional_to }
         map "indent_left", to: :indent_left
         map "indent_right", to: :indent_right
         map "indent_first_line", to: :indent_first_line
@@ -117,7 +129,9 @@ module Uniword
       end
 
       # YAML transform methods (instance methods called by lutaml-model's
-      # `with:` transform mechanism)
+      # `with:` transform mechanism). Every writer assigns through
+      # YamlWriter#yaml_put; see that module for why.
+
       def yaml_style_from(instance, value)
         if value
           instance.style = [
@@ -126,40 +140,42 @@ module Uniword
         end
       end
 
-      def yaml_style_to(instance, _doc)
-        Array(instance.style).first&.value
+      def yaml_style_to(instance, doc)
+        yaml_put(doc, "style", Array(instance.style).first&.value)
       end
 
       def yaml_alignment_from(instance, value)
         instance.alignment = Properties::Alignment.new(value: value) if value
       end
 
-      def yaml_alignment_to(instance, _doc)
-        instance.alignment&.value
+      def yaml_alignment_to(instance, doc)
+        yaml_put(doc, "alignment", instance.alignment&.value)
       end
 
       def yaml_keep_next_from(instance, value)
         instance.keep_next_wrapper = Properties::KeepNext.new(value: value) unless value.nil?
       end
 
-      def yaml_keep_next_to(instance, _doc)
-        instance.keep_next_wrapper&.value
+      # Toggles read through BooleanElement#on?, the same reading the XML and
+      # predicate consumers get, so w:val="0" and w:val="off" stay off.
+      def yaml_keep_next_to(instance, doc)
+        yaml_put(doc, "keep_next", instance.keep_next_wrapper&.on?)
       end
 
       def yaml_keep_lines_from(instance, value)
         instance.keep_lines_wrapper = Properties::KeepLines.new(value: value) unless value.nil?
       end
 
-      def yaml_keep_lines_to(instance, _doc)
-        instance.keep_lines_wrapper&.value
+      def yaml_keep_lines_to(instance, doc)
+        yaml_put(doc, "keep_lines", instance.keep_lines_wrapper&.on?)
       end
 
       def yaml_outline_level_from(instance, value)
         instance.outline_level = Properties::OutlineLevel.new(value: value.to_i) if value
       end
 
-      def yaml_outline_level_to(instance, _doc)
-        instance.outline_level&.value
+      def yaml_outline_level_to(instance, doc)
+        yaml_put(doc, "outline_level", instance.outline_level&.value)
       end
 
       def yaml_contextual_spacing_from(instance, value)
@@ -168,8 +184,8 @@ module Uniword
         instance.contextual_spacing = Properties::ContextualSpacing.new(value: value)
       end
 
-      def yaml_contextual_spacing_to(instance, _doc)
-        instance.contextual_spacing&.value
+      def yaml_contextual_spacing_to(instance, doc)
+        yaml_put(doc, "contextual_spacing", instance.contextual_spacing&.on?)
       end
 
       def yaml_page_break_before_from(instance, value)
@@ -178,8 +194,8 @@ module Uniword
         instance.page_break_before_wrapper = Properties::PageBreakBefore.new(value: value)
       end
 
-      def yaml_page_break_before_to(instance, _doc)
-        instance.page_break_before_wrapper&.value
+      def yaml_page_break_before_to(instance, doc)
+        yaml_put(doc, "page_break_before", instance.page_break_before_wrapper&.on?)
       end
 
       def yaml_widow_control_from(instance, value)
@@ -188,8 +204,44 @@ module Uniword
         instance.widow_control_wrapper = Properties::WidowControl.new(value: value)
       end
 
-      def yaml_widow_control_to(instance, _doc)
-        instance.widow_control_wrapper&.value
+      def yaml_widow_control_to(instance, doc)
+        yaml_put(doc, "widow_control", instance.widow_control_wrapper&.on?)
+      end
+
+      def yaml_suppress_line_numbers_from(instance, value)
+        return if value.nil?
+
+        instance.suppress_line_numbers_wrapper =
+          Properties::SuppressLineNumbers.new(value: value)
+      end
+
+      def yaml_suppress_line_numbers_to(instance, doc)
+        yaml_put(doc, "suppress_line_numbers",
+                 instance.suppress_line_numbers_wrapper&.on?)
+      end
+
+      def yaml_bidirectional_from(instance, value)
+        return if value.nil?
+
+        instance.bidirectional_wrapper = Properties::Bidi.new(value: value)
+      end
+
+      def yaml_bidirectional_to(instance, doc)
+        yaml_put(doc, "bidirectional", instance.bidirectional_wrapper&.on?)
+      end
+
+      # Is line numbering suppressed for this paragraph?
+      #
+      # @return [Boolean] false when w:suppressLineNumbers is absent or off
+      def suppress_line_numbers
+        suppress_line_numbers_wrapper&.on? || false
+      end
+
+      # Does this paragraph run right-to-left?
+      #
+      # @return [Boolean] false when w:bidi is absent or off
+      def bidirectional
+        bidirectional_wrapper&.on? || false
       end
 
       # XML mappings come AFTER attributes
@@ -214,8 +266,9 @@ module Uniword
         # 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,
+        # Suppress line numbers (only render if present)
+        map_element "suppressLineNumbers", to: :suppress_line_numbers_wrapper,
+                                           render_nil: false,
                                            render_default: false
 
         # Borders (complex object)
@@ -233,8 +286,8 @@ module Uniword
         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,
+        # Bidirectional (only render if present)
+        map_element "bidi", to: :bidirectional_wrapper, render_nil: false,
                             render_default: false
 
         # Right indent adjustment
@@ -271,6 +324,9 @@ module Uniword
         keep_lines_val = attrs.key?(:keep_lines) ? attrs.delete(:keep_lines) : nil
         page_break_before_val = attrs.key?(:page_break_before) ? attrs.delete(:page_break_before) : nil
         widow_control_val = attrs.key?(:widow_control) ? attrs.delete(:widow_control) : nil
+        suppress_line_numbers_val =
+          attrs.key?(:suppress_line_numbers) ? attrs.delete(:suppress_line_numbers) : nil
+        bidirectional_val = attrs.key?(:bidirectional) ? attrs.delete(:bidirectional) : nil
         style_val = attrs.key?(:style) ? attrs.delete(:style) : nil
 
         super
@@ -290,12 +346,47 @@ module Uniword
           self.widow_control_wrapper =
             Properties::WidowControl.new(value: widow_control_val)
         end
+        unless suppress_line_numbers_val.nil?
+          self.suppress_line_numbers_wrapper =
+            Properties::SuppressLineNumbers.new(value: suppress_line_numbers_val)
+        end
+        unless bidirectional_val.nil?
+          self.bidirectional_wrapper =
+            Properties::Bidi.new(value: bidirectional_val)
+        end
         self.style = style_val if style_val
 
         # Convert flat attributes to wrapper objects (Pattern 0: after super)
         convert_flat_attributes!
       end
 
+      # First w:spacing entry, appending one when absent
+      #
+      # Word can emit more than one w:spacing inside a single w:pPr, so the
+      # attribute is a collection. Callers setting individual spacing fields
+      # want the first entry.
+      #
+      # Each field named in +clearing+ is dropped from the later entries. A
+      # value written into the first entry while a later one still carries its
+      # own would emit two contradictory values, and a last-wins reader keeps
+      # the stale one.
+      #
+      # @param clearing [Array<Symbol>] fields the caller is about to write
+      # @return [Properties::Spacing] the first spacing entry
+      def ensure_spacing(*clearing)
+        entries = Array(spacing)
+        if entries.empty?
+          entries = [Properties::Spacing.new]
+          self.spacing = entries
+        end
+
+        entries.drop(1).each do |stale|
+          clearing.each { |field| stale.public_send(:"#{field}=", nil) }
+        end
+
+        entries.first
+      end
+
       # Convert flat convenience attributes to proper wrapper objects
       # This handles cases like ParagraphProperties.new(spacing_before: 120)
       # where the flat attribute is set but the wrapper object is not
@@ -303,13 +394,16 @@ module Uniword
         # Alignment - convert string to Alignment wrapper
         self.alignment = Properties::Alignment.new(value: @alignment) if @alignment.is_a?(String)
 
-        # Spacing - create spacing object from flat spacing attributes
-        if (@spacing_before || @spacing_after || @line_spacing || @line_rule) && !@spacing
-          self.spacing = Properties::Spacing.new
-          spacing.before = @spacing_before if @spacing_before
-          spacing.after = @spacing_after if @spacing_after
-          spacing.line = @line_spacing.to_i if @line_spacing
-          spacing.line_rule = @line_rule if @line_rule
+        # Spacing - create spacing object from flat spacing attributes.
+        # Array() covers both absent forms: nil when built, [] when parsed.
+        if (@spacing_before || @spacing_after || @line_spacing || @line_rule) &&
+            Array(@spacing).empty?
+          entry = Properties::Spacing.new
+          entry.before = @spacing_before if @spacing_before
+          entry.after = @spacing_after if @spacing_after
+          entry.line = @line_spacing.to_i if @line_spacing
+          entry.line_rule = @line_rule if @line_rule
+          self.spacing = [entry]
         end
 
         # Indentation - create indentation object from flat indent attributes

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

@@ -9,6 +9,25 @@ module Uniword
       # (e.g., RunProperties.new(bold: true)) and the wrapper
       # objects (e.g., Properties::Bold) required by lutaml-model.
       module Conversion
+        # Every rPr attribute whose value is an ST_OnOff toggle element.
+        BOOLEAN_WRAPPERS = {
+          bold: Properties::Bold,
+          bold_cs: Properties::BoldCs,
+          italic: Properties::Italic,
+          italic_cs: Properties::ItalicCs,
+          strike: Properties::Strike,
+          double_strike: Properties::DoubleStrike,
+          small_caps: Properties::SmallCaps,
+          caps: Properties::Caps,
+          hidden: Properties::Vanish,
+          no_proof: Properties::NoProof,
+          web_hidden: Properties::WebHidden,
+          shadow: Properties::Shadow,
+          emboss: Properties::Emboss,
+          imprint: Properties::Imprint,
+          outline: Properties::Outline,
+        }.freeze
+
         def initialize(attrs = {})
           # Extract flat convenience keys before super (lutaml-model ignores
           # unknown keys). These are converted to proper wrapper objects below.
@@ -96,16 +115,18 @@ module Uniword
           shading.pattern = type_val if type_val
         end
 
+        # Wrap every ST_OnOff toggle handed in as a primitive.
+        #
+        # `false` is a value, not an absence: testing truthiness here left a
+        # raw Ruby false on the attribute and to_xml then died on it.
         def convert_boolean_attrs!
-          @bold = Properties::Bold.new(value: @bold) if @bold && !@bold.is_a?(Properties::Bold)
-          @bold_cs = Properties::BoldCs.new(value: @bold_cs) if @bold_cs && !@bold_cs.is_a?(Properties::BoldCs)
-          @italic = Properties::Italic.new(value: @italic) if @italic && !@italic.is_a?(Properties::Italic)
-          @italic_cs = Properties::ItalicCs.new(value: @italic_cs) if @italic_cs && !@italic_cs.is_a?(Properties::ItalicCs)
-          @strike = Properties::Strike.new(value: @strike) if @strike && !@strike.is_a?(Properties::Strike)
-          @double_strike = Properties::DoubleStrike.new(value: @double_strike) if @double_strike && !@double_strike.is_a?(Properties::DoubleStrike)
-          @small_caps = Properties::SmallCaps.new(value: @small_caps) if @small_caps && !@small_caps.is_a?(Properties::SmallCaps)
-          @caps = Properties::Caps.new(value: @caps) if @caps && !@caps.is_a?(Properties::Caps)
-          @hidden = Properties::Vanish.new(value: @hidden) if @hidden && !@hidden.is_a?(Properties::Vanish)
+          BOOLEAN_WRAPPERS.each do |name, klass|
+            current = instance_variable_get(:"@#{name}")
+            next if current.nil? || current.is_a?(klass) ||
+              Lutaml::Model::Utils.uninitialized?(current)
+
+            instance_variable_set(:"@#{name}", klass.new(val: current))
+          end
         end
 
         def convert_style_attr!

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

@@ -5,30 +5,19 @@ module Uniword
     class RunProperties < Lutaml::Model::Serializable
       # Boolean predicate methods for RunProperties.
       #
-      # Unwraps boolean property objects and returns true/false.
+      # Every predicate reads through BooleanElement#on?, so all of them
+      # agree on what "0", "off" and an absent w:val mean.
       module Predicates
         def bold?
-          val = bold
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-          val == true
+          toggle_on?(bold)
         end
 
         def italic?
-          val = italic
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-          val == true
+          toggle_on?(italic)
         end
 
         def strike?
-          val = strike
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-          val == true
+          toggle_on?(strike)
         end
 
         def all_caps
@@ -36,59 +25,45 @@ module Uniword
         end
 
         def caps?
-          val = caps
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Uniword::Properties::BooleanElement)
-          val == true
+          toggle_on?(caps)
         end
 
         def small_caps?
-          val = small_caps
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Properties::SmallCaps)
-          val == true
+          toggle_on?(small_caps)
         end
 
         def shadow?
-          val = shadow
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Properties::Shadow)
-          val == true
+          toggle_on?(shadow)
         end
 
         def imprint?
-          val = imprint
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Properties::Imprint)
-          val == true
+          toggle_on?(imprint)
         end
 
         def emboss?
-          val = emboss
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Properties::Emboss)
-          val == true
+          toggle_on?(emboss)
         end
 
         def hidden?
-          val = hidden
-          return false if val.nil?
-
-          val = val.value if val.is_a?(Properties::Vanish)
-          val == true
+          toggle_on?(hidden)
         end
 
         def outline?
-          val = outline
-          return false if val.nil?
+          toggle_on?(outline)
+        end
+
+        private
+
+        # Toggles arrive as BooleanElement wrappers when parsed and as plain
+        # booleans when a caller assigns one directly.
+        #
+        # @param toggle [Object, nil] Wrapper, boolean, or nil when absent
+        # @return [Boolean] true when the toggle is on
+        def toggle_on?(toggle)
+          return false if toggle.nil?
+          return toggle.on? if toggle.is_a?(Uniword::Properties::BooleanElement)
 
-          val = val.val if val.is_a?(Properties::Outline)
-          val != "false"
+          toggle == true
         end
       end
     end