vectory 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1825d8ed689d1eb94da1c473ffd9671bc3237471f3f4b675d6f2d8ff6db4e2a7
-  data.tar.gz: 7d9ee417ac1b74b481589a83f45a359d556f1c3d2aa401149f57439c39085811
+  metadata.gz: fc294acc45e36e018340d14a047047d5addc5c712fabc42fec2642b82bc77aa8
+  data.tar.gz: '09b35052e8b019a2553eaa34ae14c6fce0344c5fc8d0e61b42fc4bb574bbe569'
 SHA512:
-  metadata.gz: 03d2373df0d22c8168dddecb4e073a62974db0d00b898d3a9896d839390c9aba6c959553d2e172e84534ece21913d0aa503d6469f600fae15e7bf5f32cc7a5b7
-  data.tar.gz: 169c5f762f9eb0a9897e7277633a1e7181f17e918341198b8d420ec482a3c83425d1ad45de4bce6428970d1850bc916fd91231a6c22dbf01c7ef6660070a7e5b
+  metadata.gz: ffb21fcdc31b15763547be90085ec49288588c7fabc9d9a2f803f5a0fcf5f958c3bf020e7f5aa96abeb2d31de2c1077e6cb9b9fa57b108e28355328e2fa64eb3
+  data.tar.gz: 989f2bb3ade3b0416571b67d7cf8262def78291e9730ee73050052ecc3fa84639be2f93d21af392fc7f7b2a0eb3be3aedd19afe7628598aa60f01afcd4d4f5ae

data/.github/workflows/rake.yml

@@ -15,5 +15,7 @@ permissions:
 jobs:
   rake:
     uses: metanorma/ci/.github/workflows/inkscape-rake.yml@main
+    with:
+      private-fonts: 'false'
     secrets:
       pat_token: ${{ secrets.CLARICLE_CI_PAT_TOKEN }}

data/Gemfile

@@ -6,6 +6,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "canon", "~> 0.1.7"
+gem "connection_pool", "~> 2.0"
 gem "openssl", "~> 3.0"
 gem "rake"
 gem "rspec"

data/lib/vectory/cli.rb

@@ -1,6 +1,5 @@
 require "thor"
-require_relative "../vectory"
-require_relative "file_magic"
+require "vectory"
 
 module Vectory
   class CLI < Thor

data/lib/vectory/conversion/ghostscript_strategy.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../ghostscript_wrapper"
-require_relative "strategy"
-
 module Vectory
   module Conversion
     # Ghostscript-based conversion strategy

data/lib/vectory/conversion/inkscape_strategy.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../inkscape_wrapper"
-require_relative "strategy"
-
 module Vectory
   module Conversion
     # Inkscape-based conversion strategy

data/lib/vectory/conversion.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "conversion/strategy"
-require_relative "conversion/inkscape_strategy"
-require_relative "conversion/ghostscript_strategy"
-
 module Vectory
   # Conversion module provides strategy-based conversion interface
   #
@@ -16,6 +12,10 @@ module Vectory
   # @example Get available strategies for a conversion
   #   Vectory::Conversion.strategies_for(:svg, :eps)
   module Conversion
+    # Autoload strategy classes
+    autoload :Strategy, "vectory/conversion/strategy"
+    autoload :InkscapeStrategy, "vectory/conversion/inkscape_strategy"
+    autoload :GhostscriptStrategy, "vectory/conversion/ghostscript_strategy"
     class << self
       # Convert content from one format to another
       #

data/lib/vectory/eps.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "ghostscript_wrapper"
-require_relative "pdf"
-
 module Vectory
   class Eps < Vector
     def self.default_extension

data/lib/vectory/ghostscript_wrapper.rb

@@ -2,18 +2,18 @@
 
 require "tempfile"
 require "fileutils"
-require_relative "errors"
-require_relative "system_call"
-require_relative "platform"
+require "ukiryu"
 
 module Vectory
   # GhostscriptWrapper converts PS and EPS files to PDF using Ghostscript
+  #
+  # Uses Ukiryu for platform-adaptive command execution.
   class GhostscriptWrapper
     SUPPORTED_INPUT_FORMATS = %w[ps eps].freeze
 
     class << self
       def available?
-        ghostscript_path
+        ghostscript_tool
         true
       rescue GhostscriptNotFoundError
         false
@@ -22,9 +22,8 @@ module Vectory
       def version
         return nil unless available?
 
-        cmd = [ghostscript_path, "--version"]
-        call = SystemCall.new(cmd).call
-        call.stdout.strip
+        tool = ghostscript_tool
+        tool.version
       rescue StandardError
         nil
       end
@@ -49,15 +48,22 @@ module Vectory
           # Close output file so GhostScript can write to it
           output_file.close
 
-          cmd = build_command(input_file.path, output_file.path,
-                              eps_crop: eps_crop)
+          # Get the tool and execute
+          tool = ghostscript_tool
+          params = build_convert_params(input_file.path, output_file.path,
+                                        eps_crop: eps_crop)
 
-          call = nil
-          begin
-            call = SystemCall.new(cmd).call
-          rescue SystemCallError => e
+          result = tool.execute(:convert,
+                                execution_timeout: Configuration.instance.timeout,
+                                **params)
+
+          unless result.success?
             raise ConversionError,
-                  "GhostScript conversion failed: #{e.message}"
+                  "GhostScript conversion failed. " \
+                  "Command: #{result.command}, " \
+                  "Exit status: #{result.status}, " \
+                  "stdout: '#{result.stdout.strip}', " \
+                  "stderr: '#{result.stderr.strip}'"
           end
 
           unless File.exist?(output_file.path)
@@ -71,9 +77,9 @@ module Vectory
           if output_content.size < 100
             raise ConversionError,
                   "GhostScript created invalid PDF (#{output_content.size} bytes). " \
-                  "Command: #{cmd.join(' ')}, " \
-                  "stdout: '#{call&.stdout&.strip}', " \
-                  "stderr: '#{call&.stderr&.strip}'"
+                  "Command: #{result.command}, " \
+                  "stdout: '#{result.stdout.strip}', " \
+                  "stderr: '#{result.stderr.strip}'"
           end
 
           output_content
@@ -86,74 +92,91 @@ module Vectory
         end
       end
 
-      private
+      # Convert PDF content to PostScript
+      #
+      # This is useful as a fallback when Inkscape's PDF import fails.
+      # Ghostscript can reliably convert PDF to EPS, and Inkscape can then
+      # import the EPS file.
+      #
+      # @param pdf_content [String] the PDF content to convert
+      # @return [String] the EPS content
+      # @raise [Vectory::ConversionError] if conversion fails
+      # @raise [Vectory::GhostscriptNotFoundError] if Ghostscript is not available
+      def pdf_to_eps(pdf_content)
+        raise GhostscriptNotFoundError unless available?
+
+        input_file = Tempfile.new(["pdf_input", ".pdf"])
+        output_file = Tempfile.new(["eps_output", ".eps"])
+
+        begin
+          input_file.binmode
+          input_file.write(pdf_content)
+          input_file.flush
+          input_file.close
+          output_file.close
 
-      def ghostscript_path
-        # First try common installation paths specific to each platform
-        if Platform.windows?
-          # Check common Windows installation directories first
-          common_windows_paths = [
-            "C:/Program Files/gs/gs*/bin/gswin64c.exe",
-            "C:/Program Files (x86)/gs/gs*/bin/gswin32c.exe",
-          ]
-
-          common_windows_paths.each do |pattern|
-            Dir.glob(pattern).sort.reverse.each do |path|
-              return path if File.executable?(path)
-            end
+          tool = ghostscript_tool
+          params = {
+            inputs: [input_file.path],
+            device: :eps2write,
+            output: output_file.path,
+            batch: true,
+            no_pause: true,
+            quiet: true,
+          }
+
+          result = tool.execute(:convert,
+                                execution_timeout: Configuration.instance.timeout,
+                                **params)
+
+          unless result.success?
+            raise ConversionError,
+                  "GhostScript PDF to EPS conversion failed. " \
+                  "Command: #{result.command}, " \
+                  "Exit status: #{result.status}, " \
+                  "stdout: '#{result.stdout.strip}', " \
+                  "stderr: '#{result.stderr.strip}'"
           end
 
-          # Then try PATH for Windows executables
-          ["gswin64c.exe", "gswin32c.exe", "gs"].each do |cmd|
-            path = find_in_path(cmd)
-            return path if path
+          unless File.exist?(output_file.path)
+            raise ConversionError,
+                  "GhostScript did not create output file: #{output_file.path}"
           end
-        else
-          # On Unix-like systems, check PATH
-          path = find_in_path("gs")
-          return path if path
-        end
 
-        raise GhostscriptNotFoundError
+          File.binread(output_file.path)
+        ensure
+          input_file.close unless input_file.closed?
+          input_file.unlink
+          output_file.close unless output_file.closed?
+          output_file.unlink
+        end
       end
 
-      def find_in_path(cmd)
-        # If command already has an extension, try it as-is first
-        if File.extname(cmd) != ""
-          Platform.executable_search_paths.each do |path|
-            exe = File.join(path, cmd)
-            return exe if File.executable?(exe) && !File.directory?(exe)
-          end
-        end
+      private
 
-        # Try with PATHEXT extensions
-        exts = ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
-        Platform.executable_search_paths.each do |path|
-          exts.each do |ext|
-            exe = File.join(path, "#{cmd}#{ext}")
-            return exe if File.executable?(exe) && !File.directory?(exe)
-          end
-        end
-        nil
+      # Get the Ghostscript tool from Ukiryu
+      def ghostscript_tool
+        Ukiryu::Tool.get("ghostscript")
+      rescue Ukiryu::Errors::ToolNotFoundError => e
+        # Tool not found - raise the original GhostscriptNotFoundError
+        raise GhostscriptNotFoundError, "Ghostscript not available: #{e.message}"
       end
 
-      def build_command(input_path, output_path, options = {})
-        cmd_parts = []
-        cmd_parts << ghostscript_path
-        cmd_parts << "-sDEVICE=pdfwrite"
-        cmd_parts << "-dNOPAUSE"
-        cmd_parts << "-dBATCH"
-        cmd_parts << "-dSAFER"
-        # Use separate arguments for output file to ensure proper path handling
-        cmd_parts << "-sOutputFile=#{output_path}"
-        cmd_parts << "-dEPSCrop" if options[:eps_crop]
-        cmd_parts << "-dAutoRotatePages=/None"
-        cmd_parts << "-dQUIET"
-        # Use -f to explicitly specify input file
-        cmd_parts << "-f"
-        cmd_parts << input_path
-
-        cmd_parts
+      # Build convert parameters for Ukiryu
+      def build_convert_params(input_path, output_path, options = {})
+        params = {
+          inputs: [input_path],
+          device: :pdfwrite,
+          output: output_path,
+          batch: true,
+          no_pause: true,
+          quiet: true,
+        }
+
+        # Add EPS crop option
+        params[:eps_crop] = true if options[:eps_crop]
+
+        params
       end
     end
   end

data/lib/vectory/inkscape_wrapper.rb

@@ -2,87 +2,102 @@
 
 require "singleton"
 require "tmpdir"
-require_relative "system_call"
-require_relative "platform"
+require "ukiryu"
 
 module Vectory
+  # InkscapeWrapper using Ukiryu for platform-adaptive command execution
+  #
+  # This class provides backward compatibility with the original InkscapeWrapper
+  # while using Ukiryu under the hood for shell detection, escaping, and execution.
   class InkscapeWrapper
     include Singleton
 
-    def self.convert(content:, input_format:, output_format:, output_class:,
+    class << self
+      def convert(content:, input_format:, output_format:, output_class:,
 plain: false)
-      instance.convert(
-        content: content,
-        input_format: input_format,
-        output_format: output_format,
-        output_class: output_class,
-        plain: plain,
-      )
+        instance.convert(
+          content: content,
+          input_format: input_format,
+          output_format: output_format,
+          output_class: output_class,
+          plain: plain,
+        )
+      end
     end
 
     def convert(content:, input_format:, output_format:, output_class:,
 plain: false)
-      with_temp_files(content, input_format,
-                      output_format) do |input_path, output_path|
-        exe = inkscape_path_or_raise_error
-        exe = external_path(exe)
-        input_path = external_path(input_path)
-        output_path = external_path(output_path)
-
-        cmd = build_command(exe, input_path, output_path, output_format, plain)
-        # Pass environment to disable display on non-Windows systems
-        env = headless_environment
-        call = SystemCall.new(cmd, env: env).call
-
-        actual_output = find_output(input_path, output_format)
-        raise_conversion_error(call) unless actual_output
-
-        output_class.from_path(actual_output)
+      with_temp_files(content, input_format, output_format) do |input_path, output_path|
+        # Get the tool
+        tool = get_inkscape_tool
+
+        # Build parameters
+        params = build_export_params(input_path, output_path, output_format, plain)
+
+        # Execute export command
+        result = tool.execute(:export,
+                              execution_timeout: Configuration.instance.timeout,
+                              **params)
+
+        raise_conversion_error(result) unless result.success?
+
+        # Check if output file exists at specified path
+        unless File.exist?(output_path)
+          # Raise error with stderr details if output file not found
+          # This handles cases where Inkscape returns exit code 0 but fails to create output
+          raise Vectory::ConversionError,
+                "Output file not found. " \
+                "Expected: #{output_path}\n" \
+                "Command: '#{result.command}',\n" \
+                "Exit status: '#{result.status}',\n" \
+                "stdout: '#{result.stdout.strip}',\n" \
+                "stderr: '#{result.stderr.strip}'."
+        end
+
+        output_class.from_path(output_path)
       end
     end
 
     def height(content, format)
-      query_integer(content, format, "--query-height")
+      query_integer(content, format, :height)
     end
 
     def width(content, format)
-      query_integer(content, format, "--query-width")
+      query_integer(content, format, :width)
     end
 
     private
 
-    def inkscape_path_or_raise_error
-      inkscape_path or raise(InkscapeNotFoundError,
-                             "Inkscape missing in PATH, unable to " \
-                             "convert image. Aborting.")
+    # Get the Inkscape tool from Ukiryu
+    def get_inkscape_tool
+      Ukiryu::Tool.get("inkscape")
+    rescue Ukiryu::Errors::ToolNotFoundError => e
+      # Tool not found - raise the original InkscapeNotFoundError
+      raise InkscapeNotFoundError, "Inkscape not available: #{e.message}"
     end
 
-    def inkscape_path
-      @inkscape_path ||= find_inkscape
-    end
+    # Build export parameters for Ukiryu
+    def build_export_params(input_path, output_path, output_format, plain)
+      params = {
+        inputs: [input_path],
+        output: output_path,
+      }
 
-    def find_inkscape
-      cmds.each do |cmd|
-        extensions.each do |ext|
-          Platform.executable_search_paths.each do |path|
-            exe = File.join(path, "#{cmd}#{ext}")
+      # Add format if specified (different from output extension)
+      # Inkscape can detect format from output extension in modern versions
+      # But we can be explicit
+      params[:format] = output_format.to_sym if output_format
 
-            return exe if File.executable?(exe) && !File.directory?(exe)
-          end
-        end
-      end
-
-      nil
-    end
+      # Add plain SVG flag
+      params[:plain] = true if plain && output_format == :svg
 
-    def cmds
-      ["inkscapecom", "inkscape"]
-    end
+      # Note: PDF import via Inkscape on macOS may have compatibility issues
+      # The pages option can specify which page to import, but may not work on all platforms
 
-    def extensions
-      ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+      params
     end
 
+    # Find the output file (Inkscape may create it with different name)
     def find_output(source_path, output_extension)
       basenames = [File.basename(source_path, ".*"),
                    File.basename(source_path)]
@@ -94,100 +109,106 @@ plain: false)
       paths.find { |p| File.exist?(p) }
     end
 
-    def raise_conversion_error(call)
+    # Raise conversion error with details
+    def raise_conversion_error(result)
       raise Vectory::ConversionError,
             "Could not convert with Inkscape. " \
-            "Inkscape cmd: '#{call.cmd}',\n" \
-            "status: '#{call.status}',\n" \
-            "stdout: '#{call.stdout.strip}',\n" \
-            "stderr: '#{call.stderr.strip}'."
-    end
+            "Command: '#{result.command}',\n" \
+            "Exit status: '#{result.status}',\n" \
+            "stdout: '#{result.stdout.strip}',\n" \
+            "stderr: '#{result.stderr.strip}'."
+    end
+
+    # Query integer value from Inkscape
+    #
+    # @param content [String] the file content
+    # @param format [String] the file format
+    # @param param_key [Symbol] the query parameter key (:width, :height, :x, :y)
+    # @return [Integer] the query result as an integer
+    def query_integer(content, format, param_key)
+      query(content, format, param_key).to_f.round
+    end
+
+    # Query Inkscape for information
+    #
+    # @param content [String] the file content
+    # @param format [String] the file format
+    # @param param_key [Symbol] the query parameter key (:width, :height, :x, :y)
+    # @return [String] the query result
+    def query(content, format, param_key)
+      tool = get_inkscape_tool
+      raise InkscapeNotFoundError, "Inkscape not available" unless tool
 
-    def build_command(exe, input_path, output_path, output_format, plain)
-      # Modern Inkscape (1.0+) uses --export-filename
-      # Older versions use --export-<format>-file or --export-type
-      if inkscape_version_modern?
-        cmd = "#{exe} --export-filename=#{output_path}"
-        cmd += " --export-plain-svg" if plain && output_format == :svg
-        # For PDF input, specify which page to use (avoid interactive prompt)
-        cmd += " --export-page=1" if input_path.end_with?(".pdf")
-      else
-        # Legacy Inkscape (0.x) uses --export-type
-        cmd = "#{exe} --export-type=#{output_format}"
-        cmd += " --export-plain-svg" if plain && output_format == :svg
-      end
-      cmd += " #{input_path}"
-      cmd
-    end
+      with_temp_file(content, format) do |path|
+        params = { input: path, param_key => true }
 
-    def inkscape_version_modern?
-      return @inkscape_version_modern if defined?(@inkscape_version_modern)
+        result = tool.execute(:query,
+                              execution_timeout: Configuration.instance.timeout,
+                              **params)
+        raise_query_error(result) if result.stdout.empty?
 
-      exe = inkscape_path
-      return @inkscape_version_modern = true unless exe # Default to modern
+        result.stdout
+      end
+    end
 
-      version_output = `#{external_path(exe)} --version 2>&1`
-      version_match = version_output.match(/Inkscape (\d+)\./)
+    # Create temp file with content
+    def with_temp_file(content, extension)
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "image.#{extension}")
+        File.binwrite(path, content)
 
-      @inkscape_version_modern = if version_match
-                                   version_match[1].to_i >= 1
-                                 else
-                                   true # Default to modern if we can't detect
-                                 end
+        yield path
+      end
     end
 
+    # Create temp files for input and output
     def with_temp_files(content, input_format, output_format)
       Dir.mktmpdir do |dir|
         input_path = File.join(dir, "image.#{input_format}")
         output_path = File.join(dir, "image.#{output_format}")
         File.binwrite(input_path, content)
 
-        yield input_path, output_path
+        begin
+          yield input_path, output_path
+        ensure
+          # On Windows, aggressively clean up temp files to avoid ENOTEMPTY errors
+          # caused by Inkscape leaving behind lock files or hanging processes
+          cleanup_temp_dir(dir) if Platform.windows?
+        end
       end
     end
 
-    def query_integer(content, format, options)
-      query(content, format, options).to_f.round
-    end
-
-    def query(content, format, options)
-      exe = inkscape_path_or_raise_error
-
-      with_temp_file(content, format) do |path|
-        cmd = "#{external_path(exe)} #{options} #{external_path(path)}"
-
-        # Pass environment to disable display on non-Windows systems
-        env = headless_environment
-        call = SystemCall.new(cmd, env: env).call
-        raise_query_error(call) if call.stdout.empty?
+    # Aggressively clean up temp directory on Windows
+    # Handles cases where Inkscape leaves behind files or processes
+    def cleanup_temp_dir(dir)
+      # Give processes a moment to release file handles
+      sleep(0.2)
 
-        call.stdout
+      # Try to remove all files in the directory
+      Dir.glob(File.join(dir, "**", "*")).reverse_each do |file|
+        File.delete(file) if File.file?(file)
+      rescue Errno::EACCES, Errno::ENOENT
+        # File may be locked or already deleted, ignore
       end
-    end
 
-    def with_temp_file(content, extension)
-      Dir.mktmpdir do |dir|
-        path = File.join(dir, "image.#{extension}")
-        File.binwrite(path, content)
-
-        yield path
+      # Try to remove subdirectories
+      Dir.glob(File.join(dir, "**", "*")).reverse_each do |path|
+        Dir.rmdir(path) if File.directory?(path)
+      rescue Errno::EACCES, Errno::ENOENT, Errno::ENOTEMPTY
+        # Directory may be locked or not empty, ignore
       end
+    rescue StandardError
+      # Best effort cleanup, don't raise
     end
 
-    def raise_query_error(call)
+    # Raise query error with details
+    def raise_query_error(result)
       raise Vectory::InkscapeQueryError,
             "Could not query with Inkscape. " \
-            "Inkscape cmd: '#{call.cmd}',\n" \
-            "status: '#{call.status}',\n" \
-            "stdout: '#{call.stdout.strip}',\n" \
-            "stderr: '#{call.stderr.strip}'."
-    end
-
-    # Returns environment variables for headless operation
-    # On non-Windows systems, disable DISPLAY to prevent X11/GDK initialization
-    def headless_environment
-      # On macOS/Linux, disable DISPLAY to prevent Gdk/X11 warnings
-      Platform.windows? ? {} : { "DISPLAY" => "" }
+            "Command: '#{result.command}',\n" \
+            "Exit status: '#{result.status}',\n" \
+            "stdout: '#{result.stdout.strip}',\n" \
+            "stderr: '#{result.stderr.strip}'."
     end
 
     # Format paths for command execution on current platform

data/lib/vectory/pdf.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "vector"
-require_relative "inkscape_wrapper"
-
 module Vectory
   class Pdf < Vector
     attr_accessor :original_height, :original_width
@@ -16,13 +13,7 @@ module Vectory
     end
 
     def to_svg
-      svg = InkscapeWrapper.convert(
-        content: content,
-        input_format: :pdf,
-        output_format: :svg,
-        output_class: Svg,
-        plain: true,
-      )
+      svg = convert_to_svg
 
       # If we have original dimensions from EPS/PS, adjust the SVG
       if original_height && original_width
@@ -35,33 +26,82 @@ module Vectory
     end
 
     def to_eps
-      InkscapeWrapper.convert(
-        content: content,
-        input_format: :pdf,
-        output_format: :eps,
-        output_class: Eps,
-      )
+      with_inkscape_pdf_fallback(:eps, Eps)
     end
 
     def to_ps
-      InkscapeWrapper.convert(
-        content: content,
-        input_format: :pdf,
-        output_format: :ps,
-        output_class: Ps,
-      )
+      with_inkscape_pdf_fallback(:ps, Ps)
     end
 
     def to_emf
+      with_inkscape_pdf_fallback(:emf, Emf)
+    end
+
+    private
+
+    # Execute a conversion with fallback for Inkscape PDF import issues
+    #
+    # Inkscape 1.4.x on Windows and macOS has a PDF import bug where it
+    # may fail to create output files. This method catches any conversion
+    # error and retries via the PDF → EPS → target format path.
+    #
+    # @param output_format [Symbol] the target format (:svg, :eps, :ps, :emf)
+    # @param output_class [Class] the output class (Svg, Eps, Ps, Emf)
+    # @param plain [Boolean] whether to use plain SVG format (only for SVG)
+    # @return [Vector] the converted output
+    # @raise [Vectory::ConversionError] if both methods fail
+    def with_inkscape_pdf_fallback(output_format, output_class, plain: false)
       InkscapeWrapper.convert(
         content: content,
         input_format: :pdf,
-        output_format: :emf,
-        output_class: Emf,
+        output_format: output_format,
+        output_class: output_class,
+        plain: plain,
       )
+    rescue Vectory::ConversionError => e
+      log_conversion_failure(e, output_format)
+
+      # Try fallback: PDF → EPS (Ghostscript) → target format (Inkscape)
+      begin
+        warn "[VECTORY] Attempting fallback: PDF → EPS → #{output_format.upcase}" if fallback_logging_enabled?
+        eps_content = GhostscriptWrapper.pdf_to_eps(content)
+        warn "[VECTORY] PDF → EPS succeeded, now trying EPS → #{output_format.upcase}" if fallback_logging_enabled?
+        return InkscapeWrapper.convert(
+          content: eps_content,
+          input_format: :eps,
+          output_format: output_format,
+          output_class: output_class,
+          plain: plain,
+        )
+      rescue StandardError => fallback_error
+        # Wrap non-Vectory errors in ConversionError for consistent error handling
+        error_to_raise = if fallback_error.is_a?(Vectory::Error)
+                           fallback_error
+                         else
+                           ConversionError.new(
+                             "PDF fallback conversion failed: #{fallback_error.message}"
+                           )
+                         end
+        warn "[VECTORY] Fallback also failed: #{fallback_error.message[0..100]}" if fallback_logging_enabled?
+        raise error_to_raise
+      end
     end
 
-    private
+    # Convert PDF to SVG using fallback mechanism
+    def convert_to_svg
+      with_inkscape_pdf_fallback(:svg, Svg, plain: true)
+    end
+
+    def log_conversion_failure(error, output_format)
+      return unless fallback_logging_enabled?
+
+      warn "[VECTORY] PDF → #{output_format.upcase} direct conversion failed:"
+      warn "[VECTORY]   Error: #{error.message[0..200]}"
+    end
+
+    def fallback_logging_enabled?
+      ENV["VECTORY_DEBUG"] || ENV["CI"]
+    end
 
     def adjust_svg_dimensions(svg_content, width, height)
       # Replace width and height attributes in SVG root element

data/lib/vectory/ps.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "ghostscript_wrapper"
-require_relative "pdf"
-
 module Vectory
   class Ps < Vector
     def self.default_extension

data/lib/vectory/svg_mapping.rb

@@ -1,6 +1,3 @@
-require_relative "svg"
-require_relative "svg_document"
-
 module Vectory
   # Processes SVG mapping in XML documents.
   #

data/lib/vectory/vector.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "tempfile"
-require_relative "inkscape_wrapper"
 
 module Vectory
   class Vector < Image

data/lib/vectory/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vectory
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/lib/vectory.rb

@@ -1,30 +1,14 @@
 # frozen_string_literal: true
 
+# External dependencies
 require "logger"
-require_relative "vectory/version"
-require_relative "vectory/utils"
+require "ukiryu"
 
+# Define base error class and additional error classes
+# (used in class bodies like cli.rb, so can't be autoloaded)
 module Vectory
   class Error < StandardError; end
-end
-
-require_relative "vectory/errors"
-require_relative "vectory/platform"
-require_relative "vectory/configuration"
-require_relative "vectory/conversion"
-require_relative "vectory/image"
-require_relative "vectory/image_resize"
-require_relative "vectory/datauri"
-require_relative "vectory/vector"
-require_relative "vectory/ghostscript_wrapper"
-require_relative "vectory/pdf"
-require_relative "vectory/eps"
-require_relative "vectory/ps"
-require_relative "vectory/emf"
-require_relative "vectory/svg"
-require_relative "vectory/svg_mapping"
 
-module Vectory
   class SystemCallError < Error; end
 
   class NotImplementedError < Error; end
@@ -32,7 +16,42 @@ module Vectory
   class NotWrittenToDiskError < Error; end
 
   class ParsingError < Error; end
+end
+
+require_relative "vectory/errors"
 
+# Lazy load: all other internal Vectory dependencies via autoload
+module Vectory
+  # Core utilities
+  autoload :Version, "vectory/version"
+  autoload :Utils, "vectory/utils"
+  autoload :Platform, "vectory/platform"
+
+  # Wrappers
+  autoload :GhostscriptWrapper, "vectory/ghostscript_wrapper"
+  autoload :InkscapeWrapper, "vectory/inkscape_wrapper"
+
+  # Conversion system
+  autoload :Conversion, "vectory/conversion"
+
+  # Format classes
+  autoload :Configuration, "vectory/configuration"
+  autoload :Image, "vectory/image"
+  autoload :ImageResize, "vectory/image_resize"
+  autoload :Datauri, "vectory/datauri"
+  autoload :Vector, "vectory/vector"
+  autoload :Pdf, "vectory/pdf"
+  autoload :Eps, "vectory/eps"
+  autoload :Ps, "vectory/ps"
+  autoload :Emf, "vectory/emf"
+  autoload :Svg, "vectory/svg"
+  autoload :SvgMapping, "vectory/svg_mapping"
+  autoload :SvgDocument, "vectory/svg_document"
+  autoload :FileMagic, "vectory/file_magic"
+end
+
+# Define additional module methods
+module Vectory
   def self.ui
     @ui ||= Logger.new($stdout).tap do |logger|
       logger.level = ENV["VECTORY_LOG"] || Logger::WARN

data/vectory.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
     f.match(%r{^(bin|spec)/})
   end
   spec.test_files = `git ls-files -- {spec}/*`.split("\n")
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.add_dependency "base64"
   spec.add_dependency "emf2svg"
@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "marcel", "~> 1.0"
   spec.add_dependency "nokogiri", "~> 1.14"
   spec.add_dependency "thor", "~> 1.0"
+  spec.add_dependency "ukiryu", "~> 0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vectory
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-05 00:00:00.000000000 Z
+date: 2026-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ukiryu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: |
   Vectory performs pairwise vector image conversions for common
   vector image formats, such as SVG, EMF, EPS and PS.
@@ -110,7 +124,6 @@ files:
 - ".github/workflows/rake.yml"
 - ".github/workflows/release.yml"
 - ".gitignore"
-- ".hound.yml"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - Gemfile
@@ -137,7 +150,6 @@ files:
 - docs/understanding/inkscape-wrapper.adoc
 - exe/vectory
 - lib/vectory.rb
-- lib/vectory/capture.rb
 - lib/vectory/cli.rb
 - lib/vectory/configuration.rb
 - lib/vectory/conversion.rb
@@ -159,7 +171,6 @@ files:
 - lib/vectory/svg.rb
 - lib/vectory/svg_document.rb
 - lib/vectory/svg_mapping.rb
-- lib/vectory/system_call.rb
 - lib/vectory/utils.rb
 - lib/vectory/vector.rb
 - lib/vectory/version.rb
@@ -177,7 +188,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.hound.yml

@@ -1,5 +0,0 @@
-# Auto-generated by Cimas: Do not edit it manually!
-# See https://github.com/metanorma/cimas
-ruby:
-  enabled: true
-  config_file: .rubocop.yml

data/lib/vectory/capture.rb

@@ -1,243 +0,0 @@
-require "timeout"
-
-module Vectory
-  module Capture
-    class << self
-      def windows?
-        !!((RUBY_PLATFORM =~ /(win|w)(32|64)$/) ||
-           (RUBY_PLATFORM =~ /mswin|mingw/))
-      end
-
-      # Capture the standard output and the standard error of a command.
-      # Almost same as Open3.capture3 method except for timeout handling and return value.
-      # See Open3.capture3.
-      #
-      #   result = with_timeout([env,] cmd... [, opts])
-      #
-      # The arguments env, cmd and opts are passed to Process.spawn except
-      # opts[:stdin_data], opts[:binmode], opts[:timeout], opts[:signal]
-      # and opts[:kill_after].  See Process.spawn.
-      #
-      # If opts[:stdin_data] is specified, it is sent to the command's standard input.
-      #
-      # If opts[:binmode] is true, internal pipes are set to binary mode.
-      #
-      # If opts[:timeout] is specified, SIGTERM is sent to the command after specified seconds.
-      #
-      # If opts[:signal] is specified, it is used instead of SIGTERM on timeout.
-      #
-      # If opts[:kill_after] is specified, also send a SIGKILL after specified seconds.
-      # it is only sent if the command is still running after the initial signal was sent.
-      #
-      # The return value is a Hash as shown below.
-      #
-      #   {
-      #     :pid     => PID of the command,
-      #     :status  => Process::Status of the command,
-      #     :stdout  => the standard output of the command,
-      #     :stderr  => the standard error of the command,
-      #     :timeout => whether the command was timed out,
-      #   }
-      def with_timeout(*cmd)
-        spawn_opts = Hash === cmd.last ? cmd.pop.dup : {}
-
-        # Separate environment variables (string keys) from spawn options (symbol keys)
-        env_vars = spawn_opts.reject { |k, _| k.is_a?(Symbol) }
-        spawn_opts = spawn_opts.reject { |k, _| k.is_a?(String) }
-
-        # Windows only supports :KILL signal reliably, Unix can use :TERM for graceful shutdown
-        default_signal = windows? ? :KILL : :TERM
-        opts = {
-          stdin_data: spawn_opts.delete(:stdin_data) || "",
-          binmode: spawn_opts.delete(:binmode) || false,
-          timeout: spawn_opts.delete(:timeout),
-          signal: spawn_opts.delete(:signal) || default_signal,
-          kill_after: spawn_opts.delete(:kill_after) || 2,
-        }
-
-        in_r,  in_w  = IO.pipe
-        out_r, out_w = IO.pipe
-        err_r, err_w = IO.pipe
-        in_w.sync = true
-
-        if opts[:binmode]
-          in_w.binmode
-          out_r.binmode
-          err_r.binmode
-        end
-
-        spawn_opts[:in]  = in_r
-        spawn_opts[:out] = out_w
-        spawn_opts[:err] = err_w
-
-        result = {
-          pid: nil,
-          status: nil,
-          stdout: "",
-          stderr: "",
-          timeout: false,
-        }
-
-        out_reader = nil
-        err_reader = nil
-        wait_thr = nil
-        watchdog = nil
-
-        begin
-          # Pass environment variables and command to spawn
-          # spawn signature: spawn([env], cmd..., [options])
-          # If env_vars is not empty, pass it as the first argument
-          result[:pid] = if env_vars.any?
-                           spawn(env_vars, *cmd, spawn_opts)
-                         else
-                           spawn(*cmd, spawn_opts)
-                         end
-          wait_thr = Process.detach(result[:pid])
-          in_r.close
-          out_w.close
-          err_w.close
-
-          # Start reader threads with timeout protection
-          out_reader = Thread.new do
-            out_r.read
-          rescue StandardError => e
-            Vectory.ui.debug("Output reader error: #{e}")
-            ""
-          end
-
-          err_reader = Thread.new do
-            err_r.read
-          rescue StandardError => e
-            Vectory.ui.debug("Error reader error: #{e}")
-            ""
-          end
-
-          # Write input data
-          begin
-            in_w.write opts[:stdin_data]
-            in_w.close
-          rescue Errno::EPIPE
-            # Process may have exited early
-          end
-
-          # Watchdog thread to enforce timeout
-          if opts[:timeout]
-            watchdog = Thread.new do
-              sleep opts[:timeout]
-              if windows?
-                # Windows: Use spawn to run taskkill in background (non-blocking)
-                if wait_thr.alive?
-                  result[:timeout] = true
-                  # Spawn taskkill in background to avoid blocking
-                  begin
-                    Process.spawn("taskkill", "/pid", result[:pid].to_s, "/f",
-                                  %i[out err] => File::NULL)
-                  rescue Errno::ENOENT
-                    # taskkill not found (shouldn't happen on Windows)
-                  end
-                end
-              elsif wait_thr.alive?
-                # Unix: Use Process.kill which works reliably
-                result[:timeout] = true
-                pid = spawn_opts[:pgroup] ? -result[:pid] : result[:pid]
-
-                begin
-                  Process.kill(opts[:signal], pid)
-                rescue Errno::ESRCH, Errno::EINVAL, Errno::EPERM
-                  # Process already dead, invalid signal, or permission denied
-                end
-
-                # Wait for kill_after duration, then force kill
-                sleep opts[:kill_after]
-                if wait_thr.alive?
-                  begin
-                    Process.kill(:KILL, pid)
-                  rescue Errno::ESRCH, Errno::EINVAL, Errno::EPERM
-                    # Process already dead, invalid signal, or permission denied
-                  end
-                end
-              end
-            end
-          end
-
-          # Wait for process to complete with timeout
-          if opts[:timeout]
-            if windows?
-              # On Windows, use polling with timeout to avoid long sleeps
-              deadline = Time.now + opts[:timeout] + 5
-              loop do
-                break unless wait_thr.alive?
-                break if Time.now > deadline
-
-                sleep 0.5
-              end
-            else
-              deadline = Time.now + opts[:timeout] + (opts[:kill_after] || 2) + 1
-              loop do
-                break unless wait_thr.alive?
-                break if Time.now > deadline
-
-                sleep 0.1
-              end
-
-              # Force kill if still alive after deadline
-              if wait_thr.alive?
-                begin
-                  Process.kill(:KILL, result[:pid])
-                rescue Errno::ESRCH, Errno::EINVAL, Errno::EPERM
-                  # Process already dead, invalid signal, or permission denied
-                end
-              end
-            end
-          end
-
-          # Wait for process status (with timeout protection)
-          status_deadline = Time.now + 5
-          while wait_thr.alive? && Time.now < status_deadline
-            sleep 0.1
-          end
-        ensure
-          # Clean up watchdog
-          watchdog&.kill
-
-          # Get process status
-          begin
-            result[:status] = wait_thr.value if wait_thr
-          rescue StandardError => e
-            Vectory.ui.debug("Error getting process status: #{e}")
-            # Create a fake failed status
-            result[:status] = Process::Status.allocate
-          end
-
-          # Get output with timeout protection
-          if out_reader
-            if out_reader.join(2)
-              result[:stdout] = out_reader.value || ""
-            else
-              out_reader.kill
-              result[:stdout] = ""
-            end
-          end
-
-          if err_reader
-            if err_reader.join(2)
-              result[:stderr] = err_reader.value || ""
-            else
-              err_reader.kill
-              result[:stderr] = ""
-            end
-          end
-
-          # Close all pipes
-          [in_w, out_r, err_r].each do |io|
-            io.close unless io.closed?
-          rescue StandardError => e
-            Vectory.ui.debug("Error closing pipe: #{e}")
-          end
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/vectory/system_call.rb

@@ -1,86 +0,0 @@
-require "open3"
-require_relative "capture"
-
-module Vectory
-  class SystemCall
-    TIMEOUT = 60
-
-    attr_reader :status, :stdout, :stderr, :cmd
-
-    def initialize(cmd, timeout = TIMEOUT, env: {})
-      @cmd = cmd
-      @timeout = timeout
-      @env = env
-    end
-
-    def call
-      log_cmd(@cmd)
-
-      execute(@cmd, @env)
-
-      log_result
-
-      raise_error unless @status.success?
-
-      self
-    end
-
-    private
-
-    def log_cmd(cmd)
-      Vectory.ui.debug("Cmd: '#{cmd}'")
-    end
-
-    def execute(cmd, env)
-      # Build spawn options with environment variables and timeout settings
-      spawn_opts = {}
-      spawn_opts.merge!(env) if env.any?
-      spawn_opts[:timeout] = @timeout
-      spawn_opts[:signal] = :TERM # Use TERM on Unix for graceful shutdown
-      spawn_opts[:kill_after] = 2
-
-      # Pass command and options directly (without splatting)
-      # Capture.with_timeout expects: cmd, options_hash
-      # It will handle extracting the options correctly
-      result = if cmd.is_a?(Array)
-                 Capture.with_timeout(*cmd, spawn_opts)
-               else
-                 Capture.with_timeout(cmd, spawn_opts)
-               end
-      @stdout = result[:stdout] || ""
-      @stderr = result[:stderr] || ""
-      @status = result[:status]
-      @timed_out = result[:timeout]
-    rescue Errno::ENOENT => e
-      raise SystemCallError, e.inspect
-    end
-
-    def log_result
-      Vectory.ui.debug("Status: #{@status.inspect}")
-      Vectory.ui.debug("Stdout: '#{@stdout.strip}'")
-      Vectory.ui.debug("Stderr: '#{@stderr.strip}'")
-    end
-
-    def raise_error
-      if @timed_out
-        raise SystemCallError,
-              "Command timed out after #{@timeout} seconds: #{@cmd},\n  " \
-              "stdout: '#{@stdout.strip}',\n  " \
-              "stderr: '#{@stderr.strip}'"
-      end
-
-      if @status.nil?
-        raise SystemCallError,
-              "Failed to run #{@cmd} (no status available),\n  " \
-              "stdout: '#{@stdout.strip}',\n  " \
-              "stderr: '#{@stderr.strip}'"
-      end
-
-      raise SystemCallError,
-            "Failed to run #{@cmd},\n  " \
-            "status: #{@status.exitstatus},\n  " \
-            "stdout: '#{@stdout.strip}',\n  " \
-            "stderr: '#{@stderr.strip}'"
-    end
-  end
-end