vectory 0.10.1 → 0.12.0

data/lib/vectory/inkscape_wrapper.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require "tmpdir"
-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
-
-    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,
-        )
-      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|
-        # 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, :height)
-    end
-
-    def width(content, format)
-      query_integer(content, format, :width)
-    end
-
-    private
-
-    # 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
-
-    # Build export parameters for Ukiryu
-    def build_export_params(input_path, output_path, output_format, plain)
-      params = {
-        inputs: [input_path],
-        output: output_path,
-      }
-
-      # 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
-
-      # Add plain SVG flag
-      params[:plain] = true if plain && output_format == :svg
-
-      # 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
-
-      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)]
-
-      paths = basenames.map do |basename|
-        "#{File.join(File.dirname(source_path), basename)}.#{output_extension}"
-      end
-
-      paths.find { |p| File.exist?(p) }
-    end
-
-    # Raise conversion error with details
-    def raise_conversion_error(result)
-      raise Vectory::ConversionError,
-            "Could not convert with Inkscape. " \
-            "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
-
-      with_temp_file(content, format) do |path|
-        params = { input: path, param_key => true }
-
-        result = tool.execute(:query,
-                              execution_timeout: Configuration.instance.timeout,
-                              **params)
-        raise_query_error(result) if result.stdout.empty?
-
-        result.stdout
-      end
-    end
-
-    # 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)
-
-        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)
-
-        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
-
-    # 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)
-
-      # 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
-
-      # 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
-
-    # Raise query error with details
-    def raise_query_error(result)
-      raise Vectory::InkscapeQueryError,
-            "Could not query with Inkscape. " \
-            "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
-    # 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

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-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 = convert_to_svg
-
-      # 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
-      with_inkscape_pdf_fallback(:eps, Eps)
-    end
-
-    def to_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: 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?
-        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
-
-    # 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
-      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

@@ -1,105 +0,0 @@
-# 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