coradoc 1.1.8 → 2.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa6087920cf2a472b02e4e44bdf3b984f42e99e39d0290c7621d431629e747f2
-  data.tar.gz: 1f51521272e4ab8cb514ae1d0dafc7a68f83ecd95637cb7ed0a8c9fdfab7eba4
+  metadata.gz: 6828a80bfe7322793f21da830475a7fe98af2dec11d72ef985ed215b64018d75
+  data.tar.gz: 317a34a26bbd9587a4e13c76ff0e59b89e5bf9961916cad341c213d42537e817
 SHA512:
-  metadata.gz: 58a6a02fe1f0f6515da56c238a7068d18148cb91e3e172a2c8bdf7cc3af03363ba6ee4931a67f3d07ec9eaf5135a1d9092109a2c801aa37e516924a9b011be8d
-  data.tar.gz: 18ca28c32f330ba3a0457f07e3fd92732f7d91895b555791d5648fa7903f50345cbed89b09fdcb5e6c34537dbddb1ed5ca9c0ea2531044738892ffa9b7fa341c
+  metadata.gz: ceee0f035da234907f3b31848ee5646d20dcc586e46b0ed6f76c6b6630b3aaefbf5020b8d019dd8e97b5a2e4ac7313ab4c30ab15d316dc788745bc37a4970e85
+  data.tar.gz: d7c1007737f72a87dfd0cb929bd6ef693783548960f5468603960c5b73a15eb93005fd2f7335446eb94fa8d9ff92eb3412632f04fb7796c4e197a8364bc7a5df

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,105 +1,199 @@
-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'
+    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 = {}
+      opts[:theme] = options[:theme].to_sym if options[:theme]
+      opts[:asset_delivery] = options[:"asset-delivery"].to_sym if options[:"asset-delivery"]
+
+      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 "version", "display version information"
+    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 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
   end
 end