vectory 0.10.1 → 0.12.0

data/lib/vectory/conversion/ghostscript_strategy.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -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