uniword 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1153bb3528efaa764919405fb7e3ac11e0e9aedcaae81e6dd0b692293e3876a2
-  data.tar.gz: 0e59bf185f59fc2377dc56c1dd1bfacbc773814d47dcef9f19bb6f855cf0298c
+  metadata.gz: 34ddbf784b5b85ba8aedc6b4df9b255763e2b8014bcdea0124563e261555b32b
+  data.tar.gz: e4ef3fce0529a6db2642cbf547c28628512834339ce636f15d90c30dccba7eb2
 SHA512:
-  metadata.gz: 540da6a280c292c6563daf77a1c024fefbc1266048d7fab197cff2e7bb7d0529d2953e1cc596d8b426668702adc03a3b1821645a8bd028fc6d71cfe937862a0c
-  data.tar.gz: 9543bd3d00ce96e4d47480f5db92a05ab60a7fc1a6e85cf60037ace089106f703f30d6be825dcaa939319c5fe559d5e35b9669f8103a6c9cabd8c5c4415552f1
+  metadata.gz: ae06c93c3b13ffffc70b0bddc7137945e4a035f2a4f75e315406547166c4423cdfe8ff8835b47ae5df50be9c6a021f500b89bd17512ae646cb3dd4c890bf8d8b
+  data.tar.gz: 7a37bcf5e4cc1ece3a92ad962757a48613be7f960890bd52017dcf8343bb1989172c7b9bd931a384dfe4bcee58c24de27b80b76e9dd4d3eca09280b078f8e3f1

data/exe/uniword

@@ -10,5 +10,14 @@ if defined?(RubyVM::YJIT) && !RubyVM::YJIT.enabled? &&
   RubyVM::YJIT.enable
 end
 
+# POSIX NO_COLOR convention: suppress colored CLI output.
+if ENV["NO_COLOR"] && !ENV["NO_COLOR"].empty?
+  require "uniword/cli/no_color"
+end
+
+# Never let a task's return value become the process exit status:
+# success is 0, and failures raise SystemExit inside `start`
+# (exit_on_failure? / handle_error).
 require "uniword"
 Uniword::CLI.start(ARGV)
+exit 0

data/lib/uniword/accessibility/accessibility_report.rb

@@ -46,6 +46,14 @@ module Uniword
         errors.empty?
       end
 
+      # Report-contract predicate shared with Quality::QualityReport:
+      # true when the document has no error-level violations.
+      #
+      # @return [Boolean]
+      def valid?
+        compliant?
+      end
+
       # Get all error-level violations
       #
       # @return [Array<AccessibilityViolation>] Error violations

data/lib/uniword/builder/chart_builder.rb

@@ -28,13 +28,16 @@ module Uniword
     #   end
     class ChartBuilder
       CHART_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart"
+      DRAWINGML_MAIN_NS =
+        "http://schemas.openxmlformats.org/drawingml/2006/main"
+      OFFICE_DOCUMENT_RELS_NS =
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
       CHART_REL_TYPE = Ooxml::PartRegistry.find_by_key(:chart).rel_type
       CHART_CONTENT_TYPE =
         Ooxml::PartRegistry.find_by_key(:chart).content_type
 
-      attr_reader :chart_type, :title_text, :series_list
-
-      attr_reader :show_legend, :width, :height, :series_list
+      attr_reader :chart_type, :title_text, :series_list, :show_legend, :width,
+                  :height
 
       def initialize(chart_type: :bar)
         @chart_type = chart_type
@@ -101,16 +104,15 @@ module Uniword
       #
       # @return [String] Chart XML
       def build_xml
-        builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-          xml["c"].chartSpace("xmlns:c" => CHART_NS,
-                              "xmlns:a" =>
-                                "http://schemas.openxmlformats.org/drawingml/2006/main",
-                              "xmlns:r" =>
-                                "http://schemas.openxmlformats.org/officeDocument/2006/relationships") do
-            build_chart_xml(xml)
-          end
-        end
-        builder.to_xml
+        @document = Moxml.new.create_document
+        @document.add_child(@document.create_declaration("1.0", "UTF-8"))
+        root = @document.create_element("c:chartSpace")
+        root.add_namespace("c", CHART_NS)
+        root.add_namespace("a", DRAWINGML_MAIN_NS)
+        root.add_namespace("r", OFFICE_DOCUMENT_RELS_NS)
+        @document.root = root
+        build_chart(root)
+        @document.to_xml
       end
 
       # Register chart on a document and create the Drawing element
@@ -147,166 +149,159 @@ module Uniword
       include DeterministicId
 
       # Build the inner chart XML
-      def build_chart_xml(xml)
-        xml["c"].chart do
-          if @title_text
-            xml["c"].title do
-              xml["c"].tx do
-                xml["c"].rich do
-                  xml["a"].bodyPr
-                  xml["a"].lstStyle
-                  xml["a"].p do
-                    xml["a"].r do
-                      xml["a"].t(@title_text)
-                    end
-                  end
-                end
-              end
-              xml["c"].overlay("val" => "0")
-            end
-          end
-
-          xml["c"].autoTitleDeleted("val" => "0")
-
-          xml["c"].plotArea do
-            build_chart_type(xml)
-
-            unless @chart_type == :pie
-              build_axis(xml, "catAx", "10", "b", "20")
-              build_axis(xml, "valAx", "20", "l", "10")
-            end
-          end
-
-          if @show_legend
-            xml["c"].legend do
-              xml["c"].legendPos("val" => @legend_position)
-              xml["c"].overlay("val" => "0")
-            end
-          end
-
-          xml["c"].plotVisOnly("val" => "1")
+      def build_chart(parent)
+        chart = add_element(parent, "c:chart")
+        if @title_text
+          title = add_element(chart, "c:title")
+          tx = add_element(title, "c:tx")
+          rich = add_element(tx, "c:rich")
+          add_element(rich, "a:bodyPr")
+          add_element(rich, "a:lstStyle")
+          p_el = add_element(rich, "a:p")
+          r_el = add_element(p_el, "a:r")
+          add_text(add_element(r_el, "a:t"), @title_text)
+          add_element(title, "c:overlay", "val" => "0")
+        end
+
+        add_element(chart, "c:autoTitleDeleted", "val" => "0")
+
+        plot_area = add_element(chart, "c:plotArea")
+        build_chart_type(plot_area)
+
+        unless @chart_type == :pie
+          build_axis(plot_area, "catAx", "10", "b", "20")
+          build_axis(plot_area, "valAx", "20", "l", "10")
+        end
+
+        if @show_legend
+          legend = add_element(chart, "c:legend")
+          add_element(legend, "c:legendPos", "val" => @legend_position)
+          add_element(legend, "c:overlay", "val" => "0")
         end
+
+        add_element(chart, "c:plotVisOnly", "val" => "1")
+        chart
       end
 
       # Build the specific chart type element
-      def build_chart_type(xml)
+      def build_chart_type(parent)
         case @chart_type
         when :bar
-          xml["c"].barChart do
-            xml["c"].barDir("val" => "col")
-            xml["c"].grouping("val" => "clustered")
-            xml["c"].varyColors("val" => "0")
-            build_all_series(xml)
-            xml["c"].axId("val" => "10")
-            xml["c"].axId("val" => "20")
-          end
+          chart = add_element(parent, "c:barChart")
+          add_element(chart, "c:barDir", "val" => "col")
+          add_element(chart, "c:grouping", "val" => "clustered")
+          add_element(chart, "c:varyColors", "val" => "0")
+          build_all_series(chart)
+          add_element(chart, "c:axId", "val" => "10")
+          add_element(chart, "c:axId", "val" => "20")
         when :line
-          xml["c"].lineChart do
-            xml["c"].grouping("val" => "standard")
-            xml["c"].varyColors("val" => "0")
-            build_all_series(xml)
-            xml["c"].axId("val" => "10")
-            xml["c"].axId("val" => "20")
-          end
+          chart = add_element(parent, "c:lineChart")
+          add_element(chart, "c:grouping", "val" => "standard")
+          add_element(chart, "c:varyColors", "val" => "0")
+          build_all_series(chart)
+          add_element(chart, "c:axId", "val" => "10")
+          add_element(chart, "c:axId", "val" => "20")
         when :pie
-          xml["c"].pieChart do
-            xml["c"].varyColors("val" => "1")
-            build_all_series(xml)
-          end
+          chart = add_element(parent, "c:pieChart")
+          add_element(chart, "c:varyColors", "val" => "1")
+          build_all_series(chart)
         end
       end
 
       # Build all series XML blocks
-      def build_all_series(xml)
+      def build_all_series(parent)
         @series_list.each_with_index do |s, i|
-          build_series(xml, s, i)
+          build_series(parent, s, i)
         end
       end
 
       # Build a single series XML block
-      def build_series(xml, series, index)
-        xml["c"].ser do
-          xml["c"].idx("val" => index)
-          xml["c"].order("val" => index)
-          xml["c"].tx do
-            xml["c"].strRef do
-              xml["c"].f("Sheet1!$B$#{index + 1}")
-              xml["c"].strCache do
-                xml["c"].ptCount("val" => 1)
-                xml["c"].pt("idx" => 0) { xml["c"].v(series[:name]) }
-              end
-            end
-          end
-          build_categories(xml)
-          build_values(xml, series[:data])
-        end
+      def build_series(parent, series, index)
+        ser = add_element(parent, "c:ser")
+        add_element(ser, "c:idx", "val" => index)
+        add_element(ser, "c:order", "val" => index)
+        tx = add_element(ser, "c:tx")
+        str_ref = add_element(tx, "c:strRef")
+        add_text(add_element(str_ref, "c:f"), "Sheet1!$B$#{index + 1}")
+        str_cache = add_element(str_ref, "c:strCache")
+        add_element(str_cache, "c:ptCount", "val" => 1)
+        pt = add_element(str_cache, "c:pt", "idx" => 0)
+        add_text(add_element(pt, "c:v"), series[:name])
+        build_categories(ser)
+        build_values(ser, series[:data])
+        ser
       end
 
       # Build category data XML
-      def build_categories(xml)
+      def build_categories(parent)
         return if @categories.empty?
 
-        xml["c"].cat do
-          xml["c"].strRef do
-            xml["c"].f("Sheet1!$A$2:$A$100")
-            xml["c"].strCache do
-              xml["c"].ptCount("val" => @categories.size)
-              @categories.each_with_index do |cat, idx|
-                xml["c"].pt("idx" => idx) { xml["c"].v(cat) }
-              end
-            end
-          end
+        cat = add_element(parent, "c:cat")
+        str_ref = add_element(cat, "c:strRef")
+        add_text(add_element(str_ref, "c:f"), "Sheet1!$A$2:$A$100")
+        str_cache = add_element(str_ref, "c:strCache")
+        add_element(str_cache, "c:ptCount", "val" => @categories.size)
+        @categories.each_with_index do |category, idx|
+          pt = add_element(str_cache, "c:pt", "idx" => idx)
+          add_text(add_element(pt, "c:v"), category)
         end
       end
 
       # Build values data XML
-      def build_values(xml, data)
-        xml["c"].val do
-          xml["c"].numRef do
-            xml["c"].f("Sheet1!$C$2:$C$100")
-            xml["c"].numCache do
-              xml["c"].formatCode("General")
-              xml["c"].ptCount("val" => data.size)
-              data.each_with_index do |val, idx|
-                xml["c"].pt("idx" => idx) { xml["c"].v(val.to_s) }
-              end
-            end
-          end
+      def build_values(parent, data)
+        val = add_element(parent, "c:val")
+        num_ref = add_element(val, "c:numRef")
+        add_text(add_element(num_ref, "c:f"), "Sheet1!$C$2:$C$100")
+        num_cache = add_element(num_ref, "c:numCache")
+        add_text(add_element(num_cache, "c:formatCode"), "General")
+        add_element(num_cache, "c:ptCount", "val" => data.size)
+        data.each_with_index do |value, idx|
+          pt = add_element(num_cache, "c:pt", "idx" => idx)
+          add_text(add_element(pt, "c:v"), value.to_s)
         end
       end
 
       # Build a chart axis
-      def build_axis(xml, tag, id, position, cross_id)
+      def build_axis(parent, tag, id, position, cross_id)
         case tag
         when "catAx"
-          xml["c"].catAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:catAx"), id, position,
+                             cross_id)
         when "valAx"
-          xml["c"].valAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:valAx"), id, position,
+                             cross_id)
         when "serAx"
-          xml["c"].serAx do
-            write_axis_content(xml, id, position, cross_id)
-          end
+          write_axis_content(add_element(parent, "c:serAx"), id, position,
+                             cross_id)
         else
           raise ArgumentError, "Unknown axis type: #{tag}"
         end
       end
 
-      def write_axis_content(xml, id, position, cross_id)
-        xml["c"].axId("val" => id)
-        xml["c"].scaling do
-          xml["c"].orientation("val" => "minMax")
-        end
-        xml["c"].delete("val" => "0")
-        xml["c"].axPos("val" => position)
-        xml["c"].majorGridlines
-        xml["c"].numFmt("formatCode" => "General",
-                        "sourceLinked" => "1")
-        xml["c"].tickLblPos("val" => "nextTo")
-        xml["c"].crossAx("val" => cross_id)
+      def write_axis_content(axis, id, position, cross_id)
+        add_element(axis, "c:axId", "val" => id)
+        scaling = add_element(axis, "c:scaling")
+        add_element(scaling, "c:orientation", "val" => "minMax")
+        add_element(axis, "c:delete", "val" => "0")
+        add_element(axis, "c:axPos", "val" => position)
+        add_element(axis, "c:majorGridlines")
+        add_element(axis, "c:numFmt", "formatCode" => "General",
+                                      "sourceLinked" => "1")
+        add_element(axis, "c:tickLblPos", "val" => "nextTo")
+        add_element(axis, "c:crossAx", "val" => cross_id)
+      end
+
+      # Append an element with attributes to a parent node.
+      def add_element(parent, name, attributes = {})
+        element = @document.create_element(name)
+        attributes.each { |key, value| element[key] = value }
+        parent.add_child(element)
+        element
+      end
+
+      # Append a text node to a parent node.
+      def add_text(parent, content)
+        parent.add_child(@document.create_text(content))
       end
 
       # Create a Drawing element with chart reference

data/lib/uniword/cli/completions.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Cli
+    # Builds shell completion scripts from live CLI metadata so new
+    # commands appear in completions without editing the scripts.
+    module Completions
+      BUILTINS = %w[help completions].freeze
+
+      module_function
+
+      # @param shell [String] "bash", "zsh", or "fish"
+      # @param root [Class] the root Thor class (Uniword::CLI)
+      # @return [String] completion script
+      def script(shell, root:)
+        commands = root.all_commands.keys - BUILTINS
+        subcommands = subcommand_map(root)
+
+        case shell
+        when "bash" then bash(commands, subcommands)
+        when "zsh"  then zsh(commands, subcommands)
+        when "fish" then fish(commands, subcommands)
+        else
+          raise ArgumentError,
+                "unsupported shell: #{shell.inspect} (bash|zsh|fish)"
+        end
+      end
+
+      # Map command name → registered subcommand Thor class, derived
+      # from class names (ThemeCLI → "theme"), so `subcommand` call
+      # sites stay the single source of truth.
+      # Space-separated subcommand word list for one class.
+      def words_for(klass)
+        klass.all_commands.keys.reject { |c| c == "help" }.join(" ")
+      end
+
+      def subcommand_map(root)
+        root.subcommand_classes.filter_map do |name, klass|
+          [name, klass]
+        end.to_h
+      end
+
+      def bash(commands, subcommands)
+        cmds = commands.join(" ")
+        script = <<~BASH
+          # uniword bash completion — generated by `uniword completions bash`
+          _uniword() {
+            local cur="${COMP_WORDS[COMP_CWORD]}"
+            local prev="${COMP_WORDS[COMP_CWORD-1]}"
+            local cmds="#{cmds}"
+        BASH
+        subcommands.each do |name, klass|
+          words = words_for(klass)
+          script << "  if [ \"$prev\" = \"#{name}\" ]; then\n    " \
+                    "COMPREPLY=( $(compgen -W \"#{words}\" " \
+                    "-- \"$cur\") )\n    return\n  fi\n"
+        end
+        script << "  COMPREPLY=( $(compgen -W \"$cmds\" -- \"$cur\") )\n" \
+                  "}\n" \
+                  "complete -F _uniword uniword\n"
+        script
+      end
+
+      def zsh(commands, subcommands)
+        script = <<~ZSH
+          #compdef uniword
+          # uniword zsh completion — generated by `uniword completions zsh`
+          _uniword() {
+            local -a cmds
+            cmds=(#{commands.map { |c| "'#{c}'" }.join(' ')})
+            _describe 'command' cmds
+        ZSH
+        subcommands.each do |name, klass|
+          words = words_for(klass).split.map { |c| "'#{c}'" }.join(" ")
+          script << "  if (( CURRENT == 2 )) && [[ #{name} == * ]]; " \
+                    "then\n    local -a sub\n    sub=(#{words})\n    " \
+                    "_describe '#{name} command' sub\n  fi\n"
+        end
+        script << "}\n"
+        script
+      end
+
+      def fish(commands, subcommands)
+        script = +<<~FISH
+          # uniword fish completion — generated by `uniword completions fish`
+        FISH
+        commands.each do |c|
+          script << "complete -c uniword -n '__fish_use_subcommand' -a '#{c}'\n"
+        end
+        subcommands.each do |name, klass|
+          words = words_for(klass)
+          script << "complete -c uniword -n '__fish_seen_subcommand_from " \
+                    "#{name}' -a '#{words}'\n"
+        end
+        script
+      end
+    end
+  end
+end

data/lib/uniword/cli/generate_cli.rb

@@ -10,6 +10,11 @@ module Uniword
   class GenerateCLI < Thor
     include CLIHelpers
 
+    # `uniword generate INPUT OUTPUT ...` dispatches straight to the
+    # generate task; the explicit `generate generate ...` form stays
+    # valid for backwards compatibility.
+    default_task :generate
+
     desc "generate INPUT OUTPUT",
          "Generate DOCX from structured text"
     long_desc <<~DESC

data/lib/uniword/cli/help_switch.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Cli
+    # Rewrites help/version flag invocations before Thor dispatch so
+    # help works on tasks with required arguments:
+    #
+    #   uniword convert --help        → uniword help convert
+    #   uniword images add --help     → uniword help images add
+    #   uniword --help / -h           → root help
+    #   uniword --version / -V        → uniword version
+    #
+    # The rewrite only fires when the help/version flag is the first
+    # flag-like token and everything before it looks like a task path
+    # (no options), so real option values (e.g. `--from docx`) are
+    # never mistaken for the chain.
+    module HelpSwitch
+      HELP_FLAGS = %w[--help -h].freeze
+      VERSION_FLAGS = %w[--version -V].freeze
+
+      def start(given_args = ARGV, config = {})
+        args = given_args.map(&:to_s)
+
+        if (help_idx = args.index { |a| HELP_FLAGS.include?(a) })
+          chain = args[0...help_idx]
+          if option_free_task_path?(chain)
+            return super(chain.unshift("help"), config)
+          end
+        end
+
+        if args.size == 1 && VERSION_FLAGS.include?(args[0])
+          return super(["version"], config)
+        end
+
+        super
+      end
+
+      private
+
+      def option_free_task_path?(chain)
+        chain.all? { |a| !a.start_with?("-") }
+      end
+    end
+  end
+end

data/lib/uniword/cli/helpers.rb

@@ -10,6 +10,7 @@ module Uniword
   module CLIHelpers
     def self.included(base)
       base.extend(ClassMethods)
+      base.extend(Cli::HelpSwitch)
     end
 
     module ClassMethods