uniword 1.6.0 → 1.7.0

data/lib/uniword/cli/main.rb

@@ -20,16 +20,22 @@ module Uniword
     long_desc <<~DESC
       Convert a document from one format to another.
 
-      Supported formats: DOCX, MHTML, HTML
+      Supported formats: DOCX, DOCM, DOTX, DOTM, MHTML/MHT, HTML
+
+      Use "-" as OUTPUT to write to stdout (binary formats print raw
+      bytes; pipe or redirect them).
 
       Examples:
         $ uniword convert input.docx output.mhtml
         $ uniword convert input.mhtml output.docx --verbose
         $ uniword convert input.html output.docx
+        $ uniword convert input.docx output.html
+        $ uniword convert input.docx - > converted.docx
     DESC
     option :from, aliases: "-f", desc: "Input format (docx/mhtml/html)",
                   type: :string
-    option :to, aliases: "-t", desc: "Output format (docx/mhtml)", type: :string
+    option :to, aliases: "-t", desc: "Output format (docx/mhtml/html)",
+                type: :string
     option :verbose, aliases: "-v", desc: "Verbose output", type: :boolean,
                      default: false
     def convert(input_path, output_path)
@@ -68,15 +74,30 @@ module Uniword
     DESC
     option :verbose, aliases: "-v", desc: "Show detailed information", type: :boolean,
                      default: false
+    option :json, type: :boolean, default: false,
+                  desc: "Output statistics as JSON (machine-readable)"
     def info(path)
-      say "Analyzing #{path}...", :green
-
       detector = ::Uniword::FormatDetector.new
       format = detector.detect(path)
-      say "\nFormat: #{format.to_s.upcase}", :cyan
-
       doc = load_document(path)
 
+      if options[:json]
+        require "json"
+        stats = {
+          path: path,
+          format: format.to_s.upcase,
+          paragraphs: doc.paragraphs.count,
+          tables: doc.tables.count,
+          text_length: doc.text.length,
+          styles: doc.styles_configuration&.styles&.count || 0,
+        }
+        puts JSON.pretty_generate(stats)
+        return
+      end
+
+      say "Analyzing #{path}...", :green
+      say "\nFormat: #{format.to_s.upcase}", :cyan
+
       say "\nDocument Statistics:", :cyan
       say "  Paragraphs: #{doc.paragraphs.count}"
       say "  Tables: #{doc.tables.count}"
@@ -130,15 +151,32 @@ module Uniword
     DESC
     option :verbose, aliases: "-v", desc: "Show detailed validation results", type: :boolean,
                      default: false
+    option :json, type: :boolean, default: false,
+                  desc: "Output the validation report as JSON (machine-readable)"
     def validate(path)
-      say "Validating #{path}...", :green
-
       doc = load_document(path)
-      say "File format is valid", :green
 
       issues = Uniword::Validation::Engine.run(
         Uniword::Validation::Rules::ModelContext.new(doc),
       )
+
+      if options[:json]
+        require "json"
+        puts JSON.pretty_generate(
+          path: path,
+          valid: issues.none?(&:error?),
+          issues: issues.map { |i|
+            { code: i.code, severity: i.severity,
+              part: i.part, message: i.message }
+          },
+        )
+        exit 1 if issues.any?(&:error?)
+        return
+      end
+
+      say "Validating #{path}...", :green
+      say "File format is valid", :green
+
       report_validation_issues(issues)
       report_content_presence(doc)
 
@@ -191,6 +229,8 @@ module Uniword
     long_desc <<~DESC
       Run document quality and accessibility checks.
 
+      Exits 1 when any report has error-level findings.
+
       Examples:
         $ uniword check document.docx
         $ uniword check document.docx --type accessibility
@@ -202,8 +242,14 @@ module Uniword
                      default: false
     option :json, desc: "Output JSON report", type: :boolean, default: false
     def check(path)
-      doc = load_document(path)
       check_type = options[:type]
+      unless CHECK_TYPES.include?(check_type)
+        say("Unknown check type: #{check_type} " \
+            "(valid: #{CHECK_TYPES.join(', ')})", :red)
+        exit 1
+      end
+
+      doc = load_document(path)
 
       reports = {}
 
@@ -219,14 +265,15 @@ module Uniword
 
       if options[:json]
         require "json"
-        output = reports.transform_values do |r|
-          { valid: r.valid?,
-            issues: r.is_a?(Uniword::Quality::CheckReport) ? r.issues.count : 0 }
+        output = reports.transform_values do |report|
+          { valid: report.valid?, issues: report.violations.count }
         end
         puts JSON.pretty_generate(output)
       else
         display_check_reports(reports)
       end
+
+      exit 1 if reports.values.any? { |report| !report.valid? }
     rescue Uniword::Error => e
       handle_error(e)
     rescue StandardError => e
@@ -383,6 +430,22 @@ module Uniword
       say "Uniword version #{Uniword::VERSION}", :green
     end
 
+    desc "completions [SHELL]", "Print shell completion script (bash|zsh|fish)"
+    long_desc <<~DESC
+      Print a self-contained shell completion script.
+
+      Install:
+        $ uniword completions bash >> ~/.bashrc
+        $ uniword completions zsh >> ~/.zshrc
+        $ uniword completions fish > ~/.config/fish/completions/uniword.fish
+    DESC
+    def completions(shell = "bash")
+      require "uniword/cli/completions"
+      puts Cli::Completions.script(shell, root: self.class)
+    rescue ArgumentError => e
+      handle_error(e)
+    end
+
     desc "redact INPUT OUTPUT", "Redact PII patterns from a document"
     long_desc <<~DESC
       Replace PII patterns (SSN, email, phone, credit card, IPv4)
@@ -406,6 +469,8 @@ module Uniword
     option :verbose, aliases: "-v", type: :boolean, default: false,
                      desc: "Show per-pattern counts"
     def redact(input_path, output_path)
+      validate_scopes!(options[:scope])
+      validate_redact_patterns!(options[:pattern])
       doc = load_document(input_path)
       patterns = resolve_redact_patterns(options[:pattern])
       result = doc.redact(patterns: patterns,
@@ -451,6 +516,8 @@ module Uniword
     option :verbose, aliases: "-v", type: :boolean, default: false,
                      desc: "Show per-scope counts"
     def find_replace(input_path, output_path, pattern, replacement)
+      validate_scopes!(options[:scope])
+      validate_regex!(pattern) if options[:regex]
       scopes = expand_scopes(options[:scope])
       doc = load_document(input_path)
       result = run_find_replace(doc, pattern, replacement, scopes)
@@ -541,6 +608,36 @@ module Uniword
       symbols
     end
 
+    # Valid values for `check --type`.
+    CHECK_TYPES = %w[all quality accessibility].freeze
+
+    def validate_scopes!(scopes)
+      valid = ["all"] + Uniword::FindReplace::Engine::ALL_SCOPES.map(&:to_s)
+      unknown = Array(scopes).map(&:to_s) - valid
+      return if unknown.empty?
+
+      say("Unknown scope: #{unknown.join(', ')} " \
+          "(valid: #{valid.join(', ')})", :red)
+      exit 1
+    end
+
+    def validate_regex!(pattern)
+      Regexp.new(pattern)
+    rescue RegexpError => e
+      say("Invalid regular expression: #{e.message}", :red)
+      exit 1
+    end
+
+    def validate_redact_patterns!(names)
+      valid = [:pii] + Uniword::Redact::PatternLibrary.all.map(&:name)
+      unknown = Array(names).map(&:to_sym) - valid
+      return if unknown.empty?
+
+      say("Unknown pattern: #{unknown.join(', ')} " \
+          "(valid: #{valid.join(', ')})", :red)
+      exit 1
+    end
+
     # Build the right matcher from --regex flag and run the engine.
     def run_find_replace(doc, pattern, replacement, scopes)
       matcher = build_find_replace_matcher(pattern, replacement)
@@ -679,14 +776,14 @@ module Uniword
         label = type.to_s.capitalize
         if report.valid?
           say("#{label}: No issues found", :green)
-        else
-          issue_count = report.is_a?(Uniword::Quality::CheckReport) ? report.issues.count : "?"
-          say("#{label}: #{issue_count} issue(s) found", :yellow)
-          if options[:verbose] && report.is_a?(Uniword::Quality::CheckReport)
-            report.issues.each do |issue|
-              say("  - #{issue}", :yellow)
-            end
-          end
+          next
+        end
+
+        say("#{label}: #{report.violations.count} issue(s) found", :yellow)
+        next unless options[:verbose]
+
+        report.violations.each do |violation|
+          say("  - #{violation.message}", :yellow)
         end
       end
     end

data/lib/uniword/cli/no_color.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Cli
+    # POSIX NO_COLOR convention (https://no-color.org/): when the
+    # environment variable is set (to any non-empty value), colored
+    # CLI output must be suppressed. Prepended onto Thor's shell only
+    # when the variable is present, so the zero-cost path is the norm.
+    module NoColor
+      def color?
+        return false if ENV["NO_COLOR"] && !ENV["NO_COLOR"].empty?
+
+        super
+      end
+    end
+  end
+end
+
+require "thor/shell/basic"
+
+Thor::Shell::Basic.prepend(Uniword::Cli::NoColor)

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/document_factory.rb

@@ -80,7 +80,7 @@ module Uniword
       rescue Zip::Error => e
         raise CorruptedFileError.new(path.to_s,
                                      "Invalid ZIP structure: #{e.message}")
-      rescue Nokogiri::XML::SyntaxError => e
+      rescue Moxml::ParseError => e
         raise CorruptedFileError.new(path.to_s, "Invalid XML: #{e.message}")
       rescue StandardError => e
         # Re-raise our custom errors
@@ -143,7 +143,7 @@ module Uniword
       rescue Zip::Error => e
         raise CorruptedFileError.new(path.to_s,
                                      "Invalid ZIP structure: #{e.message}")
-      rescue Nokogiri::XML::SyntaxError => e
+      rescue Moxml::ParseError => e
         raise CorruptedFileError.new(path.to_s, "Invalid XML: #{e.message}")
       rescue StandardError => e
         # Re-raise our custom errors

data/lib/uniword/document_writer.rb

@@ -49,36 +49,57 @@ module Uniword
     #
     # @example Save with explicit format
     #   writer.save("output.mht", format: :mhtml)
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
     def save(path, format: :auto, profile: nil, validate: nil)
       validate_path(path)
 
+      if path == "-"
+        # stdout: "-" cannot carry an extension; default to DOCX when
+        # the caller does not pin the format (use --to to override).
+        format = :docx if format == :auto
+        write_to_stream($stdout, format: format, validate: validate)
+        return
+      end
+
       format = infer_format(path) if format == :auto
 
       case format
       when :docx, :docm
         Docx::Package.to_file(document, path, profile: profile,
-                                            validate: validate)
+                                              validate: validate)
       when :dotx, :dotm
         Ooxml::DotxPackage.to_file(document, path, profile: profile,
-                                                 validate: validate)
+                                                   validate: validate)
       when :mhtml
         Mhtml::MhtmlPackage.to_file(document, path)
+      when :html
+        File.write(path, html_document)
       else
         raise ArgumentError,
               "No handler registered for format: #{format.inspect}"
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # Render the document as a standalone HTML string.
+    #
+    # @return [String] HTML document
+    def html_document
+      Transformation::OoxmlToHtmlConverter.document_to_html(document)
+    end
 
     # Infer the format from file extension.
     #
     # @param path [String] The file path
-    # @return [Symbol] The inferred format (:docx, :mhtml)
+    # @return [Symbol] The inferred format (:docx, :mhtml, :html)
     # @raise [ArgumentError] if format cannot be inferred
     #
     # @example Infer format
     #   format = writer.infer_format("output.docx")
     #   # => :docx
-    def infer_format(path)
+    def infer_format(path) # rubocop:disable Metrics/CyclomaticComplexity
       extension = File.extname(path).downcase
 
       case extension
@@ -90,16 +111,17 @@ module Uniword
         :dotx
       when ".dotm"
         :dotm
-      when ".mhtml", ".mht"
-        :mhtml
-      when ".doc"
-        # .doc can be MHTML saved with Word (not binary old Word format)
-        # We don't support binary .doc output, but MHTML .doc is valid
+      when ".html"
+        :html
+      # .doc can be MHTML saved with Word (not binary old Word format)
+      # We don't support binary .doc output, but MHTML .doc is valid
+      when ".mhtml", ".mht", ".doc"
         :mhtml
       else
         raise ArgumentError,
               "Cannot infer format from extension: #{extension}. " \
-              "Supported extensions: .docx, .docm, .dotx, .dotm, .mhtml, .mht"
+              "Supported extensions: .docx, .docm, .dotx, .dotm, " \
+              ".html, .mhtml, .mht, .doc"
       end
     end
 

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