vectory 0.8.0 → 0.8.1

data/lib/vectory/conversion.rb

@@ -0,0 +1,104 @@
+# 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
+  #
+  # This module encapsulates different conversion strategies for converting
+  # between vector formats using external tools like Inkscape and Ghostscript.
+  #
+  # @example Convert SVG to EPS using Inkscape
+  #   Vectory::Conversion.convert(svg_content, from: :svg, to: :eps)
+  #
+  # @example Get available strategies for a conversion
+  #   Vectory::Conversion.strategies_for(:svg, :eps)
+  module Conversion
+    class << self
+      # Convert content from one format to another
+      #
+      # Automatically selects the appropriate strategy based on the input/output formats.
+      #
+      # @param content [String] the content to convert
+      # @param from [Symbol] the input format
+      # @param to [Symbol] the output format
+      # @param options [Hash] additional options passed to the strategy
+      # @return [Vectory::Vector, String] the converted result
+      # @raise [Vectory::ConversionError] if no strategy supports the conversion
+      def convert(content, from:, to:, **options)
+        strategy = find_strategy(from, to)
+
+        unless strategy
+          supported = supported_conversions.map do |a, b|
+            "#{a} → #{b}"
+          end.join(", ")
+          raise Vectory::ConversionError,
+                "No strategy found for #{from} → #{to} conversion. " \
+                "Supported: #{supported}"
+        end
+
+        strategy.convert(content, input_format: from, output_format: to,
+                                  **options)
+      end
+
+      # Get all available strategies
+      #
+      # @return [Array<Vectory::Conversion::Strategy>] all registered strategies
+      def strategies
+        @strategies ||= [
+          InkscapeStrategy.new,
+          GhostscriptStrategy.new,
+        ]
+      end
+
+      # Get strategies that support a specific conversion
+      #
+      # @param input_format [Symbol] the input format
+      # @param output_format [Symbol] the output format
+      # @return [Array<Vectory::Conversion::Strategy>] matching strategies
+      def strategies_for(input_format, output_format)
+        strategies.select { |s| s.supports?(input_format, output_format) }
+      end
+
+      # Check if a conversion is supported
+      #
+      # @param input_format [Symbol] the input format
+      # @param output_format [Symbol] the output format
+      # @return [Boolean] true if any strategy supports this conversion
+      def supports?(input_format, output_format)
+        strategies_for(input_format, output_format).any?
+      end
+
+      # Get all supported conversions
+      #
+      # @return [Array<Array<Symbol>>] array of [input, output] format pairs
+      def supported_conversions
+        @supported_conversions ||= strategies.flat_map(&:supported_conversions).uniq
+      end
+
+      # Check if a specific tool is available
+      #
+      # @param tool [Symbol, String] the tool name (:inkscape, :ghostscript, etc.)
+      # @return [Boolean] true if the tool is available
+      def tool_available?(tool)
+        strategy = strategies.find { |s| s.tool_name == tool.to_s.downcase }
+        strategy&.available? || false
+      end
+
+      private
+
+      # Find a strategy for the given conversion
+      #
+      # @param input_format [Symbol] the input format
+      # @param output_format [Symbol] the output format
+      # @return [Vectory::Conversion::Strategy, nil] the strategy or nil if not found
+      def find_strategy(input_format, output_format)
+        strategies.find do |strategy|
+          strategy.supports?(input_format, output_format) && strategy.available?
+        end
+      end
+    end
+  end
+end

data/lib/vectory/datauri.rb

@@ -8,7 +8,7 @@ module Vectory
       (?:charset=[^;]+;)?
       base64,
       (?<data>.+)
-    $}x.freeze
+    $}x
 
     def self.from_vector(vector)
       mimetype = vector.class.mimetype

data/lib/vectory/emf.rb

@@ -28,19 +28,31 @@ module Vectory
     end
 
     def to_svg
-      with_file("emf") do |input_path|
-        content = Emf2svg.from_file(input_path)
+      Dir.mktmpdir do |dir|
+        input_path = File.join(dir, "image.emf")
+        File.binwrite(input_path, content)
 
-        Svg.from_content(content)
+        svg_content = Emf2svg.from_file(input_path)
+        Svg.from_content(svg_content)
       end
     end
 
     def to_eps
-      convert_with_inkscape("--export-type=eps", Eps)
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :emf,
+        output_format: :eps,
+        output_class: Eps,
+      )
     end
 
     def to_ps
-      convert_with_inkscape("--export-type=ps", Ps)
+      InkscapeWrapper.convert(
+        content: content,
+        input_format: :emf,
+        output_format: :ps,
+        output_class: Ps,
+      )
     end
   end
 end

data/lib/vectory/eps.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "ghostscript_wrapper"
+require_relative "pdf"
+
 module Vectory
   class Eps < Vector
     def self.default_extension
@@ -20,19 +23,58 @@ module Vectory
     end
 
     def to_ps
-      convert_with_inkscape("--export-type=ps", Ps)
+      to_pdf.to_ps
     end
 
     def to_svg
-      convert_with_inkscape("--export-plain-svg --export-type=svg", Svg)
+      to_pdf.to_svg
     end
 
     def to_emf
-      convert_with_inkscape("--export-type=emf", Emf)
+      to_pdf.to_emf
+    end
+
+    def to_pdf
+      pdf_content = GhostscriptWrapper.convert(content, eps_crop: true)
+      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
+
     def imgfile_suffix(uri, suffix)
       "#{File.join(File.dirname(uri), File.basename(uri, '.*'))}.#{suffix}"
     end

data/lib/vectory/errors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Vectory
+  class ConversionError < Error; end
+
+  class InkscapeNotFoundError < Error
+    def initialize(msg = nil)
+      super(msg || "Inkscape not found in PATH. Please install Inkscape.")
+    end
+  end
+
+  class GhostscriptNotFoundError < Error
+    def initialize(msg = nil)
+      super(msg || "Ghostscript not found in PATH. Please install Ghostscript.")
+    end
+  end
+
+  class InkscapeQueryError < Error; end
+
+  class InvalidFormatError < Error
+    def initialize(format, supported_formats)
+      super("Invalid format '#{format}'. Supported formats: #{supported_formats.join(', ')}")
+    end
+  end
+end

data/lib/vectory/file_magic.rb

@@ -35,7 +35,7 @@ module Vectory
       emf_slice = beginning.byteslice(0, EMF_MAGIC.size)
       return :emf if emf_slice == EMF_MAGIC
 
-      return :svg if contain_svg_tag?
+      :svg if contain_svg_tag?
     end
 
     private
@@ -47,7 +47,7 @@ module Vectory
     def contain_svg_tag?
       content = File.read(@path, 4096)
 
-      return :svg if content.include?("<svg")
+      :svg if content.include?("<svg")
     end
   end
 end

data/lib/vectory/ghostscript_wrapper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "fileutils"
+require_relative "errors"
+require_relative "system_call"
+require_relative "platform"
+
+module Vectory
+  # GhostscriptWrapper converts PS and EPS files to PDF using Ghostscript
+  class GhostscriptWrapper
+    SUPPORTED_INPUT_FORMATS = %w[ps eps].freeze
+
+    class << self
+      def available?
+        ghostscript_path
+        true
+      rescue GhostscriptNotFoundError
+        false
+      end
+
+      def version
+        return nil unless available?
+
+        cmd = [ghostscript_path, "--version"]
+        call = SystemCall.new(cmd).call
+        call.stdout.strip
+      rescue StandardError
+        nil
+      end
+
+      def convert(content, options = {})
+        raise GhostscriptNotFoundError unless available?
+
+        eps_crop = options.fetch(:eps_crop, false)
+        input_ext = eps_crop ? ".eps" : ".ps"
+
+        # Create temporary input file
+        input_file = Tempfile.new(["gs_input", input_ext])
+        output_file = Tempfile.new(["gs_output", ".pdf"])
+
+        begin
+          # Write content and close the input file so GhostScript can read it
+          input_file.binmode
+          input_file.write(content)
+          input_file.flush
+          input_file.close
+
+          # 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)
+
+          call = nil
+          begin
+            call = SystemCall.new(cmd).call
+          rescue SystemCallError => e
+            raise ConversionError,
+                  "GhostScript conversion failed: #{e.message}"
+          end
+
+          unless File.exist?(output_file.path)
+            raise ConversionError,
+                  "GhostScript did not create output file: #{output_file.path}"
+          end
+
+          output_content = File.binread(output_file.path)
+
+          # Check if the PDF is valid (should be more than just the header)
+          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}'"
+          end
+
+          output_content
+        ensure
+          # Clean up temp files
+          input_file.close unless input_file.closed?
+          input_file.unlink
+          output_file.close unless output_file.closed?
+          output_file.unlink
+        end
+      end
+
+      private
+
+      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
+          end
+
+          # Then try PATH for Windows executables
+          ["gswin64c.exe", "gswin32c.exe", "gs"].each do |cmd|
+            path = find_in_path(cmd)
+            return path if path
+          end
+        else
+          # On Unix-like systems, check PATH
+          path = find_in_path("gs")
+          return path if path
+        end
+
+        raise GhostscriptNotFoundError
+      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
+
+        # 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
+      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
+      end
+    end
+  end
+end

data/lib/vectory/image_resize.rb

@@ -74,7 +74,7 @@ module Vectory
 
     def image_size_interpret(img, realsize)
       # Extract parent dimensions for percentage calculations
-      parent_w_px = realsize.is_a?(Array) && realsize.length > 0 ? realsize[0] : nil
+      parent_w_px = realsize.is_a?(Array) && realsize.length.positive? ? realsize[0] : nil
       parent_h_px = realsize.is_a?(Array) && realsize.length > 1 ? realsize[1] : nil
 
       # Process width and height using the original css_size_to_px signature
@@ -90,7 +90,7 @@ module Vectory
 
       # If a dimension attribute led to a nil value (e.g. "auto", or "%" of nil parent)
       # and the other dimension is resolved, default the nil dimension to 0.
-      if img["width"] && w.nil? && !h.nil? 
+      if img["width"] && w.nil? && !h.nil?
         w = 0
       end
       if img["height"] && h.nil? && !w.nil?

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