uniword 1.7.0 → 1.7.2

data/lib/uniword/properties/boolean_element_factory.rb

@@ -4,12 +4,57 @@ require "lutaml/model"
 
 module Uniword
   module Properties
-    # OOXML boolean element mixin for value/val getter logic only.
+    # Shared reading and writing behaviour for OOXML ST_OnOff elements.
+    #
     # The val= setter must be defined AFTER attribute :val to override
-    # the generated setter.
+    # the generated setter, so includers pull in BooleanValSetter separately.
     module BooleanElement
+      # Move a `value:` key onto `val:`.
+      #
+      # lutaml-model drops constructor keys it does not know, so
+      # `Bold.new(value: "0")` used to build an ON toggle and throw the
+      # argument away. An explicit `val:` still wins.
+      #
+      # @param attrs [Hash, Object] Constructor arguments
+      # @return [Hash, Object] Arguments with `value` renamed to `val`
+      def self.alias_value_key(attrs)
+        return attrs unless attrs.is_a?(Hash)
+
+        key = [:value, "value"].find { |k| attrs.key?(k) }
+        return attrs if key.nil?
+
+        attrs = attrs.dup
+        aliased = attrs.delete(key)
+        attrs[:val] = aliased unless attrs.key?(:val) || attrs.key?("val")
+        attrs
+      end
+
+      def initialize(attrs = {})
+        super(BooleanElement.alias_value_key(attrs))
+      end
+
+      # ST_OnOff (ECMA-376 §17.17.4) spells off as "0", "false" or "off".
+      # An absent w:val means the toggle is on. Unknown tokens read as on:
+      # a reader must not raise on a malformed document.
+      #
+      # @return [Boolean] true when the toggle is on
+      def on?
+        Ooxml::Types::OoxmlBoolean.on?(val)
+      end
+
+      # One reading for every consumer.
+      #
+      # This used to be `val != "false"`, which read "0" and "off" as on.
+      # Word shows both as off.
+      #
+      # @return [Boolean] true when the toggle is on
       def value
-        val != "false"
+        on?
+      end
+
+      # @param new_value [Object] Any ST_OnOff spelling, or a Ruby boolean
+      def value=(new_value)
+        self.val = new_value
       end
     end
 

data/lib/uniword/properties/boolean_formatting.rb

@@ -18,5 +18,9 @@ module Uniword
     BooleanElementFactory.define("qFormat", "QuickFormat")
     BooleanElementFactory.define("keepNext", "KeepNext")
     BooleanElementFactory.define("keepLines", "KeepLines")
+
+    # Paragraph-level boolean elements
+    BooleanElementFactory.define("suppressLineNumbers", "SuppressLineNumbers")
+    BooleanElementFactory.define("bidi", "Bidi")
   end
 end

data/lib/uniword/properties/outline.rb

@@ -9,25 +9,16 @@ module Uniword
     # Represents <w:outline/> or <w:outline w:val="false"/>
     # Used in run properties (w:rPr) for outline text effect
     class Outline < Lutaml::Model::Serializable
-      attribute :val, :string
+      include BooleanElement
+
+      attribute :val, :string, default: nil
+      include BooleanValSetter
 
       xml do
         element "outline"
         namespace Uniword::Ooxml::Namespaces::WordProcessingML
         map_attribute "val", to: :val, render_nil: false, render_default: false
       end
-
-      # Handle boolean-like values for val attribute
-      # nil = true (element present without val means true)
-      # 'false' = false
-      def initialize(attrs = {})
-        if [true, "true"].include?(attrs[:val])
-          attrs[:val] = nil # true = no val attribute
-        elsif [false, "false"].include?(attrs[:val])
-          attrs[:val] = "false"
-        end
-        super
-      end
     end
   end
 end

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

@@ -33,55 +33,34 @@ module Uniword
 
         return violations unless @require_alt_text
 
-        image_count = 0
-        document.paragraphs.each_with_index do |para, para_index|
-          # Images are in runs as drawings
-          para.runs.each do |run|
-            run.drawings.each do |drawing|
-              image_count += 1
+        # Same drawings the accessibility rule and the renderer see, table
+        # cells included, read through the same Drawing#alt_text.
+        document.images.each_with_index do |drawing, index|
+          image_count = index + 1
+          alt_text = drawing.alt_text
 
-              alt_text = extract_alt_text(drawing)
-
-              if alt_text.nil? || alt_text.empty?
-                violations << create_violation(
-                  severity: :error,
-                  message: "Image #{image_count} is missing alt text. " \
-                           "Alt text is required for accessibility.",
-                  location: "Paragraph #{para_index + 1}, Image #{image_count}",
-                  element: drawing,
-                )
-              elsif alt_text.length < @min_length
-                violations << create_violation(
-                  severity: :warning,
-                  message: "Image #{image_count} has alt text that is too short " \
-                           "(#{alt_text.length} characters, minimum: #{@min_length}). " \
-                           "Provide more descriptive alt text.",
-                  location: "Paragraph #{para_index + 1}, Image #{image_count}",
-                  element: drawing,
-                )
-              end
-            end
+          if alt_text.nil?
+            violations << create_violation(
+              severity: :error,
+              message: "Image #{image_count} is missing alt text. " \
+                       "Alt text is required for accessibility.",
+              location: "Image #{image_count}",
+              element: drawing,
+            )
+          elsif alt_text.length < @min_length
+            violations << create_violation(
+              severity: :warning,
+              message: "Image #{image_count} has alt text that is too short " \
+                       "(#{alt_text.length} characters, minimum: #{@min_length}). " \
+                       "Provide more descriptive alt text.",
+              location: "Image #{image_count}",
+              element: drawing,
+            )
           end
         end
 
         violations
       end
-
-      private
-
-      # Extract alt text from image (Drawing element)
-      #
-      # In OOXML, alt text is stored in:
-      # - drawing.inline.doc_properties.descr (for inline images)
-      # - drawing.anchor.doc_properties.descr (for anchored images)
-      #
-      # @param drawing [Drawing] The drawing element to extract alt text from
-      # @return [String, nil] Alt text or nil if not present
-      def extract_alt_text(drawing)
-        # Try inline first, then anchor
-        doc_props = drawing&.inline&.doc_properties || drawing&.anchor&.doc_properties
-        doc_props&.descr
-      end
     end
   end
 end

data/lib/uniword/review/review_manager.rb

@@ -100,6 +100,45 @@ module Uniword
         comment
       end
 
+      # Resolve a comment with Word semantics: remove the comment entry
+      # and every anchor marker referencing it (commentRangeStart,
+      # commentRangeEnd, and the commentReference run) from the body.
+      #
+      # @param comment_id [String] The comment ID to resolve
+      # @return [Uniword::Comment, nil] The removed comment
+      def resolve_comment!(comment_id)
+        comment = comments_part.find_comment(comment_id)
+        return nil unless comment
+
+        strip_comment_anchors(comment_id.to_s)
+        comments_part.remove_comment(comment_id)
+      end
+
+      # Anchor a comment entry around a paragraph using Word's canonical
+      # markup (range start/end plus the styled reference run).
+      #
+      # @param comment_id [String] The comment ID to anchor
+      # @param paragraph [Wordprocessingml::Paragraph, nil] anchor target
+      # @return [void]
+      def anchor_comment(comment_id, paragraph)
+        Builder::CommentAnchorer.anchor(paragraph, comment_id)
+      end
+
+      # Map of comment ID to the text of the paragraph anchoring it.
+      #
+      # @return [Hash{String => String}] anchored paragraph text per ID;
+      #   IDs without an anchor in the body are absent
+      def comment_anchor_texts
+        texts = {}
+        each_body_paragraph do |paragraph|
+          paragraph.comment_range_starts.each do |marker|
+            id = marker.id.to_s
+            texts[id] ||= paragraph.text
+          end
+        end
+        texts
+      end
+
       # Remove a comment from the document.
       #
       # @param comment_id [String] The comment ID to remove
@@ -281,11 +320,99 @@ module Uniword
           end
         end
         unless @resolver_hydrated
-          @resolver.hydrate(@tracked_changes)
+          # The facade is shared on the document, so a second manager
+          # (or a second verb on the same manager chain) would re-run
+          # the resolver over already-hydrated entries and duplicate
+          # every revision. Hydrate only a facade that is still empty;
+          # a populated one is already in sync with the document.
+          @resolver.hydrate(@tracked_changes) if @tracked_changes.revisions.empty?
           @resolver_hydrated = true
         end
         @tracked_changes
       end
+
+      # --- Comment anchor removal ---------------------------------------
+
+      # Remove every anchor marker for a comment ID from the body,
+      # tables and SDT content included. Mirrors RevisionResolver's
+      # element_order surgery: parsed models keep serialization order in
+      # element_order, so each removed element's order entry goes with it.
+      #
+      # @param comment_id [String] The comment ID being resolved
+      # @return [void]
+      def strip_comment_anchors(comment_id)
+        each_body_paragraph do |paragraph|
+          remove_anchored_elements(paragraph, :comment_range_starts,
+                                   "commentRangeStart", comment_id)
+          remove_anchored_elements(paragraph, :comment_range_ends,
+                                   "commentRangeEnd", comment_id)
+          remove_reference_runs(paragraph, comment_id)
+        end
+      end
+
+      # @yieldparam paragraph [Wordprocessingml::Paragraph]
+      # @return [void]
+      def each_body_paragraph(&block)
+        containers = [@document.body].compact
+        FindReplace::ParagraphWalker.each_paragraph(containers, &block)
+      end
+
+      # Remove the elements with the ID from a paragraph collection,
+      # keeping element_order in sync.
+      #
+      # @param paragraph [Wordprocessingml::Paragraph]
+      # @param collection_name [Symbol] reader of the marker collection
+      # @param tag [String] element_order tag of the marker
+      # @param comment_id [String] the comment ID being resolved
+      # @return [void]
+      def remove_anchored_elements(paragraph, collection_name, tag,
+                                   comment_id)
+        collection = paragraph.public_send(collection_name)
+        matching = collection.select { |element| element.id.to_s == comment_id }
+        matching.each do |element|
+          index = collection.index(element)
+          collection.delete(element)
+          remove_nth_order_entry(paragraph, tag, index)
+        end
+      end
+
+      # Remove the runs carrying the comment's w:commentReference.
+      #
+      # @param paragraph [Wordprocessingml::Paragraph]
+      # @param comment_id [String] the comment ID being resolved
+      # @return [void]
+      def remove_reference_runs(paragraph, comment_id)
+        paragraph.runs.select do |run|
+          run.comment_reference&.id.to_s == comment_id
+        end.each do |run|
+          index = paragraph.runs.index(run)
+          paragraph.runs.delete(run)
+          remove_nth_order_entry(paragraph, "r", index)
+        end
+      end
+
+      # Drop the index-th entry named `tag` from a model's element_order
+      # (no-op without a parsed order or when the entry is missing).
+      #
+      # @param model [Lutaml::Model::Serializable]
+      # @param tag [String]
+      # @param index [Integer, nil]
+      # @return [void]
+      def remove_nth_order_entry(model, tag, index)
+        order = Ooxml::ElementOrder.mutable_order(model)
+        return unless order && index
+
+        seen = -1
+        order.each_with_index do |entry, i|
+          next unless entry.name == tag
+
+          seen += 1
+          next unless seen == index
+
+          order.delete_at(i)
+          return
+        end
+      end
     end
   end
 end

data/lib/uniword/template/fill_result.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Uniword
+  module Template
+    # Value object holding the result of a template fill operation.
+    #
+    # Counts filled placeholders per source kind (content controls,
+    # MERGEFIELD simple fields, {{var}} text placeholders) and records
+    # the variable names that had no data. Returned by `Filler#fill`.
+    #
+    # @example
+    #   result = Filler.new(document).fill(data)
+    #   puts result.summary
+    #   puts result.to_json
+    class FillResult
+      # Placeholder source kinds, in fill precedence order.
+      SOURCES = %i[sdt mergefield text].freeze
+
+      attr_reader :filled, :missing_counts
+
+      def initialize
+        @filled = SOURCES.to_h { |kind| [kind, 0] }
+        @missing_counts = Hash.new { |hash, key| hash[key] = 0 }
+      end
+
+      # Record one filled placeholder of the given source kind.
+      #
+      # @param source [Symbol] one of SOURCES (e.g. :sdt, :mergefield, :text)
+      # @return [void]
+      def add(source)
+        @filled[source] += 1
+      end
+
+      # Record one occurrence of a variable with no data.
+      #
+      # @param name [String] the missing variable name
+      # @return [void]
+      def record_missing(name)
+        @missing_counts[name] += 1
+      end
+
+      # Total number of filled placeholders across all source kinds.
+      #
+      # @return [Integer]
+      def total_filled
+        @filled.values.sum
+      end
+
+      # Missing variable names, sorted alphabetically.
+      #
+      # @return [Array<String>]
+      def missing
+        @missing_counts.keys.sort
+      end
+
+      # Whether every placeholder found a value (nothing missing).
+      #
+      # @return [Boolean]
+      def complete?
+        missing.empty?
+      end
+
+      # Whether no placeholder was filled at all.
+      #
+      # @return [Boolean]
+      def empty?
+        total_filled.zero?
+      end
+
+      # Human-readable summary of the fill operation.
+      #
+      # @return [String]
+      def summary
+        parts = SOURCES.filter_map do |kind|
+          count = @filled[kind]
+          "#{count} #{kind} placeholder(s)" if count.positive?
+        end
+
+        summary = if parts.empty?
+                    "No placeholders filled."
+                  else
+                    filled_summary(parts)
+                  end
+        summary += missing_summary if missing.any?
+        summary
+      end
+
+      # Serialize to JSON string.
+      #
+      # @return [String] Pretty-printed JSON
+      def to_json(*_args)
+        JSON.pretty_generate(to_h)
+      end
+
+      # Convert to a plain Hash suitable for serialization.
+      #
+      # @return [Hash]
+      def to_h
+        {
+          filled: @filled.dup,
+          total_filled: total_filled,
+          missing: missing,
+          missing_counts: @missing_counts.dup,
+          summary: summary,
+        }
+      end
+
+      private
+
+      def filled_summary(parts)
+        "Filled #{total_filled} placeholder(s) (#{parts.join(', ')})."
+      end
+
+      def missing_summary
+        " Missing variable(s) left untouched: #{missing.join(', ')}."
+      end
+    end
+  end
+end