vectory 0.7.8 → 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

@@ -6,6 +6,7 @@ module Vectory
 
     def call(img, path, maxheight, maxwidth)
       s, realsize = get_image_size(img, path)
+      # Ensure s[0] and s[1] are not nil before setting viewBox
       img.name == "svg" && !img["viewBox"] && s[0] && s[1] and
         img["viewBox"] = viewbox(s)
       s, skip = image_dont_resize(s, realsize)
@@ -18,7 +19,8 @@ module Vectory
       detected = detect_size(path)
       realsize = detected if detected
       s = image_size_interpret(img, realsize || [nil, nil])
-      image_size_zeroes_complete(s, realsize)
+      # No call to image_size_zeroes_complete here
+      [s, realsize] # s should now be correctly populated
     end
 
     private
@@ -53,7 +55,11 @@ module Vectory
     end
 
     def fill_size(current, another, real_current, real_another)
-      return current unless current.zero? && !another.zero?
+      # Ensure 'current' and 'another' are not nil before calling zero?
+      # Also ensure real_another is not nil or zero to prevent division by zero
+      return current unless (current.nil? || current.zero?) &&
+        !(another.nil? || another.zero?) &&
+        !(real_another.nil? || real_another.zero?)
 
       another * real_current / real_another
     end
@@ -67,22 +73,102 @@ module Vectory
     end
 
     def image_size_interpret(img, realsize)
-      w = image_size_percent(img["width"], realsize[0])
-      h = image_size_percent(img["height"], realsize[1])
+      # Extract parent dimensions for percentage calculations
+      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
+      w = css_size_to_px(img["width"], parent_w_px)
+      h = css_size_to_px(img["height"], parent_h_px)
+
+      # If attributes resulted in no dimensions, but realsize exists, use realsize.
+      # This brings back some of the logic from the removed image_size_zeroes_complete.
+      if w.nil? && h.nil? && realsize && !(realsize[0].nil? && realsize[1].nil?)
+        w = realsize[0]
+        h = realsize[1]
+      end
+
+      # 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?
+        w = 0
+      end
+      if img["height"] && h.nil? && !w.nil?
+        h = 0
+      end
+
       [w, h]
     end
 
-    def image_size_percent(value, real)
-      /%$/.match?(value) && !real.nil? and
-        value = real * (value.sub(/%$/, "").to_f / 100)
-      value.to_i
+    # Enhanced version of image_size_percent that handles percentage calculations
+    # This is now a helper method for css_size_to_px
+    def image_size_percent(percentage_numeric_value, real_dimension)
+      return nil if real_dimension.nil? || percentage_numeric_value.nil?
+
+      # Calculates the dimension in pixels. The result is a float.
+      (real_dimension * (percentage_numeric_value / 100.0))
     end
 
-    def image_size_zeroes_complete(dim, realsize)
-      if dim[0].zero? && dim[1].zero?
-        dim = realsize
+    # New method from image_sizer.rb, incorporated directly into ImageResize
+    # Converts CSS length string to pixels.
+    def css_size_to_px(size_str, real_dimension_for_percentage, dpi: 96)
+      return nil unless size_str.is_a?(String)
+
+      cleaned_size_str = size_str.strip.downcase
+
+      # Handle keywords like "auto" which don't resolve to a numeric pixel value.
+      return nil if cleaned_size_str == "auto"
+
+      # Handle plain numbers (e.g., "150") as pixels.
+      if cleaned_size_str.match?(/^\d+(\.\d+)?$/)
+        return cleaned_size_str.to_f.to_i
+      end
+
+      # Match numeric value and unit (e.g., "10.5cm", "50%", "-5px").
+      match = cleaned_size_str.match(/^([-+]?[0-9]*\.?[0-9]+)([a-z%]+)$/)
+      unless match
+        # Not a plain number and not in "valueUnit" format
+        return nil
+      end
+
+      value = match[1].to_f
+      unit = match[2]
+      px_value = nil # This will store the calculated pixel value as a float.
+
+      case unit
+      when "px"
+        px_value = value
+      when "in"
+        px_value = value * dpi
+      when "cm"
+        px_value = value * dpi / 2.54
+      when "mm"
+        px_value = value * dpi / 25.4
+      when "pt" # 1 point = 1/72 inch
+        px_value = value * dpi / 72.0
+      when "pc" # 1 pica = 12 points
+        px_value = value * 12.0 * dpi / 72.0
+      when "%"
+        # Use the enhanced image_size_percent method
+        px_value = image_size_percent(value, real_dimension_for_percentage)
+      else
+        return nil # Unknown unit
+      end
+
+      return nil if px_value.nil?
+
+      # For 'px' and '%' units, truncate to match "integer conversion" expectation.
+      # For physical units, round to handle floating point inaccuracies correctly.
+      if ["px", "%"].include?(unit)
+        px_value.to_i
+      else
+        px_value.round
       end
-      [dim, realsize]
     end
+
+    # REMOVE the image_size_zeroes_complete method entirely if it's still present
+    # def image_size_zeroes_complete(dim, realsize)
+    #   ...
+    # end
   end
 end