vectory 0.10.2 → 0.12.0

data/lib/vectory/conversion/inkscape_strategy.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Vectory
-  module Conversion
-    # Inkscape-based conversion strategy
-    #
-    # Handles conversions using Inkscape, including:
-    # - SVG ↔ EPS
-    # - SVG ↔ PS
-    # - SVG ↔ EMF
-    # - SVG ↔ PDF
-    # - EPS/PS → PDF
-    #
-    # @see https://inkscape.org/
-    class InkscapeStrategy < Strategy
-      # Inkscape supports bidirectional conversion with SVG as source/target
-      SUPPORTED_CONVERSIONS = [
-        %i[svg eps],
-        %i[svg ps],
-        %i[svg emf],
-        %i[svg pdf],
-        %i[eps svg],
-        %i[eps pdf],
-        %i[ps svg],
-        %i[ps pdf],
-        %i[pdf svg],
-        %i[emf svg],
-      ].freeze
-
-      # Convert content using Inkscape
-      #
-      # @param content [String] the input content to convert
-      # @param input_format [Symbol] the input format
-      # @param output_format [Symbol] the output format
-      # @param options [Hash] additional options
-      # @option options [Boolean] :plain export plain SVG (for SVG output)
-      # @option options [Class] :output_class the class to instantiate with result
-      # @return [Vectory::Vector] the converted vector object
-      # @raise [Vectory::InkscapeNotFoundError] if Inkscape is not available
-      def convert(content, input_format:, output_format:, **options)
-        output_class = options.fetch(:output_class) do
-          format_class(output_format)
-        end
-
-        InkscapeWrapper.convert(
-          content: content,
-          input_format: input_format,
-          output_format: output_format,
-          output_class: output_class,
-          plain: options[:plain] || false,
-        )
-      end
-
-      # Check if this conversion is supported
-      #
-      # @param input_format [Symbol] the input format
-      # @param output_format [Symbol] the output format
-      # @return [Boolean] true if Inkscape supports this conversion
-      def supports?(input_format, output_format)
-        SUPPORTED_CONVERSIONS.include?([input_format, output_format])
-      end
-
-      # Get supported conversions
-      #
-      # @return [Array<Array<Symbol>>] array of [input, output] format pairs
-      def supported_conversions
-        SUPPORTED_CONVERSIONS
-      end
-
-      # Check if Inkscape is available
-      #
-      # @return [Boolean] true if Inkscape can be found in PATH
-      def available?
-        InkscapeWrapper.instance.send(:inkscape_path)
-        true
-      rescue Vectory::InkscapeNotFoundError
-        false
-      end
-
-      # Get the tool name
-      #
-      # @return [String] "inkscape"
-      def tool_name
-        "inkscape"
-      end
-
-      # Query the width of content
-      #
-      # @param content [String] the vector content
-      # @param format [Symbol] the format of the content
-      # @return [Integer] the width in pixels
-      def width(content, format)
-        InkscapeWrapper.instance.width(content, format)
-      end
-
-      # Query the height of content
-      #
-      # @param content [String] the vector content
-      # @param format [Symbol] the format of the content
-      # @return [Integer] the height in pixels
-      def height(content, format)
-        InkscapeWrapper.instance.height(content, format)
-      end
-
-      private
-
-      # Get the Vectory class for a format
-      def format_class(format)
-        case format
-        when :svg then Vectory::Svg
-        when :eps then Vectory::Eps
-        when :ps then Vectory::Ps
-        when :emf then Vectory::Emf
-        when :pdf then Vectory::Pdf
-        else
-          raise ArgumentError, "Unsupported format: #{format}"
-        end
-      end
-    end
-  end
-end

data/lib/vectory/conversion/strategy.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Vectory
-  module Conversion
-    # Base class for conversion strategies
-    #
-    # Conversion strategies encapsulate the logic for converting between
-    # different vector formats using external tools (Inkscape, Ghostscript, etc.)
-    #
-    # @abstract Subclasses must implement the {#convert} method
-    class Strategy
-      # Convert content from one format to another
-      #
-      # @param content [String] the input content to convert
-      # @param input_format [Symbol] the input format (e.g., :svg, :eps, :ps)
-      # @param output_format [Symbol] the desired output format (e.g., :svg, :pdf, :eps)
-      # @param options [Hash] additional options for the conversion
-      # @return [String] the converted content
-      # @raise [Vectory::ConversionError] if conversion fails
-      # @abstract
-      def convert(content, input_format:, output_format:, **options)
-        raise NotImplementedError,
-              "#{self.class} must implement #convert method"
-      end
-
-      # Check if this strategy supports the given conversion
-      #
-      # @param input_format [Symbol] the input format
-      # @param output_format [Symbol] the output format
-      # @return [Boolean] true if this strategy supports the conversion
-      def supports?(input_format, output_format)
-        supported_conversions.include?([input_format, output_format])
-      end
-
-      # Get the list of conversions this strategy supports
-      #
-      # @return [Array<Array<Symbol>>] array of [input, output] format pairs
-      def supported_conversions
-        []
-      end
-
-      # Check if the required external tool is available
-      #
-      # @return [Boolean] true if the tool is available
-      def available?
-        raise NotImplementedError,
-              "#{self.class} must implement #available? method"
-      end
-
-      # Get the name of the external tool used by this strategy
-      #
-      # @return [String] the tool name
-      def tool_name
-        self.class.name.split("::").last.gsub(/Strategy$/, "").downcase
-      end
-    end
-  end
-end

data/lib/vectory/conversion.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-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
-    # 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
-      #
-      # 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/ghostscript_wrapper.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-require "fileutils"
-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_tool
-        true
-      rescue GhostscriptNotFoundError
-        false
-      end
-
-      def version
-        return nil unless available?
-
-        tool = ghostscript_tool
-        tool.version
-      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
-
-          # Get the tool and execute
-          tool = ghostscript_tool
-          params = build_convert_params(input_file.path, output_file.path,
-                                        eps_crop: eps_crop)
-
-          result = tool.execute(:convert,
-                                execution_timeout: Configuration.instance.timeout,
-                                **params)
-
-          unless result.success?
-            raise ConversionError,
-                  "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)
-            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: #{result.command}, " \
-                  "stdout: '#{result.stdout.strip}', " \
-                  "stderr: '#{result.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
-
-      # 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
-
-          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
-
-          unless File.exist?(output_file.path)
-            raise ConversionError,
-                  "GhostScript did not create output file: #{output_file.path}"
-          end
-
-          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
-
-      private
-
-      # 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
-
-      # 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
-end

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