vectory 0.8.0 → 0.8.1

data/lib/vectory/capture.rb

@@ -3,15 +3,16 @@ require "timeout"
 module Vectory
   module Capture
     class << self
-      # rubocop:disable all
-      #
-      # Originally from https://gist.github.com/pasela/9392115
-      #
+      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 = capture3_with_timeout([env,] cmd... [, opts])
+      #   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]
@@ -39,12 +40,19 @@ module Vectory
       #   }
       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) || :TERM,
-          :kill_after => spawn_opts.delete(:kill_after),
+          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
@@ -63,53 +71,173 @@ module Vectory
         spawn_opts[:err] = err_w
 
         result = {
-          :pid     => nil,
-          :status  => nil,
-          :stdout  => nil,
-          :stderr  => nil,
-          :timeout => false,
+          pid: nil,
+          status: nil,
+          stdout: "",
+          stderr: "",
+          timeout: false,
         }
 
         out_reader = nil
         err_reader = nil
         wait_thr = nil
+        watchdog = nil
 
         begin
-          Timeout.timeout(opts[:timeout]) do
-            result[:pid] = spawn(*cmd, spawn_opts)
-            wait_thr = Process.detach(result[:pid])
-            in_r.close
-            out_w.close
-            err_w.close
+          # 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
 
-            out_reader = Thread.new { out_r.read }
-            err_reader = Thread.new { err_r.read }
+          # 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
 
-            result[:status] = wait_thr.value
+                # 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
-        rescue Timeout::Error
-          result[:timeout] = true
-          pid = spawn_opts[:pgroup] ? -result[:pid] : result[:pid]
-          Process.kill(opts[:signal], pid)
-          if opts[:kill_after]
-            unless wait_thr.join(opts[:kill_after])
-              Process.kill(:KILL, pid)
+
+          # 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
-          result[:status] = wait_thr.value if wait_thr
-          result[:stdout] = out_reader.value if out_reader
-          result[:stderr] = err_reader.value if err_reader
-          out_r.close unless out_r.closed?
-          err_r.close unless err_r.closed?
+          # 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
-      # rubocop:enable all
     end
   end
 end

data/lib/vectory/cli.rb

@@ -12,10 +12,12 @@ module Vectory
     STATUS_SYSTEM_CALL_ERROR = 5
     STATUS_INKSCAPE_NOT_FOUND_ERROR = 6
     STATUS_SAME_FORMAT_ERROR = 7
+    STATUS_GHOSTSCRIPT_NOT_FOUND_ERROR = 8
 
     MAP_ERROR_TO_STATUS = {
       Vectory::ConversionError => STATUS_CONVERSION_ERROR,
       Vectory::InkscapeNotFoundError => STATUS_INKSCAPE_NOT_FOUND_ERROR,
+      Vectory::GhostscriptNotFoundError => STATUS_GHOSTSCRIPT_NOT_FOUND_ERROR,
       Vectory::SystemCallError => STATUS_SYSTEM_CALL_ERROR,
     }.freeze
 

data/lib/vectory/configuration.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Vectory
+  # Configuration for Vectory
+  #
+  # Provides centralized configuration for tool paths, timeouts, caching, etc.
+  # Can be loaded from environment variables or a configuration file.
+  #
+  # @example Set custom Inkscape path
+  #   Vectory::Configuration.instance.inkscape_path = "/path/to/inkscape"
+  #
+  # @example Load from environment variables
+  #   # Set VECTORY_INKSCAPE_PATH environment variable
+  #   Vectory::Configuration.load_from_environment
+  class Configuration
+    # Default timeout for external tool execution (seconds)
+    DEFAULT_TIMEOUT = 120
+
+    # Default cache TTL for memoized values (seconds)
+    DEFAULT_CACHE_TTL = 300
+
+    # Default temporary directory
+    DEFAULT_TEMP_DIR = nil # Use system default
+
+    attr_accessor :inkscape_path, :ghostscript_path, :timeout, :cache_ttl,
+                  :cache_enabled, :temp_dir, :verbose_logging
+
+    # Get the singleton instance
+    #
+    # @return [Vectory::Configuration] the configuration instance
+    def self.instance
+      @instance ||= new
+    end
+
+    # Reset the configuration to defaults
+    #
+    # @api private
+    def self.reset!
+      @instance = new
+    end
+
+    # Initialize configuration with default values
+    def initialize
+      @timeout = DEFAULT_TIMEOUT
+      @cache_ttl = DEFAULT_CACHE_TTL
+      @cache_enabled = true
+      @temp_dir = DEFAULT_TEMP_DIR
+      @verbose_logging = false
+      @inkscape_path = nil
+      @ghostscript_path = nil
+    end
+
+    # Load configuration from environment variables
+    #
+    # Supported environment variables:
+    # - VECTORY_INKSCAPE_PATH: Path to Inkscape executable
+    # - VECTORY_GHOSTSCRIPT_PATH: Path to Ghostscript executable
+    # - VECTORY_TIMEOUT: Timeout for external tools (default: 120)
+    # - VECTORY_CACHE_TTL: Cache TTL in seconds (default: 300)
+    # - VECTORY_CACHE_ENABLED: Enable/disable caching (default: true)
+    # - VECTORY_TEMP_DIR: Temporary directory path
+    # - VECTORY_VERBOSE: Enable verbose logging (default: false)
+    #
+    # @return [self] the configuration instance
+    def self.load_from_environment
+      config = instance
+
+      config.inkscape_path = ENV["VECTORY_INKSCAPE_PATH"] if ENV["VECTORY_INKSCAPE_PATH"]
+      config.ghostscript_path = ENV["VECTORY_GHOSTSCRIPT_PATH"] if ENV["VECTORY_GHOSTSCRIPT_PATH"]
+      config.timeout = ENV["VECTORY_TIMEOUT"]&.to_i || config.timeout
+      config.cache_ttl = ENV["VECTORY_CACHE_TTL"]&.to_i || config.cache_ttl
+      config.cache_enabled = ENV["VECTORY_CACHE_ENABLED"] != "false"
+      config.temp_dir = ENV["VECTORY_TEMP_DIR"] if ENV["VECTORY_TEMP_DIR"]
+      config.verbose_logging = ENV["VECTORY_VERBOSE"] == "true"
+
+      config
+    end
+
+    # Load configuration from a YAML file
+    #
+    # @param path [String] path to the YAML configuration file
+    # @return [self] the configuration instance
+    # @raise [Errno::ENOENT] if the file doesn't exist
+    def self.load_from_file(path)
+      require "yaml"
+      config_data = YAML.load_file(path)
+
+      config = instance
+      config.inkscape_path = config_data["inkscape_path"] if config_data["inkscape_path"]
+      config.ghostscript_path = config_data["ghostscript_path"] if config_data["ghostscript_path"]
+      config.timeout = config_data["timeout"] || config.timeout
+      config.cache_ttl = config_data["cache_ttl"] || config.cache_ttl
+      config.cache_enabled = config_data.fetch("cache_enabled",
+                                               config.cache_enabled)
+      config.temp_dir = config_data["temp_dir"] || config.temp_dir
+      config.verbose_logging = config_data.fetch("verbose_logging",
+                                                 config.verbose_logging)
+
+      config
+    end
+
+    # Export configuration as a hash
+    #
+    # @return [Hash] the configuration as a hash
+    def to_h
+      {
+        inkscape_path: @inkscape_path,
+        ghostscript_path: @ghostscript_path,
+        timeout: @timeout,
+        cache_ttl: @cache_ttl,
+        cache_enabled: @cache_enabled,
+        temp_dir: @temp_dir,
+        verbose_logging: @verbose_logging,
+      }
+    end
+
+    # Get the Inkscape path (custom or auto-detected)
+    #
+    # @return [String, nil] the configured Inkscape path or nil if not set
+    def effective_inkscape_path
+      @inkscape_path
+    end
+
+    # Get the Ghostscript path (custom or auto-detected)
+    #
+    # @return [String, nil] the configured Ghostscript path or nil if not set
+    def effective_ghostscript_path
+      @ghostscript_path
+    end
+
+    # Check if caching is enabled
+    #
+    # @return [Boolean] true if caching is enabled
+    def caching_enabled?
+      @cache_enabled
+    end
+
+    # Get the temporary directory
+    #
+    # @return [String] the temporary directory path
+    def temporary_directory
+      @temp_dir || Dir.tmpdir
+    end
+
+    # Check if verbose logging is enabled
+    #
+    # @return [Boolean] true if verbose logging is enabled
+    def verbose_logging?
+      @verbose_logging
+    end
+
+    # Validate the configuration
+    #
+    # @return [Boolean] true if configuration is valid
+    # @raise [ArgumentError] if configuration is invalid
+    def validate!
+      errors = []
+
+      if @timeout && @timeout <= 0
+        errors << "timeout must be positive, got: #{@timeout}"
+      end
+
+      if @cache_ttl&.negative?
+        errors << "cache_ttl must be non-negative, got: #{@cache_ttl}"
+      end
+
+      if @temp_dir && !File.directory?(@temp_dir)
+        errors << "temp_dir does not exist: #{@temp_dir}"
+      end
+
+      return true if errors.empty?
+
+      raise ArgumentError,
+            "Invalid configuration:\n  - #{errors.join("\n  - ")}"
+    end
+  end
+end

data/lib/vectory/conversion/ghostscript_strategy.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../ghostscript_wrapper"
+require_relative "strategy"
+
+module Vectory
+  module Conversion
+    # Ghostscript-based conversion strategy
+    #
+    # Handles PS/EPS → PDF conversions using Ghostscript.
+    # Ghostscript is used for its accurate BoundingBox preservation.
+    #
+    # @see https://www.ghostscript.com/
+    class GhostscriptStrategy < Strategy
+      # Ghostscript supports PS/EPS → PDF conversions
+      SUPPORTED_CONVERSIONS = [
+        %i[ps pdf],
+        %i[eps pdf],
+      ].freeze
+
+      # Convert PS/EPS content to PDF using Ghostscript
+      #
+      # @param content [String] the PS/EPS content to convert
+      # @param input_format [Symbol] the input format (:ps or :eps)
+      # @param output_format [Symbol] the output format (must be :pdf)
+      # @param options [Hash] additional options
+      # @option options [Boolean] :eps_crop use EPSCrop for better BoundingBox handling
+      # @return [String] the PDF content
+      # @raise [Vectory::GhostscriptNotFoundError] if Ghostscript is not available
+      # @raise [Vectory::ConversionError] if conversion fails
+      def convert(content, input_format:, output_format:, **options)
+        unless output_format == :pdf
+          raise ArgumentError,
+                "Ghostscript only supports PDF output, got: #{output_format}"
+        end
+
+        unless %i[ps eps].include?(input_format)
+          raise ArgumentError,
+                "Ghostscript only supports PS/EPS input, got: #{input_format}"
+        end
+
+        GhostscriptWrapper.convert(content,
+                                   eps_crop: options[:eps_crop] || 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 Ghostscript 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 Ghostscript is available
+      #
+      # @return [Boolean] true if Ghostscript can be found
+      def available?
+        GhostscriptWrapper.available?
+      end
+
+      # Get the tool name
+      #
+      # @return [String] "ghostscript"
+      def tool_name
+        "ghostscript"
+      end
+    end
+  end
+end

data/lib/vectory/conversion/inkscape_strategy.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../inkscape_wrapper"
+require_relative "strategy"
+
+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

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