uniword 1.7.0 → 1.7.2

data/lib/uniword/cli/plain_text_command.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Cli
+    # Mechanics for the top-level `to` / `from` CLI verbs (issue #80):
+    # format validation, document loading, conversion through
+    # Converter::PlainText, default output path derivation, and output
+    # writing. Presentation stays in CLI so in-process specs see the
+    # same output as the executable.
+    module PlainTextCommand
+      FORMATS = { "md" => :markdown, "adoc" => :asciidoc }.freeze
+
+      EXTENSIONS = { markdown: ".md", asciidoc: ".adoc" }.freeze
+
+      module_function
+
+      # Convert a DOCX file to a plain-text format.
+      #
+      # @param format_key [String] "md" or "adoc"
+      # @param input_path [String] path to the .docx input
+      # @param strict [Boolean] fail on fidelity loss
+      # @return [Converter::PlainTextResult]
+      def convert_to(format_key, input_path, strict: false)
+        format = normalize_format!(format_key)
+        document = load_document!(input_path)
+        converter = Converter::PlainText.new
+        if format == :markdown
+          converter.to_markdown_result(document, strict: strict)
+        else
+          converter.to_asciidoc_result(document, strict: strict)
+        end
+      end
+
+      # Convert a plain-text file to a DocumentRoot.
+      #
+      # @param format_key [String] "md" or "adoc"
+      # @param input_path [String] path to the .md/.adoc input
+      # @param strict [Boolean] fail on fidelity loss
+      # @return [Converter::PlainTextResult]
+      def convert_from(format_key, input_path, strict: false)
+        format = normalize_format!(format_key)
+        raise FileNotFoundError.new(input_path) unless File.exist?(input_path)
+
+        text = File.read(input_path)
+        converter = Converter::PlainText.new
+        if format == :markdown
+          converter.from_markdown_result(text, strict: strict)
+        else
+          converter.from_asciidoc_result(text, strict: strict)
+        end
+      end
+
+      # @param format_key [String] "md" or "adoc"
+      # @return [String] the canonical file extension (".md"/".adoc")
+      # @raise [UnsupportedOperationError] for unknown formats
+      def extension_for(format_key)
+        format = normalize_format!(format_key)
+        EXTENSIONS.fetch(format)
+      end
+
+      # Default output path: the input's basename with a new
+      # extension, written next to the input.
+      #
+      # @param input_path [String]
+      # @param extension [String] e.g. ".md" or ".docx"
+      # @return [String]
+      def default_output(input_path, extension)
+        directory = File.dirname(input_path)
+        basename = File.basename(input_path, ".*")
+        File.join(directory, "#{basename}#{extension}")
+      end
+
+      # Write converted text to a file, or to stdout for "-".
+      #
+      # @param result [Converter::PlainTextResult]
+      # @param output_path [String] path or "-"
+      def write_text(result, output_path)
+        if output_path == "-"
+          $stdout.puts result.text
+        else
+          File.write(output_path, result.text)
+        end
+      end
+
+      def normalize_format!(format_key)
+        FORMATS.fetch(format_key.to_s.downcase) do
+          raise UnsupportedOperationError.new(
+            "format #{format_key.inspect}",
+            "supported: #{FORMATS.keys.join(', ')}",
+          )
+        end
+      end
+
+      def load_document!(path)
+        raise FileNotFoundError.new(path) unless File.exist?(path)
+
+        DocumentFactory.from_file(path)
+      end
+    end
+  end
+end

data/lib/uniword/cli/review_cli.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "thor"
+require "time"
+require "date"
 
 module Uniword
   # Review subcommands for Uniword CLI.
@@ -23,9 +25,12 @@ module Uniword
       Examples:
         $ uniword review comments document.docx
         $ uniword review comments document.docx --verbose
+        $ uniword review comments document.docx --json
     DESC
     option :verbose, aliases: "-v", desc: "Show detailed information",
                      type: :boolean, default: false
+    option :json, desc: "Output as JSON (machine-readable)",
+                  type: :boolean, default: false
     def comments(path)
       doc = load_document(path)
       manager = Review::ReviewManager.new(doc)
@@ -36,6 +41,21 @@ module Uniword
         return
       end
 
+      if options[:json]
+        require "json"
+        anchors = manager.comment_anchor_texts
+        puts JSON.pretty_generate(comment_list.map do |comment|
+          {
+            id: comment.comment_id,
+            author: comment.author,
+            date: comment.date,
+            text: comment.text,
+            anchored_text: anchors[comment.comment_id.to_s],
+          }
+        end)
+        return
+      end
+
       say "Comments (#{comment_list.count}):", :green
       comment_list.each_with_index do |comment, idx|
         say "  #{idx + 1}. ID: #{comment.comment_id}"
@@ -64,12 +84,19 @@ module Uniword
         $ uniword review changes document.docx
         $ uniword review changes document.docx --author "John Doe"
         $ uniword review changes document.docx --type insert
+        $ uniword review changes document.docx --since 2026-01-01 --json
     DESC
     option :author, desc: "Filter revisions by author", type: :string
     option :type, desc: "Filter by type (insert/delete/format_change)",
                   type: :string
+    option :since, desc: "Only revisions dated on/after (ISO 8601)",
+                   type: :string
+    option :until, desc: "Only revisions dated on/before (ISO 8601)",
+                   type: :string
     option :verbose, aliases: "-v", desc: "Show detailed information",
                      type: :boolean, default: false
+    option :json, desc: "Output as JSON (machine-readable)",
+                  type: :boolean, default: false
     def changes(path)
       doc = load_document(path)
       manager = Review::ReviewManager.new(doc)
@@ -81,6 +108,20 @@ module Uniword
         return
       end
 
+      if options[:json]
+        require "json"
+        puts JSON.pretty_generate(revisions.map do |rev|
+          {
+            id: rev.revision_id,
+            author: rev.author,
+            date: rev.date,
+            type: rev.type.to_s,
+            text: rev.text,
+          }
+        end)
+        return
+      end
+
       say "Tracked changes (#{revisions.count}):", :green
       revisions.each_with_index do |rev, idx|
         say "  #{idx + 1}. ID: #{rev.revision_id}"
@@ -102,58 +143,53 @@ module Uniword
       handle_error(e)
     end
 
-    desc "accept FILE REVISION_ID", "Accept a single revision"
+    desc "accept FILE [REVISION_ID]",
+         "Accept a revision, or all matching filters"
     long_desc <<~DESC
-      Accept a tracked change by its revision ID.
+      Accept a tracked change by its revision ID. Without an ID, every
+      revision matching the --author/--since/--until filters is accepted
+      (default: all).
 
       Examples:
         $ uniword review accept document.docx 3
         $ uniword review accept document.docx 3 --output accepted.docx
+        $ uniword review accept document.docx --author "John Doe" -o out.docx
+        $ uniword review accept document.docx --since 2026-01-01 -o out.docx
     DESC
+    option :author, desc: "With no ID: only revisions by this author",
+                    type: :string
+    option :since, desc: "With no ID: only revisions dated on/after",
+                   type: :string
+    option :until, desc: "With no ID: only revisions dated on/before",
+                   type: :string
     option :output, aliases: "-o", desc: "Output file (overwrites if omitted)",
                     type: :string
-    def accept(path, revision_id)
-      doc = load_document(path)
-      manager = Review::ReviewManager.new(doc)
-
-      unless manager.accept(revision_id)
-        say "Revision '#{revision_id}' not found.", :red
-        exit 1
-      end
-
-      save_output(doc, path)
-      say "Accepted revision '#{revision_id}'.", :green
-    rescue Uniword::Error => e
-      handle_error(e)
-    rescue StandardError => e
-      handle_error(e)
+    def accept(path, revision_id = nil)
+      apply_decisions(path, revision_id, :accept, "Accepted")
     end
 
-    desc "reject FILE REVISION_ID", "Reject a single revision"
+    desc "reject FILE [REVISION_ID]",
+         "Reject a revision, or all matching filters"
     long_desc <<~DESC
-      Reject a tracked change by its revision ID.
+      Reject a tracked change by its revision ID. Without an ID, every
+      revision matching the --author/--since/--until filters is rejected
+      (default: all).
 
       Examples:
         $ uniword review reject document.docx 3
         $ uniword review reject document.docx 3 --output rejected.docx
+        $ uniword review reject document.docx --author "John Doe" -o out.docx
     DESC
+    option :author, desc: "With no ID: only revisions by this author",
+                    type: :string
+    option :since, desc: "With no ID: only revisions dated on/after",
+                   type: :string
+    option :until, desc: "With no ID: only revisions dated on/before",
+                   type: :string
     option :output, aliases: "-o", desc: "Output file (overwrites if omitted)",
                     type: :string
-    def reject(path, revision_id)
-      doc = load_document(path)
-      manager = Review::ReviewManager.new(doc)
-
-      unless manager.reject(revision_id)
-        say "Revision '#{revision_id}' not found.", :red
-        exit 1
-      end
-
-      save_output(doc, path)
-      say "Rejected revision '#{revision_id}'.", :green
-    rescue Uniword::Error => e
-      handle_error(e)
-    rescue StandardError => e
-      handle_error(e)
+    def reject(path, revision_id = nil)
+      apply_decisions(path, revision_id, :reject, "Rejected")
     end
 
     desc "accept-all FILE", "Accept all tracked changes"
@@ -277,6 +313,60 @@ module Uniword
 
     private
 
+    # Apply accept/reject to one revision ID or to all revisions
+    # matching the author/date filters, then save.
+    #
+    # @param path [String] document path
+    # @param revision_id [String, nil] single target ID (filters unused)
+    # @param action [Symbol] :accept or :reject
+    # @param label [String] past-tense verb for the report line
+    # @return [void]
+    def apply_decisions(path, revision_id, action, label)
+      doc = load_document(path)
+      manager = Review::ReviewManager.new(doc)
+
+      if revision_id
+        found = decide(manager, action, revision_id)
+        unless found
+          say "Revision '#{revision_id}' not found.", :red
+          exit 1
+        end
+        count = 1
+      else
+        targets = filtered_revisions(manager)
+        # Capture the count first: deciding a revision splices it out
+        # of the facade's list, which `targets` may alias.
+        count = targets.count
+        targets.each { |rev| decide(manager, action, rev.revision_id) }
+      end
+
+      save_output(doc, path)
+
+      if count.positive?
+        say "#{label} #{count} revision(s).", :green
+      else
+        say "No matching revisions found.", :yellow
+      end
+    rescue Uniword::Error => e
+      handle_error(e)
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    # Dispatch one revision decision to the review manager.
+    #
+    # @param manager [Review::ReviewManager]
+    # @param action [Symbol] :accept or :reject
+    # @param revision_id [String]
+    # @return [Boolean, nil] outcome reported by the manager
+    def decide(manager, action, revision_id)
+      if action == :accept
+        manager.accept(revision_id)
+      else
+        manager.reject(revision_id)
+      end
+    end
+
     # Filter revisions based on CLI options.
     #
     # @param manager [Review::ReviewManager] The review manager
@@ -290,6 +380,9 @@ module Uniword
         end
       end
 
+      revisions = filter_by_date_range(revisions, options[:since],
+                                       options[:until])
+
       if options[:type]
         type = options[:type].to_sym
         revisions = revisions.select { |r| r.type == type }
@@ -298,6 +391,52 @@ module Uniword
       revisions
     end
 
+    # Keep revisions whose date falls within [since, until]. Dates are
+    # ISO 8601; unparseable revision dates are dropped when a date
+    # filter is active. Date-only bounds are interpreted as UTC days
+    # (inclusive on both ends).
+    #
+    # @param revisions [Array<Uniword::Revision>]
+    # @param since [String, nil] inclusive lower bound (ISO 8601)
+    # @param until_date [String, nil] inclusive upper bound (ISO 8601)
+    # @return [Array<Uniword::Revision>]
+    def filter_by_date_range(revisions, since, until_date)
+      lower = parse_filter_time(since)
+      upper = parse_filter_time(until_date, end_of_day: true)
+      return revisions unless lower || upper
+
+      revisions.select do |revision|
+        date = parse_filter_time(revision.date)
+        next false unless date
+
+        (lower.nil? || date >= lower) && (upper.nil? || date <= upper)
+      end
+    end
+
+    # Parse an ISO 8601 timestamp or date (2026-01-31 or
+    # 2026-01-31T12:00:00Z); nil when blank, exit 1 when unparseable.
+    # Date-only values resolve to the start of the UTC day, or to the
+    # last second of that day with end_of_day.
+    #
+    # @param value [String, nil]
+    # @param end_of_day [Boolean] resolve date-only values to 23:59:59Z
+    # @return [Time, nil]
+    def parse_filter_time(value, end_of_day: false)
+      return nil if value.nil? || value.to_s.empty?
+
+      Time.iso8601(value.to_s)
+    rescue ArgumentError
+      date = begin
+        Date.iso8601(value.to_s)
+      rescue ArgumentError
+        say "Invalid date: '#{value}' (expected ISO 8601, " \
+            "e.g. 2026-01-31 or 2026-01-31T12:00:00Z)", :red
+        exit 1
+      end
+      start_of_day = Time.utc(date.year, date.month, date.day)
+      end_of_day ? start_of_day + 86_399 : start_of_day
+    end
+
     # Format revision type for display.
     #
     # @param type [Symbol] The revision type

data/lib/uniword/cli/revisions_cli.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Uniword
+  # Revisions subcommands for the Uniword CLI.
+  #
+  # The issue-#79 spelling of the tracked-changes verbs: `revisions
+  # list` / `revisions accept` / `revisions reject` delegate to the
+  # `review changes|accept|reject` implementations, so both groups
+  # share one behavior surface (filters, JSON, exit codes).
+  class RevisionsCLI < Thor
+    include CLIHelpers
+
+    desc "list FILE", "List tracked changes (alias of review changes)"
+    long_desc <<~DESC
+      List tracked changes with id, type, author, date, and text -
+      identical to `uniword review changes`, under the revisions name.
+
+      Examples:
+        $ uniword revisions list document.docx
+        $ uniword revisions list document.docx --author "John Doe" --json
+        $ uniword revisions list document.docx --since 2026-01-01
+    DESC
+    option :author, desc: "Filter revisions by author", type: :string
+    option :type, desc: "Filter by type (insert/delete/format_change)",
+                  type: :string
+    option :since, desc: "Only revisions dated on/after (ISO 8601)",
+                   type: :string
+    option :until, desc: "Only revisions dated on/before (ISO 8601)",
+                   type: :string
+    option :verbose, aliases: "-v", desc: "Show detailed information",
+                     type: :boolean, default: false
+    option :json, desc: "Output as JSON (machine-readable)",
+                  type: :boolean, default: false
+    def list(path)
+      ReviewCLI.new.invoke(:changes, [path], options.to_h)
+    end
+
+    desc "accept FILE [REVISION_ID]",
+         "Accept revisions (alias of review accept)"
+    long_desc <<~DESC
+      Accept one revision by id, or every filter-matching revision when
+      no id is given. Identical to `uniword review accept`.
+
+      Examples:
+        $ uniword revisions accept document.docx
+        $ uniword revisions accept document.docx 4
+        $ uniword revisions accept document.docx --author "John Doe" -o out.docx
+    DESC
+    option :author, desc: "With no ID: only revisions by this author",
+                    type: :string
+    option :since, desc: "With no ID: only revisions dated on/after",
+                   type: :string
+    option :until, desc: "With no ID: only revisions dated on/before",
+                   type: :string
+    option :output, aliases: "-o", desc: "Output file (overwrites if omitted)",
+                    type: :string
+    def accept(path, revision_id = nil)
+      ReviewCLI.new.invoke(:accept, [path, revision_id].compact,
+                           options.to_h)
+    end
+
+    desc "reject FILE [REVISION_ID]",
+         "Reject revisions (alias of review reject)"
+    long_desc <<~DESC
+      Reject one revision by id, or every filter-matching revision when
+      no id is given. Identical to `uniword review reject`.
+
+      Examples:
+        $ uniword revisions reject document.docx
+        $ uniword revisions reject document.docx 4
+        $ uniword revisions reject document.docx --author "John Doe" -o out.docx
+    DESC
+    option :author, desc: "With no ID: only revisions by this author",
+                    type: :string
+    option :since, desc: "With no ID: only revisions dated on/after",
+                   type: :string
+    option :until, desc: "With no ID: only revisions dated on/before",
+                   type: :string
+    option :output, aliases: "-o", desc: "Output file (overwrites if omitted)",
+                    type: :string
+    def reject(path, revision_id = nil)
+      ReviewCLI.new.invoke(:reject, [path, revision_id].compact,
+                           options.to_h)
+    end
+  end
+end

data/lib/uniword/cli/template_cli.rb

@@ -151,8 +151,83 @@ module Uniword
       handle_error(e, verbose: options[:verbose])
     end
 
+    desc "fill DOCUMENT", "Fill placeholders in a document with data"
+    long_desc <<~DESC
+      Fill placeholders in a DOCX document (mail merge) and save the
+      result as a new DOCX file.
+
+      Placeholder sources, in precedence order:
+        1. Content controls (w:sdt) whose alias or tag names a variable
+        2. MERGEFIELD simple fields (w:fldSimple)
+        3. {{var}} text placeholders inside run text
+
+      Data is loaded from a YAML or JSON file (--data, required). Nested
+      data keys are addressed with dotted paths ({{client.name}}).
+      Placeholders without data are left untouched unless --strict,
+      which fails with the list of missing variable names.
+
+      Examples:
+        $ uniword template fill letter.docx --data data.yml
+        $ uniword template fill letter.docx --data data.json -o out.docx
+        $ uniword template fill letter.docx --data data.yml --strict
+        $ uniword template fill letter.docx --data data.yml --json
+    DESC
+    option :data, desc: "Path to YAML or JSON data file", type: :string,
+                  required: true
+    option :output, aliases: "-o",
+                    desc: "Output DOCX path (default: <name>.filled.docx)",
+                    type: :string
+    option :strict, desc: "Fail when a placeholder variable has no data",
+                    type: :boolean, default: false
+    option :json, desc: "Report as JSON", type: :boolean, default: false
+    option :verbose, aliases: "-v", desc: "Verbose output",
+                     type: :boolean, default: false
+    def fill(input_path)
+      validate_input_file(input_path)
+
+      document = DocumentFactory.from_file(input_path)
+      data = parse_data_file(options[:data])
+      log_fill_start(data) if options[:verbose]
+      report_fill(document, data, input_path)
+    rescue Uniword::Error => e
+      handle_error(e)
+    rescue StandardError => e
+      handle_error(e, verbose: options[:verbose])
+    end
+
     private
 
+    def validate_input_file(path)
+      return if File.exist?(path)
+
+      say "File not found: #{path}", :red
+      exit 1
+    end
+
+    def log_fill_start(data)
+      return unless data.any?
+
+      say "  Data keys: #{data.keys.join(', ')}", :cyan
+    end
+
+    def report_fill(document, data, input_path)
+      result = fill_document(document, data)
+      output_path = options[:output] || derive_filled_path(input_path)
+      document.save(output_path)
+
+      if options[:json]
+        puts result.to_json
+      else
+        say result.summary, result.complete? ? :green : :yellow
+        say "Filled document -> #{output_path}", :green
+      end
+    end
+
+    def fill_document(document, data)
+      Uniword::Template::Filler.new(document)
+        .fill(data, strict: options[:strict])
+    end
+
     def load_template_data
       data = {}
 
@@ -189,5 +264,11 @@ module Uniword
 
       data
     end
+
+    # Default output path: "<name>.filled.docx" next to the input.
+    def derive_filled_path(path)
+      ext = File.extname(path)
+      "#{path.delete_suffix(ext)}.filled#{ext}"
+    end
   end
 end