dynamic_image 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd1d723cd97a91199630354e541d2a740aa41bae8ccb07554c1e723096a1b6dc
-  data.tar.gz: b4f5a8bf26b69da95543cb8885f5add2b72504ea88f83c4097bc1c25a13c622f
+  metadata.gz: d9d7c5e9f872a132439d46c725089651caee0b684a52b425c2e572026e733bd0
+  data.tar.gz: 787251fd6c8d096cb1a918bf8667b482d92a59aec19dd3b8420a2e22b3dcce69
 SHA512:
-  metadata.gz: e2ba7e0be3c929f9da2b1c7311ae7a246341f081cc8057e8293417a8a73634ec5844d0ce7a691c3d5c771d99924b311c59a2a9b9bf2e2baae84675a3967a8614
-  data.tar.gz: '08cfc8124f2d6e2bd9d505315b1af7ed87e42ae4ff497a88fafd240e9594943721a6f72e7f196d5dffb1a43a1c8489e9b1b427e4042e149aedcf21a22f0506ba'
+  metadata.gz: 442830ff44a5ea152920a483985dd0b737599ef9c68a07da4f677eb1de366ce3cb6a55acf4a9de2a59441b14c901d45ec3d8e71b846169895ca8913fae2b04ed
+  data.tar.gz: '079bd5660c3109a67ae5ad616fd0ddbd6c1102ecee17e9a9ca1d57a555d21cc64bc8e30228be4edd12a64e7cba69d8d0739f58e275396c53d7d6351cf8c00bb3'

data/README.md

@@ -3,7 +3,7 @@
 [![Code Climate](https://codeclimate.com/github/elektronaut/dynamic_image/badges/gpa.svg)](https://codeclimate.com/github/elektronaut/dynamic_image)
 [![Code Climate](https://codeclimate.com/github/elektronaut/dynamic_image/badges/coverage.svg)](https://codeclimate.com/github/elektronaut/dynamic_image)
 [![Inline docs](http://inch-ci.org/github/elektronaut/dynamic_image.svg)](http://inch-ci.org/github/elektronaut/dynamic_image)
-[![Security](https://hakiri.io/github/elektronaut/dynamic_image/master.svg)](https://hakiri.io/github/elektronaut/dynamic_image/master)
+[![Security](https://hakiri.io/github/elektronaut/dynamic_image/main.svg)](https://hakiri.io/github/elektronaut/dynamic_image/main)
 
 # DynamicImage
 
@@ -21,17 +21,16 @@ images will be converted to RGB, and RGB images will be converted to the sRGB
 colorspace for consistent appearance in all browsers.
 
 DynamicImage is built on [Dis](https://github.com/elektronaut/dis)
-and [MiniMagick](https://github.com/minimagick/minimagick).
+and [ruby-vips](https://github.com/libvips/ruby-vips).
 
 All URLs are signed with a HMAC to protect against denial of service
 and enumeration attacks.
 
 ## Requirements
 
-* Rails 5
-* Ruby 2.4+
-* ImageMagick command line tools
-* ExifTool
+* Rails 5+
+* Ruby 2.7+
+* libvips 8.8+
 
 ## Documentation
 
@@ -42,7 +41,7 @@ and enumeration attacks.
 Add the gem to your Gemfile and run `bundle install`.
 
 ```ruby
-gem "dynamic_image", "~> 2.0.0"
+gem "dynamic_image", "~> 3.0"
 ```
 
 Run the `dis:install` generator to set up your storage.

data/lib/dynamic_image.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-require "mini_exiftool"
-require "mini_magick"
 require "dis"
 require "vector2d"
+require "vips"
 
 require "dynamic_image/belongs_to"
 require "dynamic_image/controller"
 require "dynamic_image/digest_verifier"
 require "dynamic_image/engine"
 require "dynamic_image/errors"
+require "dynamic_image/format"
 require "dynamic_image/helper"
+require "dynamic_image/image_processor"
 require "dynamic_image/image_reader"
 require "dynamic_image/image_sizing"
 require "dynamic_image/jobs"
@@ -20,5 +21,5 @@ require "dynamic_image/processed_image"
 require "dynamic_image/routing"
 
 module DynamicImage
-  cattr_accessor :digest_verifier, :process_later_limit
+  cattr_accessor :digest_verifier
 end

data/lib/dynamic_image/controller.rb

@@ -33,7 +33,7 @@ module DynamicImage
     end
 
     def download
-      render_raw_image(disposition: "attachment", filename: @record.filename)
+      render_raw_image(disposition: "attachment")
     end
 
     # Returns the requested size as a vector.
@@ -44,19 +44,31 @@ module DynamicImage
     private
 
     def cache_expiration_header
-      expires_in 30.days, public: true if response.status == 200
+      return unless response.status == 200
+
+      response.headers["Cache-Control"] = "max-age=#{1.year}, public"
+      expires_in 1.year, public: true
     end
 
     def find_record
       @record = model.find(params[:id])
     end
 
-    def process_later?(processed_image, size)
-      return false unless DynamicImage.process_later_limit
+    def filename(format = nil)
+      if format.is_a?(DynamicImage::Format)
+        File.basename(@record.filename, ".*") + format.extension
+      else
+        filename(DynamicImage::Format.find(format) ||
+                 DynamicImage::Format.content_type(@record.content_type))
+      end
+    end
 
-      image_size = processed_image.record.size.x * processed_image.record.size.y
-      image_size > DynamicImage.process_later_limit &&
-        !processed_image.find_variant(size)
+    def process_and_send(image, options)
+      processed_image = DynamicImage::ProcessedImage.new(image, options)
+      send_data(processed_image.cropped_and_resized(requested_size),
+                filename: filename(processed_image.format),
+                content_type: processed_image.format.content_type,
+                disposition: "inline")
     end
 
     def render_image(options)
@@ -64,16 +76,16 @@ module DynamicImage
 
       respond_to do |format|
         format.html do
-          render(file: File.join(File.dirname(__FILE__), "templates/show"),
+          render(template: "dynamic_image/images/show",
                  layout: false, locals: { options: options })
         end
         format.any(:gif, :jpeg, :jpg, :png, :tiff, :webp) do
-          send_image(@record, options)
+          process_and_send(@record, options)
         end
       end
     end
 
-    def render_raw_image(disposition: "inline", filename: nil)
+    def render_raw_image(disposition: "inline")
       return unless stale?(@record)
 
       respond_to do |format|
@@ -90,19 +102,6 @@ module DynamicImage
       params[:format]
     end
 
-    def send_image(image, options)
-      processed_image = DynamicImage::ProcessedImage.new(image, options)
-      if process_later?(processed_image, requested_size)
-        DynamicImage::Jobs::CreateVariant
-          .perform_later(image, options, requested_size.to_s)
-        head 503, retry_after: 10
-      else
-        send_data(processed_image.cropped_and_resized(requested_size),
-                  content_type: processed_image.content_type,
-                  disposition: "inline")
-      end
-    end
-
     def verify_signed_params
       key = %i[action id size].map do |k|
         k == :id ? params.require(k).to_i : params.require(k)

data/lib/dynamic_image/errors.rb

@@ -3,11 +3,17 @@
 module DynamicImage
   module Errors
     class Error < StandardError; end
+
     class InvalidImage < DynamicImage::Errors::Error; end
+
     class InvalidHeader < DynamicImage::Errors::Error; end
+
     class InvalidSignature < DynamicImage::Errors::Error; end
+
     class InvalidSizeOptions < DynamicImage::Errors::Error; end
+
     class InvalidTransformation < DynamicImage::Errors::Error; end
+
     class ParameterMissing < DynamicImage::Errors::Error; end
   end
 end

data/lib/dynamic_image/format.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module DynamicImage
+  class Format
+    attr_reader :name, :animated, :content_types, :extensions, :magic_bytes,
+                :save_options
+
+    def initialize(name, options)
+      options = default_options.merge(options)
+
+      @name = name
+      @animated = options[:animated]
+      @content_types = Array(options[:content_type])
+      @extensions = Array(options[:extension])
+      @magic_bytes = options[:magic_bytes].map do |s|
+        s.dup.force_encoding("binary")
+      end
+      @save_options = options[:save_options]
+    end
+
+    def animated?
+      animated
+    end
+
+    def content_type
+      content_types.first
+    end
+
+    def extension
+      extensions.first
+    end
+
+    class << self
+      def content_type(type)
+        formats.filter { |f| f.content_types.include?(type) }.first
+      end
+
+      def content_types
+        formats.flat_map(&:content_types)
+      end
+
+      def find(name)
+        key = name.to_s.upcase
+        key = "JPEG" if key == "JPG"
+        registered_formats[key]
+      end
+
+      def formats
+        registered_formats.map { |_, f| f }
+      end
+
+      def register(name, **opts)
+        registered_formats[name] = new(name, opts)
+      end
+
+      def sniff(bytes)
+        return unless bytes
+
+        formats.each do |format|
+          format.magic_bytes.each do |b|
+            return format if bytes.start_with?(b)
+          end
+        end
+        nil
+      end
+
+      private
+
+      def registered_formats
+        @registered_formats ||= {}
+      end
+    end
+
+    def default_options
+      { animated: false, content_type: [], extension: [], magic_bytes: [],
+        save_options: {} }
+    end
+
+    register(
+      "BMP",
+      content_type: %w[image/bmp],
+      extension: %w[.bmp],
+      magic_bytes: ["\x42\x4d"]
+    )
+
+    register(
+      "GIF",
+      animated: true,
+      content_type: %w[image/gif],
+      extension: %w[.gif],
+      magic_bytes: %w[GIF87a GIF89a],
+      save_options: { optimize_gif_frames: true,
+                      optimize_gif_transparency: true }
+    )
+
+    register(
+      "JPEG",
+      content_type: %w[image/jpeg image/pjpeg],
+      extension: %w[.jpg .jpeg],
+      magic_bytes: ["\xff\xd8"],
+      save_options: { Q: 90, strip: true, background: [255.0, 255.0, 255.0] }
+    )
+
+    register(
+      "PNG",
+      content_type: %w[image/png],
+      extension: %w[.png],
+      magic_bytes: ["\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"]
+    )
+
+    register(
+      "TIFF",
+      content_type: %w[image/tiff],
+      extension: %w[.tiff .tif],
+      magic_bytes: ["\x49\x49\x2a\x00", "\x4d\x4d\x00\x2a"]
+    )
+
+    register(
+      "WEBP",
+      animated: true,
+      content_type: %w[image/webp],
+      extension: %w[.webp],
+      magic_bytes: ["\x52\x49\x46\x46"],
+      save_options: { Q: 90, strip: true }
+    )
+  end
+end

data/lib/dynamic_image/image_processor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "dynamic_image/image_processor/colors"
+require "dynamic_image/image_processor/frames"
+require "dynamic_image/image_processor/transform"
+
+module DynamicImage
+  # = ImageProcessor
+  #
+  # This is the image processing pipeline.
+  #
+  # ==== Example:
+  #
+  #   DynamicImage::ImageProcessor
+  #     .new(file)
+  #     .crop(crop_start, crop_size)
+  #     .resize(size)
+  #     .convert(:jpeg)
+  #     .read
+  class ImageProcessor
+    include DynamicImage::ImageProcessor::Colors
+    include DynamicImage::ImageProcessor::Frames
+    include DynamicImage::ImageProcessor::Transform
+
+    attr_reader :image, :target_format
+
+    def initialize(image, target_format: nil)
+      if image.is_a?(Vips::Image)
+        @image = image
+        @target_format = target_format
+      else
+        reader = DynamicImage::ImageReader.new(image)
+        @image = screen_profile(reader.read.autorot)
+        @target_format = reader.format
+      end
+    end
+
+    # Convert the image to a different format.
+    def convert(new_format)
+      unless new_format.is_a?(DynamicImage::Format)
+        new_format = DynamicImage::Format.find(new_format)
+      end
+      if frame_count > 1 && !new_format.animated?
+        self.class.new(extract_frame(0), target_format: new_format)
+      else
+        self.class.new(image, target_format: new_format)
+      end
+    end
+
+    # Returns the image data as a binary string.
+    def read
+      tempfile = Tempfile.new(["dynamic_image", target_format.extension],
+                              binmode: true)
+      tempfile.close
+      write(tempfile.path)
+      tempfile.open
+      tempfile.read
+    ensure
+      tempfile.close
+    end
+
+    # Returns the image size as a Vector2d.
+    def size
+      Vector2d.new(
+        image.get("width"),
+        image.get(
+          image.get_fields.include?("page-height") ? "page-height" : "height"
+        )
+      )
+    end
+
+    # Write the image to a file.
+    def write(path)
+      image.write_to_file(path, **target_format.save_options)
+    end
+
+    private
+
+    def apply(new_image)
+      self.class.new(new_image, target_format: target_format)
+    end
+
+    def blank_image
+      image.draw_rect([0.0, 0.0, 0.0, 0.0],
+                      0, 0, image.get("width"), image.get("height"),
+                      fill: true)
+    end
+  end
+end

data/lib/dynamic_image/image_processor/colors.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module DynamicImage
+  class ImageProcessor
+    # = ImageProcessor::Colors
+    #
+    # Performs the necessary profile conversions on the image. All
+    # images are converted to the sRGB colorspace using either the
+    # embedded profile, or the built-in generic profile. Grayscale
+    # images are converted back to grayscale after processing.
+    module Colors
+      private
+
+      def icc_profile?(image)
+        image.get_fields.include?("icc-profile-data")
+      end
+
+      def icc_transform_srgb(image)
+        return image unless icc_profile?(image)
+
+        image.icc_transform("srgb", embedded: true, intent: :perceptual)
+      end
+
+      def screen_profile(image)
+        if !icc_profile?(image) && %i[rgb b-w].include?(image.interpretation)
+          return image
+        end
+
+        target_space = image.interpretation == :"b-w" ? "b-w" : "srgb"
+        icc_transform_srgb(image).colourspace(target_space)
+      end
+    end
+  end
+end

data/lib/dynamic_image/image_processor/frames.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module DynamicImage
+  class ImageProcessor
+    module Frames
+      # Extracts a single frame from a multi-frame image.
+      def frame(index)
+        apply extract_frame(index)
+      end
+
+      # Returns the number of frames.
+      def frame_count
+        image.get("height") / size.y
+      end
+
+      private
+
+      def each_frame(&block)
+        return apply(block.call(image)) unless frame_count > 1
+
+        apply(replace_frames(frames.map { |f| block.call(f) }))
+      end
+
+      def extract_frame(index)
+        image.extract_area(0, (index * size.y), size.x, size.y)
+      end
+
+      def frames
+        frame_count.times.map { |i| extract_frame(i) }
+      end
+
+      def replace_frames(new_frames)
+        new_size = Vector2d(new_frames.first.size)
+        new_image = blank_image.insert(
+          Vips::Image.arrayjoin(new_frames, across: 1),
+          0, 0, expand: true
+        ).extract_area(0, 0, new_size.x, new_size.y * frame_count).copy
+        new_image.set("page-height", new_size.y)
+        new_image
+      end
+    end
+  end
+end

data/lib/dynamic_image/image_processor/transform.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DynamicImage
+  class ImageProcessor
+    module Transform
+      # Crops the image
+      def crop(crop_size, crop_start)
+        return self if crop_start == Vector2d(0, 0) && crop_size == size
+
+        unless valid_crop?(crop_start, crop_size)
+          raise DynamicImage::Errors::InvalidTransformation,
+                "crop size is out of bounds"
+        end
+
+        each_frame do |frame|
+          frame.crop(crop_start.x, crop_start.y, crop_size.x, crop_size.y)
+        end
+      end
+
+      # Resize the image to a new size.
+      def resize(new_size)
+        new_size = Vector2d(new_size)
+        apply image.thumbnail_image(new_size.x.to_i,
+                                    height: new_size.y.to_i,
+                                    crop: :none,
+                                    size: :both)
+      end
+
+      # Rotates the image. The rotation must be a multiple of 90 degrees.
+      def rotate(degrees)
+        degrees = degrees.to_i % 360
+        return self if degrees.zero?
+
+        if (degrees % 90).nonzero?
+          raise DynamicImage::Errors::InvalidTransformation,
+                "angle must be a multiple of 90 degrees"
+        end
+
+        each_frame { |frame| frame.rotate(degrees) }
+      end
+
+      private
+
+      def valid_crop?(crop_start, crop_size)
+        bounds = crop_start + crop_size
+        bounds.x <= size.x && bounds.y <= size.y
+      end
+    end
+  end
+end

data/lib/dynamic_image/image_reader.rb

@@ -2,54 +2,49 @@
 
 module DynamicImage
   class ImageReader
-    class << self
-      def magic_bytes
-        @magic_bytes ||= [
-          "\x47\x49\x46\x38\x37\x61",         # GIF
-          "\x47\x49\x46\x38\x39\x61",
-          "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a", # PNG
-          "\xff\xd8",                         # JPEG
-          "\x49\x49\x2a\x00",                 # TIFF
-          "\x4d\x4d\x00\x2a",
-          "\x42\x4d",                         # BMP
-          "\x52\x49\x46\x46"                  # WEBP
-        ].map { |s| s.dup.force_encoding("binary") }
-      end
-    end
-
     def initialize(data)
       @data = data
     end
 
-    def exif
-      raise DynamicImage::Errors::InvalidHeader unless valid_header?
-
-      MiniExiftool.new(string_io)
+    def format
+      DynamicImage::Format.sniff(file_header)
     end
 
     def read
       raise DynamicImage::Errors::InvalidHeader unless valid_header?
 
-      MiniMagick::Image.read(@data)
+      if @data.is_a?(String)
+        Vips::Image.new_from_buffer(@data, option_string)
+      else
+        Vips::Image.new_from_file(@data.path + option_string, access: :random)
+      end
     end
 
     def valid_header?
-      return false if file_header.blank?
-
-      self.class.magic_bytes.each do |str|
-        return true if file_header.start_with?(str)
-      end
-      false
+      format ? true : false
     end
 
     private
 
     def file_header
-      @file_header ||= string_io.read(8)
+      @file_header ||= read_file_header
+    end
+
+    def option_string
+      format.animated? ? "[n=-1]" : ""
     end
 
-    def string_io
-      StringIO.new(@data, "rb")
+    def read_file_header
+      data_stream = stream
+      header = data_stream.read(8)
+      data_stream.seek((0 - header.length), IO::SEEK_CUR) if header
+      header
+    end
+
+    def stream
+      return StringIO.new(@data, "rb") if @data.is_a?(String)
+
+      @data
     end
   end
 end

data/lib/dynamic_image/image_sizing.rb

@@ -36,19 +36,6 @@ module DynamicImage
       [crop_size, (start + crop_start)]
     end
 
-    # Returns crop geometry as an ImageMagick compatible string.
-    #
-    # ==== Example
-    #
-    #   image = Image.find(params[:id]) # 320x200 image
-    #   sizing = DynamicImage::ImageSizing.new(image)
-    #
-    #   sizing.crop_geometry(Vector2d(100, 100)) # => "200x200+60+0"
-    def crop_geometry_string(ratio_vector)
-      crop_size, start = crop_geometry(ratio_vector)
-      crop_size.floor.to_s + "+#{start.x.to_i}+#{start.y.to_i}!"
-    end
-
     # Adjusts +fit_size+ to fit the image dimensions.
     # Any dimension set to zero will be ignored.
     #

data/lib/dynamic_image/metadata.rb

@@ -15,39 +15,38 @@ module DynamicImage
     def colorspace
       return unless valid?
 
-      case metadata[:colorspace]
+      case metadata[:colorspace].to_s
       when /rgb/i
         "rgb"
       when /cmyk/i
         "cmyk"
-      when /gray/i
+      when /gray/i, /b-w/i
         "gray"
       end
     end
 
     # Returns the content type of the image.
     def content_type
-      "image/#{format.downcase}" if valid?
+      reader.format.content_type if valid?
+    end
+
+    def format
+      reader.format.name if valid?
     end
 
     # Returns the dimensions of the image as a vector.
     def dimensions
-      Vector2d.new(*metadata[:dimensions]) if valid?
+      Vector2d.new(metadata[:width], metadata[:height]) if valid?
     end
 
     # Returns the width of the image.
     def width
-      dimensions.try(:x)
+      metadata[:width] if valid?
     end
 
     # Returns the height of the image.
     def height
-      dimensions.try(:y)
-    end
-
-    # Returns the format of the image.
-    def format
-      metadata[:format] if valid?
+      metadata[:height] if valid?
     end
 
     # Returns true if the image is valid.
@@ -63,12 +62,8 @@ module DynamicImage
 
     def read_image
       image = reader.read
-      image.auto_orient
-      result = yield image
-      image.destroy!
-      result
-    rescue MiniMagick::Invalid
-      :invalid
+      image.autorot if image.respond_to?(:autorot)
+      yield image
     end
 
     def reader
@@ -77,11 +72,15 @@ module DynamicImage
 
     def read_metadata
       read_image do |image|
-        {
-          colorspace: image[:colorspace],
-          dimensions: image[:dimensions],
-          format: image[:format]
-        }
+        height = if image.get_fields.include?("page-height")
+                   image.get("page-height")
+                 else
+                   image.get("height")
+                 end
+
+        { width: image.get("width"),
+          height: height,
+          colorspace: image.get("interpretation") }
       end
     end
   end

data/lib/dynamic_image/model/transformations.rb

@@ -10,10 +10,10 @@ module DynamicImage
         transform_image do |image|
           new_size = real_size.constrain_both(max_size)
           scale = new_size.x / real_size.x
-          image.resize(new_size)
           crop_attributes.each do |attr|
             self[attr] = self[attr] * scale if self[attr]
           end
+          image.resize(new_size)
         end
       end
 
@@ -29,8 +29,8 @@ module DynamicImage
         end
 
         transform_image do |image|
-          image.rotate(degrees)
           rotate_dimensions(real_size.x, real_size.y, degrees)
+          image.rotate(degrees)
         end
       end
 
@@ -74,15 +74,9 @@ module DynamicImage
         [new_width - crop_gravity_y, crop_gravity_x]
       end
 
-      def processed_image
-        DynamicImage::ProcessedImage.new(self, uncropped: true)
-      end
-
-      def transform_image
+      def transform_image(&block)
         read_image_metadata if data_changed?
-        self.data = processed_image.normalized do |image|
-          yield(image) if block_given?
-        end
+        self.data = block.call(DynamicImage::ImageProcessor.new(data)).read
         read_image_metadata
         self
       end

data/lib/dynamic_image/model/validations.rb

@@ -58,19 +58,11 @@ module DynamicImage
 
       module ClassMethods
         def allowed_colorspaces
-          %w[rgb
-             cmyk
-             gray]
+          %w[rgb cmyk gray]
         end
 
         def allowed_content_types
-          %w[image/bmp
-             image/gif
-             image/jpeg
-             image/pjpeg
-             image/png
-             image/tiff
-             image/webp]
+          DynamicImage::Format.content_types
         end
       end
 

data/lib/dynamic_image/processed_image.rb

@@ -11,21 +11,8 @@ module DynamicImage
     def initialize(record, options = {})
       @record    = record
       @uncropped = options[:uncropped] ? true : false
-      @format    = options[:format].to_s.upcase if options[:format]
-      @format    = "JPEG" if defined?(@format) && @format == "JPG"
-    end
-
-    # Returns the content type of the processed image.
-    #
-    # ==== Example
-    #
-    #   image = Image.find(params[:id])
-    #   DynamicImage::ProcessedImage.new(image).content_type
-    #   # => 'image/png'
-    #   DynamicImage::ProcessedImage.new(image, :jpeg).content_type
-    #   # => 'image/jpeg'
-    def content_type
-      "image/#{format}".downcase
+      @format_name = options[:format].to_s.upcase if options[:format]
+      @format_name = "JPEG" if defined?(@format_name) && @format_name == "JPG"
     end
 
     # Crops and resizes the image. Normalization is performed as well.
@@ -56,6 +43,10 @@ module DynamicImage
       record.variants.find_by(variant_params(size))
     end
 
+    def format
+      DynamicImage::Format.find(@format_name) || record_format
+    end
+
     # Normalizes the image.
     #
     # * Applies EXIF rotation
@@ -72,109 +63,48 @@ module DynamicImage
     # Returns a binary string.
     def normalized
       require_valid_image!
-      process_data do |image|
-        image.combine_options do |combined|
-          combined.auto_orient
-          convert_to_srgb(image, combined)
-          yield(combined) if block_given?
-          optimize(combined)
-        end
-        image.format(format) if needs_format_conversion?
-      end
-    end
-
-    private
 
-    def coalesced(image)
-      gif? ? DynamicImage::ImageReader.new(image.coalesce.to_blob).read : image
+      image = DynamicImage::ImageProcessor.new(record.data)
+      image = yield(image) if block_given?
+      image.convert(format).read
     end
 
-    def convert_to_srgb(image, combined)
-      if image.data["profiles"].present? &&
-         exif.colorspacedata&.strip&.downcase == record.colorspace
-        combined.profile(srgb_profile)
-      end
-      combined.colorspace("sRGB") if record.cmyk?
-    end
+    private
 
     def create_variant(size)
       record.variants.create(
         variant_params(size).merge(filename: record.filename,
-                                   content_type: content_type,
+                                   content_type: format.content_type,
                                    data: crop_and_resize(size))
       )
     end
 
     def crop_and_resize(size)
       normalized do |image|
-        next unless record.cropped? || size != record.size
-
-        image.crop(image_sizing.crop_geometry_string(size))
-        image.resize(size)
+        image.crop(*image_sizing.crop_geometry(size)).resize(size)
       end
     end
 
-    def exif
-      @exif ||= DynamicImage::ImageReader.new(record.data).exif
-    end
-
-    def format
-      @format ||= record_format
-    end
-
-    def gif?
-      content_type == "image/gif"
-    end
-
-    def jpeg?
-      content_type == "image/jpeg"
-    end
-
     def image_sizing
       @image_sizing ||=
         DynamicImage::ImageSizing.new(record, uncropped: @uncropped)
     end
 
-    def needs_format_conversion?
-      format != record_format
-    end
-
-    def optimize(image)
-      image.layers "optimize" if gif?
-      image.strip
-      image.quality(85).sampling_factor("4:2:0").interlace("JPEG") if jpeg?
-      image
-    end
-
-    def process_data
-      image = coalesced(DynamicImage::ImageReader.new(record.data).read)
-      yield(image)
-      result = image.to_blob
-      image.destroy!
-      result
-    end
-
     def record_format
-      { "image/bmp" => "BMP", "image/png" => "PNG", "image/gif" => "GIF",
-        "image/jpeg" => "JPEG", "image/pjpeg" => "JPEG", "image/tiff" => "TIFF",
-        "image/webp" => "WEBP" }[record.content_type]
+      DynamicImage::Format.content_type(record.content_type)
     end
 
     def require_valid_image!
       raise DynamicImage::Errors::InvalidImage unless record.valid?
     end
 
-    def srgb_profile
-      File.join(File.dirname(__FILE__), "profiles/sRGB_ICC_v4_Appearance.icc")
-    end
-
     def variant_params(size)
       crop_size, crop_start = image_sizing.crop_geometry(size)
 
       { width: size.x.round, height: size.y.round,
         crop_width: crop_size.x, crop_height: crop_size.y,
         crop_start_x: crop_start.x, crop_start_y: crop_start.y,
-        format: format }
+        format: format.name }
     end
   end
 end

data/lib/dynamic_image/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicImage
-  VERSION = "2.1.0"
+  VERSION = "3.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_image
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Inge Jørgensen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-13 00:00:00.000000000 Z
+date: 2021-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dis
@@ -19,7 +19,7 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.6
+        version: 1.1.11
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,49 +29,35 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.6
+        version: 1.1.11
 - !ruby/object:Gem::Dependency
-  name: mini_exiftool
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: mini_magick
+  name: ruby-vips
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: vector2d
   requirement: !ruby/object:Gem::Requirement
@@ -110,16 +96,16 @@ dependencies:
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +145,7 @@ files:
 - README.md
 - Rakefile
 - app/models/dynamic_image/variant.rb
+- app/views/dynamic_image/images/show.html.erb
 - db/migrate/20190620160500_create_dynamic_image_variants.rb
 - lib/dynamic_image.rb
 - lib/dynamic_image/belongs_to.rb
@@ -166,7 +153,12 @@ files:
 - lib/dynamic_image/digest_verifier.rb
 - lib/dynamic_image/engine.rb
 - lib/dynamic_image/errors.rb
+- lib/dynamic_image/format.rb
 - lib/dynamic_image/helper.rb
+- lib/dynamic_image/image_processor.rb
+- lib/dynamic_image/image_processor/colors.rb
+- lib/dynamic_image/image_processor/frames.rb
+- lib/dynamic_image/image_processor/transform.rb
 - lib/dynamic_image/image_reader.rb
 - lib/dynamic_image/image_sizing.rb
 - lib/dynamic_image/jobs.rb
@@ -178,9 +170,7 @@ files:
 - lib/dynamic_image/model/validations.rb
 - lib/dynamic_image/model/variants.rb
 - lib/dynamic_image/processed_image.rb
-- lib/dynamic_image/profiles/sRGB_ICC_v4_Appearance.icc
 - lib/dynamic_image/routing.rb
-- lib/dynamic_image/templates/show.html.erb
 - lib/dynamic_image/version.rb
 - lib/rails/generators/dynamic_image/resource/resource_generator.rb
 homepage: https://github.com/elektronaut/dynamic_image
@@ -195,14 +185,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Rails plugin that simplifies image uploading and processing