coradoc 1.1.8 → 2.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa6087920cf2a472b02e4e44bdf3b984f42e99e39d0290c7621d431629e747f2
-  data.tar.gz: 1f51521272e4ab8cb514ae1d0dafc7a68f83ecd95637cb7ed0a8c9fdfab7eba4
+  metadata.gz: 75ed45610af35c31ab134148781a5e5411ecc2949c443ca5b52d658b157452be
+  data.tar.gz: 16442662e51b42a22877f7ec0e7e5557829b529f6f4407a77700be7a2958abde
 SHA512:
-  metadata.gz: 58a6a02fe1f0f6515da56c238a7068d18148cb91e3e172a2c8bdf7cc3af03363ba6ee4931a67f3d07ec9eaf5135a1d9092109a2c801aa37e516924a9b011be8d
-  data.tar.gz: 18ca28c32f330ba3a0457f07e3fd92732f7d91895b555791d5648fa7903f50345cbed89b09fdcb5e6c34537dbddb1ed5ca9c0ea2531044738892ffa9b7fa341c
+  metadata.gz: fff4b4fe812e09f3e527a9c424bcaa712e9857cc56900974000a40bbfb50ae859df19e8cebf155d164ac830061f8b594e7d0f8798c91c89f1457146fbde4d2fb
+  data.tar.gz: 6141595e393440bf93ecd0248538e4608ab8e6404878c7cbe71ce3d526010241716aa98e4e1c9f830b32615d2a0456d5596da13d4ee13086d7b35eaef3e57ca2

data/.rspec

@@ -1,3 +1,3 @@
+--require spec_helper
 --format documentation
 --color
---require spec_helper

data/Rakefile

@@ -1,17 +1,8 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-
-if File.exist?(".codeclimate")
-  ENV["CODECLIMATE_REPO_TOKEN"] = File.read(".codeclimate").strip
-end
-
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-task default: :spec
 
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -Ilib -rcoradoc -rcoradoc/reverse_adoc"
-end
+task default: :spec

data/exe/coradoc

@@ -1,5 +1,24 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "coradoc/cli"
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
 
-Coradoc::CLI.start
+require 'coradoc'
+require 'coradoc/cli'
+
+GEM_TO_REQUIRE_PATH = {
+  'coradoc-adoc' => 'coradoc/asciidoc',
+  'coradoc-html' => 'coradoc/html',
+  'coradoc-markdown' => 'coradoc/markdown',
+  'coradoc-docx' => 'coradoc/docx'
+}.freeze
+
+GEM_TO_REQUIRE_PATH.each do |gem_name, require_path|
+  gem gem_name
+  require require_path
+rescue LoadError
+  nil
+end
+
+Coradoc::CLI.start(ARGV)

data/lib/coradoc/cli.rb

@@ -1,104 +1,218 @@
-require "coradoc"
-require "thor"
+# frozen_string_literal: true
+
+require 'thor'
 
 module Coradoc
   class CLI < Thor
-    package_name "coradoc"
-
-    desc "convert [FILE]", "Convert document to another format"
-
-    option :output,
-           type: :string, aliases: "-o",
-           desc: "Output file to write"
-
-    option :input_format,
-           type: :string, aliases: "-I",
-           enum: Input.keys.map(&:to_s), default: nil,
-           desc: "Define input format (defaults to input file extension)"
-
-    option :output_format,
-           type: :string, aliases: "-O",
-           enum: Output.keys.map(&:to_s), default: nil,
-           desc: "Define output format (defaults to output file extension)"
-
-    at_least_one :output, :output_format
-
-    option :require,
-           type: :string, aliases: "-r",
-           repeatable: true,
-           desc: "Require additional Ruby file (eg. to load a plugin)"
-
-    option :external_images,
-           type: :boolean, aliases: "-e",
-           desc: "Extract images from input document"
-
-    option :unknown_tags,
-           type: :string, aliases: "-u",
-           enum: %w[pass_through drop bypass raise],
-           default: "pass_through",
-           desc: "Unknown tag handling"
-
-    option :mathml2asciimath,
-           type: :boolean, aliases: "-m",
-           desc: "Convert MathML to AsciiMath"
-
-    option :track_time,
-           type: :boolean,
-           desc: "Track time spent on each step"
-
-    option :split_sections,
-           type: :numeric,
-           default: 0, banner: "LEVEL",
-           desc: "Split sections into separate files up to a provided level"
-
-    def convert(input = nil)
-      options[:require]&.each { |r| Kernel.require r }
-
-      config = {
-        input_options: input_options = {},
-        input_processor: nil,
-        output_options: {},
-        output_processor: nil,
-      }
-
-      config[:input_processor] = options[:input_format]&.to_sym
-      config[:output_processor] = options[:output_format]&.to_sym
-
-      %i[
-        external_images
-        unknown_tags
-        mathml2asciimath
-        track_time
-        split_sections
-      ].each do |i|
-        input_options[i] = options[i]
+    package_name 'Coradoc'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'convert FILE', 'Convert a document from one format to another'
+    option :to, aliases: '-t', desc: 'Target format (adoc, html, md)', type: :string
+    option :output, aliases: '-o', desc: 'Output file path (default: stdout)', type: :string
+    option :from, aliases: '-f', desc: 'Source format (auto-detected from extension)', type: :string
+    option :theme, desc: 'HTML theme (classic, modern)', type: :string, default: 'classic'
+    option :verbose, desc: 'Enable verbose output', type: :boolean, default: false
+    option :asset_delivery, desc: 'Asset delivery mode (embedded, external)', type: :string, default: 'embedded'
+    option :toc, desc: 'Include table of contents', type: :boolean, default: false
+    option :toc_levels, desc: 'TOC depth (1-5)', type: :numeric, default: 2
+    option :section_numbers, desc: 'Enable section numbering', type: :boolean, default: false
+    option :section_number_levels, desc: 'Section numbering depth (1-6)', type: :numeric, default: 3
+    option :lang, desc: 'Document language code', type: :string, default: 'en'
+    def convert(file)
+      source_format = resolve_format(file, :from)
+      target_format = options[:to] ? Coradoc.normalize_format(options[:to]) : Coradoc.resolve_output_format(options[:output])
+
+      unless source_format && target_format
+        error 'Error: Could not determine format. Use --from and --to options.'
+        exit 1
       end
 
-      output = options[:output]
-
-      begin
-        Coradoc::Converter.(input, output, **config)
-      rescue Converter::NoInputPathError => e
-        warn "You must provide INPUT file as a file for this optionset."
-        warn "Detail: #{e.message}"
-      rescue Converter::NoOutputPathError => e
-        warn "You must provide OUTPUT file as a file for this optionset."
-        warn "Detail: #{e.message}"
-      rescue Converter::NoProcessorError => e
-        warn "No processor found for given input/output."
-        warn "Hint: set -I/--input-format or -O/--output-format option."
-        warn "Detail: #{e.message}"
+      unless Coradoc.serialize_format?(target_format)
+        error "Error: Converting to #{target_format} is not yet supported."
+        exit 1
       end
+
+      verbose_log "Converting #{file} (#{source_format}) to #{target_format}"
+
+      opts = build_convert_options
+      result = Coradoc.convert_file(file, from: source_format, to: target_format, **opts)
+      write_output(result, options[:output])
+    rescue Coradoc::Error => e
+      error "Error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Error: #{e.message}"
+      verbose_log e.backtrace.join("\n") if options[:verbose]
+      exit 1
+    end
+
+    desc 'formats', 'List supported formats'
+    def formats
+      caps = Coradoc.format_capabilities
+
+      puts 'Supported formats:'
+      puts ''
+      puts '  Source formats (can read):'
+      caps.each { |name, c| puts "    - #{name}" if c[:parse] }
+      puts ''
+      puts '  Target formats (can write):'
+      caps.each { |name, c| puts "    - #{name}" if c[:serialize] }
     end
 
-    desc "version", "display version information"
+    desc 'version', 'Display Coradoc version'
     def version
-      puts "Coradoc: v#{Coradoc::VERSION}"
-      puts "[dependency] WordToMarkdown: v#{WordToMarkdown::VERSION}"
-      if Gem.win_platform?
-        puts "[dependency] LibreOffice: version not available on Windows"
+      puts "Coradoc #{Coradoc::VERSION}"
+    end
+
+    desc 'validate FILE', 'Validate a document against its schema'
+    option :format, aliases: '-f', desc: 'Source format (auto-detected from extension)', type: :string
+    option :strict, desc: 'Enable strict validation mode', type: :boolean, default: false
+    def validate(file)
+      source_format = resolve_format(file)
+      unless source_format
+        error 'Error: Could not determine format. Use --format option.'
+        exit 1
+      end
+
+      verbose_log "Validating #{file} (#{source_format})"
+
+      result = Coradoc.validate_file(file, format: source_format)
+
+      if result.valid?
+        puts '✓ Document is valid'
+      else
+        error "✗ #{result}"
+        exit 1
+      end
+    rescue Coradoc::Error => e
+      error "Error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Error: #{e.message}"
+      verbose_log e.backtrace.join("\n") if options[:verbose]
+      exit 1
+    end
+
+    desc 'query FILE SELECTOR', 'Query document elements using CSS-like selectors'
+    option :format, aliases: '-f', desc: 'Source format (auto-detected from extension)', type: :string
+    option :output, aliases: '-o', desc: 'Output format (text, json)', type: :string, default: 'text'
+    def query(file, selector)
+      source_format = resolve_format(file)
+      unless source_format
+        error 'Error: Could not determine format. Use --format option.'
+        exit 1
+      end
+
+      verbose_log "Querying #{file} with selector: #{selector}"
+
+      doc = Coradoc.parse_file(file, format: source_format)
+      results = Coradoc::Query.query(doc, selector)
+
+      if results.empty?
+        puts "No elements found matching: #{selector}"
       else
-        puts "[dependency] LibreOffice: v#{WordToMarkdown.soffice.version}"
+        case options[:output]
+        when 'json'
+          require 'json'
+          puts JSON.pretty_generate(results.map { |r| Coradoc.describe_element(r) })
+        else
+          puts "Found #{results.length} element(s):"
+          results.each_with_index do |elem, i|
+            puts "  #{i + 1}. #{Coradoc.describe_element(elem)}"
+          end
+        end
+      end
+    rescue Coradoc::Error => e
+      error "Error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Error: #{e.message}"
+      verbose_log e.backtrace.join("\n") if options[:verbose]
+      exit 1
+    end
+
+    desc 'info FILE', 'Display document metadata and statistics'
+    option :format, aliases: '-f', desc: 'Source format (auto-detected from extension)', type: :string
+    def info(file)
+      source_format = resolve_format(file)
+      unless source_format
+        error 'Error: Could not determine format. Use --format option.'
+        exit 1
+      end
+
+      verbose_log "Analyzing #{file} (#{source_format})"
+
+      doc = Coradoc.parse_file(file, format: source_format)
+      stats = Coradoc.document_stats(doc)
+      fi = Coradoc.file_info(file)
+
+      puts 'Document Information'
+      puts '=' * 40
+      puts "Format: #{source_format}"
+      puts "File size: #{fi[:size]} bytes"
+      puts "Line count: #{fi[:lines]}" if fi[:lines]
+      puts "Title: #{stats[:title]}" if stats[:title]
+      puts "Child elements: #{stats[:child_count]}" if stats[:child_count]
+
+      if stats[:element_counts]&.any?
+        puts ''
+        puts 'Element Counts:'
+        stats[:element_counts].each { |type, count| puts "  #{type}: #{count}" }
+      end
+    rescue Coradoc::Error => e
+      error "Error: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      error "Error: #{e.message}"
+      verbose_log e.backtrace.join("\n") if options[:verbose]
+      exit 1
+    end
+
+    map '-v' => :version, '--version' => :version
+
+    private
+
+    def resolve_format(file, option_key = :format)
+      raw = options[option_key]
+      raw ? Coradoc.normalize_format(raw) : Coradoc.detect_format(file)
+    end
+
+    def write_output(content, output_file)
+      if output_file
+        File.write(output_file, content)
+        verbose_log "Written to: #{output_file}"
+      else
+        puts content
+      end
+    end
+
+    def verbose_log(message)
+      warn "[verbose] #{message}" if options[:verbose]
+    end
+
+    def error(message)
+      warn message
+    end
+
+    CONVERT_OPTIONS = %i[
+      toc toc_levels section_numbers section_number_levels
+      lang theme asset_delivery
+    ].freeze
+    private_constant :CONVERT_OPTIONS
+
+    SYMBOL_OPTIONS = %i[theme asset_delivery].freeze
+    private_constant :SYMBOL_OPTIONS
+
+    def build_convert_options
+      CONVERT_OPTIONS.each_with_object({}) do |key, opts|
+        value = options[key]
+        next unless value
+
+        opts[key] = SYMBOL_OPTIONS.include?(key) ? value.to_sym : value
       end
     end
   end