vectory 0.7.8 → 0.8.1

data/lib/vectory/inkscape_wrapper.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "tmpdir"
+require_relative "system_call"
+require_relative "platform"
+
+module Vectory
+  class InkscapeWrapper
+    include Singleton
+
+    def self.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,
+      )
+    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)
+      end
+    end
+
+    def height(content, format)
+      query_integer(content, format, "--query-height")
+    end
+
+    def width(content, format)
+      query_integer(content, format, "--query-width")
+    end
+
+    private
+
+    def inkscape_path_or_raise_error
+      inkscape_path or raise(InkscapeNotFoundError,
+                             "Inkscape missing in PATH, unable to " \
+                             "convert image. Aborting.")
+    end
+
+    def inkscape_path
+      @inkscape_path ||= find_inkscape
+    end
+
+    def find_inkscape
+      cmds.each do |cmd|
+        extensions.each do |ext|
+          Platform.executable_search_paths.each do |path|
+            exe = File.join(path, "#{cmd}#{ext}")
+
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+      end
+
+      nil
+    end
+
+    def cmds
+      ["inkscapecom", "inkscape"]
+    end
+
+    def extensions
+      ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+    end
+
+    def find_output(source_path, output_extension)
+      basenames = [File.basename(source_path, ".*"),
+                   File.basename(source_path)]
+
+      paths = basenames.map do |basename|
+        "#{File.join(File.dirname(source_path), basename)}.#{output_extension}"
+      end
+
+      paths.find { |p| File.exist?(p) }
+    end
+
+    def raise_conversion_error(call)
+      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
+
+    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
+
+    def inkscape_version_modern?
+      return @inkscape_version_modern if defined?(@inkscape_version_modern)
+
+      exe = inkscape_path
+      return @inkscape_version_modern = true unless exe # Default to modern
+
+      version_output = `#{external_path(exe)} --version 2>&1`
+      version_match = version_output.match(/Inkscape (\d+)\./)
+
+      @inkscape_version_modern = if version_match
+                                   version_match[1].to_i >= 1
+                                 else
+                                   true # Default to modern if we can't detect
+                                 end
+    end
+
+    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
+      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?
+
+        call.stdout
+      end
+    end
+
+    def with_temp_file(content, extension)
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "image.#{extension}")
+        File.binwrite(path, content)
+
+        yield path
+      end
+    end
+
+    def raise_query_error(call)
+      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" => "" }
+    end
+
+    # Format paths for command execution on current platform
+    # Handles Windows backslash conversion and quoting for paths with spaces
+    def external_path(path)
+      return path unless path
+      return path unless Platform.windows?
+
+      # Convert forward slashes to backslashes
+      path.gsub!(%r{/}, "\\")
+      # Quote paths with spaces
+      path[/\s/] ? "\"#{path}\"" : path
+    end
+  end
+end

data/lib/vectory/pdf.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "vector"
+require_relative "inkscape_wrapper"
+
+module Vectory
+  class Pdf < Vector
+    attr_accessor :original_height, :original_width
+
+    def self.default_extension
+      "pdf"
+    end
+
+    def self.mimetype
+      "application/pdf"
+    end
+
+    def to_svg
+      svg = InkscapeWrapper.convert(
+        content: content,
+        input_format: :pdf,
+        output_format: :svg,
+        output_class: Svg,
+        plain: true,
+      )
+
+      # If we have original dimensions from EPS/PS, adjust the SVG
+      if original_height && original_width
+        adjusted_content = adjust_svg_dimensions(svg.content, original_width,
+                                                 original_height)
+        svg = Svg.new(adjusted_content, svg.initial_path)
+      end
+
+      svg
+    end
+
+    def to_eps
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :pdf,
+        output_format: :eps,
+        output_class: Eps,
+      )
+    end
+
+    def to_ps
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :pdf,
+        output_format: :ps,
+        output_class: Ps,
+      )
+    end
+
+    def to_emf
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :pdf,
+        output_format: :emf,
+        output_class: Emf,
+      )
+    end
+
+    private
+
+    def adjust_svg_dimensions(svg_content, width, height)
+      # Replace width and height attributes in SVG root element
+      svg_content.gsub(/(<svg[^>]*\s)width="[^"]*"/, "\\1width=\"#{width}\"")
+        .gsub(/(<svg[^>]*\s)height="[^"]*"/, "\\1height=\"#{height}\"")
+        .gsub(/(<svg[^>]*\s)viewBox="[^"]*"/) do |match|
+          # Adjust viewBox to match new dimensions
+          "#{match.split('viewBox')[0]}viewBox=\"0 0 #{width} #{height}\""
+      end
+    end
+  end
+end

data/lib/vectory/platform.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Vectory
+  # Platform abstraction for centralized OS-specific behavior
+  #
+  # This class provides a single source of truth for platform detection
+  # and platform-specific path handling, eliminating duplicated logic
+  # across InkscapeWrapper, GhostscriptWrapper, and other classes.
+  #
+  # @example Check if running on Windows
+  #   Vectory::Platform.windows? # => true or false
+  #
+  # @example Format a path for execution on the current platform
+  #   Vectory::Platform.path_for_execution("C:/Program Files/Inkscape/inkscape.exe")
+  #   # On Windows: "C:\\Program Files\\Inkscape\\inkscape.exe"
+  #   # On Unix:   "C:/Program Files/Inkscape/inkscape.exe"
+  class Platform
+    class << self
+      # Detect if running on Windows
+      #
+      # @return [Boolean] true if on Windows platform
+      def windows?
+        Gem.win_platform?
+      end
+
+      # Detect if running on macOS
+      #
+      # @return [Boolean] true if on macOS platform
+      def macos?
+        RbConfig::CONFIG["host_os"].include?("darwin")
+      end
+
+      # Detect if running on Linux
+      #
+      # @return [Boolean] true if on Linux platform
+      def linux?
+        RbConfig::CONFIG["host_os"].include?("linux")
+      end
+
+      # Format a file path for execution on the current platform
+      #
+      # On Windows, converts forward slashes to backslashes and quotes paths with spaces.
+      # On Unix-like systems, returns the path unchanged.
+      #
+      # @param path [String] the file path to format
+      # @return [String] platform-formatted path
+      def path_for_execution(path)
+        return path unless path
+
+        formatted_path = windows? ? path.gsub("/", "\\") : path
+
+        # Quote paths with spaces to prevent shell parsing issues
+        formatted_path[/\s/] ? "\"#{formatted_path}\"" : formatted_path
+      end
+
+      # Get the PATH environment variable as an array
+      #
+      # Handles different PATH separators on Windows (;) vs Unix (:)
+      #
+      # @return [Array<String>] array of directory paths
+      def executable_search_paths
+        @executable_search_paths ||= begin
+          path_sep = windows? ? ";" : ":"
+          (ENV["PATH"] || "").split(path_sep)
+        end
+      end
+
+      # Check if a command is available in the system PATH
+      #
+      # @param command [String] the command to check
+      # @return [Boolean] true if command is found in PATH
+      def command_available?(command)
+        executable_search_paths.any? do |dir|
+          executable_path = File.join(dir, command)
+          File.executable?(executable_path) && !File.directory?(executable_path)
+        end
+      end
+
+      # Get the appropriate shell command extension for the platform
+      #
+      # @return [String, nil] ".exe" on Windows, nil on Unix
+      def command_extension
+        windows? ? ".exe" : nil
+      end
+
+      # Get the default shell for the platform
+      #
+      # @return [String] shell command (e.g., "cmd.exe" on Windows, "sh" on Unix)
+      def default_shell
+        if windows?
+          "cmd.exe"
+        else
+          "sh"
+        end
+      end
+
+      # Reset cached values (primarily for testing)
+      #
+      # @api private
+      def reset_cache
+        @executable_search_paths = nil
+      end
+    end
+  end
+end

data/lib/vectory/ps.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "ghostscript_wrapper"
+require_relative "pdf"
+
 module Vectory
   class Ps < Vector
     def self.default_extension
@@ -20,15 +23,56 @@ module Vectory
     end
 
     def to_eps
-      convert_with_inkscape("--export-type=eps", Eps)
+      to_pdf.to_eps
     end
 
     def to_emf
-      convert_with_inkscape("--export-type=emf", Emf)
+      to_pdf.to_emf
     end
 
     def to_svg
-      convert_with_inkscape("--export-type=svg", Svg)
+      to_pdf.to_svg
+    end
+
+    def to_pdf
+      pdf_content = GhostscriptWrapper.convert(content, eps_crop: false)
+      pdf = Pdf.new(pdf_content)
+      # Pass original BoundingBox dimensions to preserve them in conversions
+      bbox = parse_bounding_box
+      if bbox
+        pdf.original_width = bbox[:urx] - bbox[:llx]
+        pdf.original_height = bbox[:ury] - bbox[:lly]
+      end
+      pdf
+    end
+
+    def height
+      bbox = parse_bounding_box
+      return super unless bbox
+
+      bbox[:ury] - bbox[:lly]
+    end
+
+    def width
+      bbox = parse_bounding_box
+      return super unless bbox
+
+      bbox[:urx] - bbox[:llx]
+    end
+
+    private
+
+    def parse_bounding_box
+      # Look for %%BoundingBox: llx lly urx ury
+      match = content.match(/^%%BoundingBox:\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)/m)
+      return nil unless match
+
+      {
+        llx: match[1].to_f,
+        lly: match[2].to_f,
+        urx: match[3].to_f,
+        ury: match[4].to_f,
+      }
     end
   end
 end

data/lib/vectory/svg.rb

@@ -32,15 +32,58 @@ module Vectory
     end
 
     def to_emf
-      convert_with_inkscape("--export-type=emf", Emf)
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :svg,
+        output_format: :emf,
+        output_class: Emf,
+      )
     end
 
     def to_eps
-      convert_with_inkscape("--export-type=eps", Eps)
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :svg,
+        output_format: :eps,
+        output_class: Eps,
+      )
     end
 
     def to_ps
-      convert_with_inkscape("--export-type=ps", Ps)
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :svg,
+        output_format: :ps,
+        output_class: Ps,
+      )
+    end
+
+    def height
+      # Try to read height from SVG attributes first
+      doc = Nokogiri::XML(content)
+      svg_element = doc.at_xpath("//svg:svg",
+                                 "svg" => SVG_NS) || doc.at_xpath("//svg")
+
+      if svg_element && svg_element["height"]
+        svg_element["height"].to_f.round
+      else
+        # Fall back to Inkscape query if no height attribute
+        super
+      end
+    end
+
+    def width
+      # Try to read width from SVG attributes first
+      doc = Nokogiri::XML(content)
+      svg_element = doc.at_xpath("//svg:svg",
+                                 "svg" => SVG_NS) || doc.at_xpath("//svg")
+
+      if svg_element && svg_element["width"]
+        svg_element["width"].to_f.round
+      else
+        # Fall back to Inkscape query if no width attribute
+        super
+      end
     end
 
     private

data/lib/vectory/svg_document.rb

@@ -4,6 +4,44 @@ module Vectory
   class SvgDocument
     SVG_NS = "http://www.w3.org/2000/svg".freeze
 
+    class << self
+      # Update instances of id in style statements in a nokogiri document
+      def update_ids_css(document, ids, suffix)
+        suffix = suffix.is_a?(Integer) ? sprintf("%09d", suffix) : suffix
+        document.xpath(".//m:style", "m" => SVG_NS).each do |s|
+          c = s.children.to_xml
+          s.children = update_ids_css_string(c, ids, suffix)
+        end
+        document.xpath(".//*[@style]").each do |s|
+          s["style"] = update_ids_css_string(s["style"], ids, suffix)
+        end
+      end
+
+      # Update instances of id in style statements in the string style
+      def update_ids_css_string(style, ids, suffix)
+        ids.each do |i|
+          style = style.gsub(%r[##{i}\b],
+                             sprintf("#%<id>s_%<suffix>s", id: i,
+                                                           suffix: suffix))
+            .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]),
+                  sprintf("[id='%<id>s_%<suffix>s']", id: i,
+                                                      suffix: suffix))
+        end
+        style
+      end
+
+      def update_ids_attrs(document, ids, suffix)
+        suffix = suffix.is_a?(Integer) ? sprintf("%09d", suffix) : suffix
+        document.xpath(". | .//*[@*]").each do |a|
+          a.attribute_nodes.each do |x|
+            val = x.value.sub(/^#/, "")
+            ids.include?(val) and x.value += "_#{suffix}"
+            x.value = x.value.sub(%r{url\(#([^()]+)\)}, "url(#\\1_#{suffix})")
+          end
+        end
+      end
+    end
+
     def initialize(content)
       @document = Nokogiri::XML(content)
     end
@@ -33,8 +71,8 @@ module Vectory
       ids = collect_ids
       return if ids.empty?
 
-      update_ids_attrs(ids, suffix)
-      update_ids_css(ids, suffix)
+      self.class.update_ids_attrs(@document.root, ids, suffix)
+      self.class.update_ids_css(@document.root, ids, suffix)
 
       self
     end
@@ -50,27 +88,5 @@ module Vectory
     def collect_ids
       @document.xpath("./@id | .//@id").map(&:value)
     end
-
-    def update_ids_attrs(ids, suffix)
-      @document.xpath(". | .//*[@*]").each do |a|
-        a.attribute_nodes.each do |x|
-          ids.include?(x.value) and x.value += sprintf("_%09d", suffix)
-        end
-      end
-    end
-
-    def update_ids_css(ids, suffix)
-      @document.xpath("//m:style", "m" => SVG_NS).each do |s|
-        c = s.children.to_xml
-        ids.each do |i|
-          c = c.gsub(%r[##{i}\b],
-                     sprintf("#%<id>s_%<suffix>09d", id: i, suffix: suffix))
-            .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]),
-                  sprintf("[id='%<id>s_%<suffix>09d']", id: i, suffix: suffix))
-        end
-
-        s.children = c
-      end
-    end
   end
 end

data/lib/vectory/system_call.rb

@@ -7,15 +7,16 @@ module Vectory
 
     attr_reader :status, :stdout, :stderr, :cmd
 
-    def initialize(cmd, timeout = TIMEOUT)
+    def initialize(cmd, timeout = TIMEOUT, env: {})
       @cmd = cmd
       @timeout = timeout
+      @env = env
     end
 
     def call
       log_cmd(@cmd)
 
-      execute(@cmd)
+      execute(@cmd, @env)
 
       log_result
 
@@ -30,14 +31,26 @@ module Vectory
       Vectory.ui.debug("Cmd: '#{cmd}'")
     end
 
-    def execute(cmd)
-      result = Capture.with_timeout(cmd,
-                                    timeout: @timeout,
-                                    signal: :KILL, # only KILL works on Windows
-                                    kill_after: @timeout)
-      @stdout = result[:stdout]
-      @stderr = result[:stderr]
+    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
@@ -49,6 +62,20 @@ module Vectory
     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  " \