safe_image 0.2.0 → 0.4.0

data/lib/safe_image/jpegli_backend.rb

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "pathname"
-require "tempfile"
-
 module SafeImage
   module JpegliBackend
     module_function
 
-    DIRECT_INPUTS = %w[png].freeze
+    DIRECT_INPUTS = Formats::CJPEGLI_DIRECT_INPUTS
     CHROMA_SUBSAMPLING = %w[420 422 444].freeze
-    DEFAULT_QUALITY = 85
+    DEFAULT_QUALITY = QualityDefaults::JPEG
 
     def available?
       Runner.available?("cjpegli")
     end
 
     def suitable_direct_input?(input)
-      DIRECT_INPUTS.include?(normalized_ext(input))
+      Formats.cjpegli_direct_input?(normalized_ext(input))
     end
 
     def convert(input:, output:, quality: DEFAULT_QUALITY, chroma_subsampling: :auto, timeout: Runner::DEFAULT_TIMEOUT)
@@ -28,16 +24,44 @@ module SafeImage
       ensure_jpeg_output!(output)
 
       input_format = normalized_ext(input)
-      unless DIRECT_INPUTS.include?(input_format)
+      if DIRECT_INPUTS.none? { |candidate| candidate == input_format }
         raise UnsupportedFormatError, "cjpegli direct input format is unsupported: #{input_format.inspect}"
       end
 
       quality = validate_quality!(quality)
       chroma_subsampling = validate_chroma_subsampling!(chroma_subsampling, input_format: input_format)
-      encode(input: input, output: output, quality: quality, chroma_subsampling: chroma_subsampling, timeout: timeout, input_format: input_format)
+      encode(
+        input: input,
+        output: output,
+        quality: quality,
+        chroma_subsampling: chroma_subsampling,
+        timeout: timeout,
+        input_format: input_format
+      )
+    end
+
+    def encode_generated_jpeg(output:, quality: DEFAULT_QUALITY, chroma_subsampling: :auto, input_format: nil)
+      StagedOutput.with_temp_path_near(output, suffix: ".safe-image.png") do |tmp_path|
+        decoded = yield tmp_path
+        source_format = input_format || decoded.fetch(:input_format)
+        encode(
+          input: tmp_path,
+          output: output,
+          quality: quality,
+          chroma_subsampling: validate_chroma_subsampling!(chroma_subsampling, input_format: source_format),
+          input_format: source_format
+        )
+      end
     end
 
-    def encode(input:, output:, quality: DEFAULT_QUALITY, chroma_subsampling: "420", timeout: Runner::DEFAULT_TIMEOUT, input_format: nil)
+    def encode(
+      input:,
+      output:,
+      quality: DEFAULT_QUALITY,
+      chroma_subsampling: "420",
+      timeout: Runner::DEFAULT_TIMEOUT,
+      input_format: nil
+    )
       raise UnsupportedFormatError, "cjpegli is not installed" unless available?
 
       input = PathSafety.ensure_regular_file!(input)
@@ -49,37 +73,32 @@ module SafeImage
       quality = validate_quality!(quality)
       chroma_subsampling = validate_chroma_subsampling!(chroma_subsampling, input_format: input_format)
 
-      tmp = Tempfile.new([output_path.basename(".*").to_s, ".cjpegli.jpg"], output_path.dirname.to_s)
-      tmp_path = Pathname.new(tmp.path)
-      tmp.close
-
-      begin
-        argv = [
-          "cjpegli",
-          input.to_s,
-          tmp_path.to_s,
-          "--quality=#{quality}",
-          "--chroma_subsampling=#{chroma_subsampling}"
-        ]
-        Runner.run!(argv, timeout: timeout, read: [input.to_s], write: [output_path.dirname.to_s])
-        raise Error, "cjpegli did not create output" unless tmp_path.file? && File.size(tmp_path).positive?
-        FileUtils.mv(tmp_path, output_path)
-
-        # cjpegli works without libvips; fall back to identify for the
-        # output dimensions when the native header read is unavailable.
-        info = VipsGlue.available? ? Native.probe(output_path.to_s) : ImageMagickBackend.probe(output_path.to_s)
-        {
-          input_format: input_format,
-          output_format: "jpg",
-          width: info.fetch(:width),
-          height: info.fetch(:height),
-          duration_ms: info.fetch(:duration_ms),
-          encoder: "cjpegli",
-          chroma_subsampling: chroma_subsampling
-        }
-      ensure
-        FileUtils.rm_f(tmp_path)
-      end
+      info =
+        StagedOutput.replace(output_path, suffix: ".cjpegli.jpg") do |tmp_path|
+          argv = [
+            "cjpegli",
+            input.to_s,
+            tmp_path.to_s,
+            "--quality=#{quality}",
+            "--chroma_subsampling=#{chroma_subsampling}"
+          ]
+          Runner.run!(argv, timeout: timeout, read: [input.to_s], write: [output_path.dirname.to_s])
+          raise Error, "cjpegli did not create output" unless tmp_path.file? && File.size(tmp_path).positive?
+
+          # cjpegli works without libvips in the Ruby process; fall back to
+          # identify when the helper/native header read is unavailable.
+          info = Native.available? ? Native.probe(tmp_path.to_s) : ImageMagickBackend.probe(tmp_path.to_s)
+          {
+            input_format: input_format,
+            output_format: "jpg",
+            width: info.fetch(:width),
+            height: info.fetch(:height),
+            duration_ms: info.fetch(:duration_ms),
+            encoder: "cjpegli",
+            chroma_subsampling: chroma_subsampling
+          }
+        end
+      info
     end
 
     def validate_quality!(quality)
@@ -94,7 +113,9 @@ module SafeImage
       value = "444" if value.to_sym == :auto && input_format.to_s == "png"
       value = "420" if value.to_sym == :auto
       value = value.to_s
-      raise ArgumentError, "chroma_subsampling must be one of #{CHROMA_SUBSAMPLING.join(", ")}" unless CHROMA_SUBSAMPLING.include?(value)
+      if CHROMA_SUBSAMPLING.none? { |candidate| candidate == value }
+        raise ArgumentError, "chroma_subsampling must be one of #{CHROMA_SUBSAMPLING.join(", ")}"
+      end
       value
     end
 
@@ -104,8 +125,7 @@ module SafeImage
     end
 
     def normalized_ext(path)
-      ext = File.extname(path.to_s).delete_prefix(".").downcase
-      ext == "jpeg" ? "jpg" : ext
+      Formats.extension(path)
     end
   end
 end

data/lib/safe_image/metadata_operations.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module SafeImage
+  # Inline implementations for local, read-only image metadata operations.
+  class MetadataOperations < OperationSet
+    def probe(path, max_pixels: nil)
+      path = PathSafety.local_path(path)
+      max_pixels = resolved_max_pixels(max_pixels)
+
+      case File.extname(path).downcase
+      when ".svg"
+        info = SvgMetadata.probe(path, max_pixels: max_pixels)
+        Result.metadata(
+          input: File.expand_path(path),
+          input_format: "svg",
+          width: info.fetch(:width),
+          height: info.fetch(:height),
+          backend: :svg_metadata,
+          duration_ms: info.fetch(:duration_ms)
+        )
+      when ".ico"
+        # Pure-Ruby directory parse; reports the largest entry's dimensions.
+        info = Ico.probe(path, max_pixels: max_pixels)
+        Result.metadata(
+          input: File.expand_path(path),
+          input_format: "ico",
+          width: info.fetch(:width),
+          height: info.fetch(:height),
+          backend: :ico_metadata,
+          duration_ms: info.fetch(:duration_ms)
+        )
+      else
+        case config.backend
+        when :vips
+          Processor.new(max_pixels: max_pixels, config: config).probe(path)
+        when :imagemagick
+          info = ImageMagickBackend.probe(path, max_pixels: max_pixels)
+          Result.metadata(
+            input: File.expand_path(path),
+            input_format: info.fetch(:input_format),
+            width: info.fetch(:width),
+            height: info.fetch(:height),
+            backend: :imagemagick,
+            duration_ms: info.fetch(:duration_ms)
+          )
+        end
+      end
+    end
+
+    def type(path, max_pixels: nil)
+      fastimage_type(probe(path, max_pixels: max_pixels).input_format)
+    end
+
+    def size(path, max_pixels: nil)
+      result = probe(path, max_pixels: max_pixels)
+      [result.width, result.height]
+    end
+
+    def dimensions(path, max_pixels: nil)
+      size(path, max_pixels: max_pixels)
+    end
+
+    def info(path, max_pixels: nil, animated: false, orientation: false)
+      result = probe(path, max_pixels: max_pixels)
+      type = fastimage_type(result.input_format)
+      Info.new(
+        path: result.input,
+        type: type,
+        width: result.width,
+        height: result.height,
+        size: [result.width, result.height],
+        animated: animated ? animated?(path, max_pixels: max_pixels) : nil,
+        orientation: orientation ? orientation(path, max_pixels: max_pixels) : nil
+      )
+    end
+
+    def orientation(path, max_pixels: nil)
+      case File.extname(PathSafety.local_path(path)).downcase
+      when ".svg", ".ico"
+        # No EXIF orientation in either format; upright by definition.
+        1
+      else
+        max_pixels = resolved_max_pixels(max_pixels)
+        case config.backend
+        when :vips
+          # Header-only native read.
+          VipsBackend.orientation(path, max_pixels: max_pixels)
+        when :imagemagick
+          # Probe first: rejects undecodable files and enforces the pixel cap.
+          ImageMagickBackend.probe(path, max_pixels: max_pixels)
+          ImageMagickBackend.orientation(path)
+        end
+      end
+    end
+
+    def dominant_color(path, max_pixels: nil)
+      max_pixels = resolved_max_pixels(max_pixels)
+      case config.backend
+      when :vips
+        if File.extname(PathSafety.local_path(path)).downcase == ".ico"
+          # The configured backend is vips; ICO bytes are decoded by the
+          # pure-Ruby parser and the extracted PNG is averaged by the vips helper.
+          vips_ico_dominant_color(path, max_pixels: max_pixels)
+        else
+          VipsBackend.dominant_color(path, max_pixels: max_pixels)
+        end
+      when :imagemagick
+        imagemagick_dominant_color(path, max_pixels: max_pixels)
+      end
+    end
+
+    def frame_count(path, max_pixels: nil)
+      backend.frame_count(path, max_pixels: max_pixels)
+    end
+
+    def animated?(path, max_pixels: nil)
+      return false if File.extname(PathSafety.local_path(path)).downcase == ".svg"
+
+      backend.frame_count(path, max_pixels: max_pixels).to_i > 1
+    end
+
+    def self.fastimage_type(format)
+      format.to_s == "jpg" ? :jpeg : format.to_s.to_sym
+    end
+
+    private
+
+    def vips_ico_dominant_color(path, max_pixels:)
+      Tempfile.create(%w[safe-image-ico .png]) do |tmp|
+        tmp.close
+        Ico.convert_to_png(path, tmp.path, max_pixels: max_pixels)
+        VipsBackend.dominant_color(tmp.path, max_pixels: max_pixels)
+      end
+    end
+
+    def imagemagick_dominant_color(path, max_pixels:)
+      # Probe first: rejects undecodable files and enforces the pixel cap before
+      # ImageMagick fully decodes the image to average it.
+      probe(path, max_pixels: max_pixels)
+      ImageMagickBackend.dominant_color(path)
+    end
+
+    def fastimage_type(format)
+      self.class.fastimage_type(format)
+    end
+
+    def backend
+      OperationBackends.for(config)
+    end
+  end
+
+  private_constant :MetadataOperations
+end