dynamic_image 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f098d53169629e3e9958e1cd67d320c3950d87ef9480451201c95fc74aeb0673
-  data.tar.gz: 86b1de10949a440da1a2f7ec732a8e8ef883f481950facb5d1bac597dd1f3392
+  metadata.gz: cce4ab2b6835bbc3e5299f0c9513ada8a30a2db2b46865b975d20492febb8656
+  data.tar.gz: 172bf1404ef850c29b15d2f3cb88bc41fd4bb7274d0a10e1bfc41d0d6f1b8c55
 SHA512:
-  metadata.gz: 2a4bb11b4f2e08f64498f09524f308414aab7007b721aaa15c9d3fcdaad58efa97810bc5597fd32315b88e73c8db53408b6a141dc5289966d88caa46effd675d
-  data.tar.gz: 95d13e86e911f99ec93222ed2f6b79efba44c54a6407a6e859bc2623f1d2eb020e05301260827d8862a5ac6c26f064b56c6812e6901cb68172f7a688cd9eb492
+  metadata.gz: 917691711e8027af32a176f95d2ad9ccc1621cf8b3141c0e734f086357ace2d6cd2ea0e5217c07ef7ada018a5baeddad6f509efd8b0f4919eb6d2c8e1c4ceafb
+  data.tar.gz: ab5d71c3d0508b4819e93489dfaee8ad5772177b3c1cf76174ac16ebfd4d459070a0b1c8fe2b1c2bc3d20f3f9d648c48ecf07c4e3920ce690dc492b721692d9e

data/README.md

@@ -285,7 +285,7 @@ media queries.
 ## Formats
 
 Supported formats are JPEG, PNG, GIF, WebP, JPEG XL and TIFF.
-BMP, HEIC and AVIF can also be uploaded, but aren't supported for output.
+HEIC and AVIF can also be uploaded, but aren't supported for output.
 
 The preferred format lists are configurable, sorted most preferred format
 first:

data/lib/dynamic_image/backfill.rb

@@ -4,7 +4,7 @@ module DynamicImage
   # = DynamicImage Backfill
   #
   # Fills in the metadata columns for records stored before those columns existed. The values are read back from
-  # the stored file.
+  # the stored file, except where the format guarantees them.
   #
   # Records are written with +update_columns+, so no callbacks run and +updated_at+ is left alone.
   # {DynamicImage::Model#to_param} fingerprints on +updated_at+, and touching it would invalidate every image URL
@@ -17,20 +17,24 @@ module DynamicImage
     # The columns this fills in.
     COLUMNS = %i[frame_count alpha].freeze
 
-    # @return [Class] the model being backfilled
-    attr_reader :model
-
     # @return [Integer] records written
     attr_reader :updated
 
     # @return [Integer] records left alone, unreadable or missing
     attr_reader :skipped
 
+    # @return [Integer] records filled in from the format, without a read
+    attr_reader :inferred
+
     # @param model [Class] a model including {DynamicImage::Model}
-    def initialize(model)
+    # @param concurrency [Integer] how many files to read at a time. Reads are network bound; the metadata itself
+    #   comes off the header. Set to 1 to read serially.
+    def initialize(model, concurrency: 4)
       @model = model
       @updated = 0
       @skipped = 0
+      @inferred = 0
+      @concurrency = [concurrency.to_i, 1].max
     end
 
     # The records with a column still unset.
@@ -40,22 +44,42 @@ module DynamicImage
       COLUMNS.map { |column| model.where(column => nil) }.reduce(:or)
     end
 
-    # Reads metadata for every pending record and fills the columns in.
+    # Fills in what the format settles, then reads the rest.
     #
-    # @yieldparam record [DynamicImage::Model] each record, after it has been processed
+    # @yieldparam record [DynamicImage::Model] each record, after it has been read
     # @return [self]
     # @raise [ArgumentError] if the table doesn't have the columns yet
     def run
       ensure_columns
-      pending.find_each do |record|
-        process(record)
-        yield(record) if block_given?
+      infer_from_format
+      pending.find_in_batches(batch_size: concurrency) do |batch|
+        read(batch).each do |record, values|
+          write(record, values)
+          yield(record) if block_given?
+        end
       end
       self
     end
 
     private
 
+    attr_reader :model, :concurrency
+
+    # The formats whose values follow from the format itself. A format that holds neither animation nor an alpha
+    # channel has one frame and no transparency, whatever the file contains.
+    def inferable_formats
+      DynamicImage::Format.formats.reject { |f| f.animated? || f.alpha? }
+    end
+
+    # Written with update_all, so no files are read, no callbacks run and updated_at is left alone.
+    def infer_from_format
+      inferable_formats.each do |format|
+        @inferred += pending.where(content_type: format.content_types)
+                            .update_all(frame_count: 1, alpha: false)
+      end
+      @inferred
+    end
+
     def ensure_columns
       missing = COLUMNS.reject { |c| model.column_names.include?(c.to_s) }
       return if missing.empty?
@@ -65,20 +89,30 @@ module DynamicImage
             "Run bin/rails generate dynamic_image:upgrade #{model.name}"
     end
 
-    def process(record)
-      record.with_data_file { |path| apply(record, path) }
+    # Reads run in threads and touch no database connection. The writes happen on the calling thread, so the
+    # counters stay consistent.
+    def read(records)
+      return records.map { |record| [record, values_for(record)] } if concurrency == 1
+
+      records.map { |record| Thread.new { [record, values_for(record)] } }
+             .map(&:value)
+    end
+
+    # Metadata reads lazily, so the values have to be resolved before the file goes out of scope.
+    def values_for(record)
+      record.with_data_file do |path|
+        metadata = DynamicImage::Metadata.new(path)
+        [metadata.frame_count, metadata.alpha?] if metadata.valid?
+      end
     rescue Dis::Errors::NotFoundError
-      @skipped += 1
+      nil
     end
 
-    # Metadata reads lazily, so the values have to be resolved before the file goes out of scope. Written with
-    # update_columns so that no callbacks run.
-    def apply(record, path)
-      metadata = DynamicImage::Metadata.new(path)
-      return @skipped += 1 unless metadata.valid?
+    # Written with update_columns so that no callbacks run.
+    def write(record, values)
+      return @skipped += 1 if values.nil?
 
-      record.update_columns(frame_count: metadata.frame_count,
-                            alpha: metadata.alpha?)
+      record.update_columns(frame_count: values.first, alpha: values.last)
       @updated += 1
     end
   end

data/lib/dynamic_image/controller.rb

@@ -32,7 +32,7 @@ module DynamicImage
     PROCESSED_FORMATS = %i[gif jpeg jpg jxl png tiff webp].freeze
 
     # Additional formats +original+ and +download+ will serve.
-    STORED_FORMATS = (PROCESSED_FORMATS + %i[avif bmp heic]).freeze
+    STORED_FORMATS = (PROCESSED_FORMATS + %i[avif heic]).freeze
 
     included do
       before_action :verify_signed_params

data/lib/dynamic_image/engine.rb

@@ -19,7 +19,6 @@ module DynamicImage
 
     initializer "dynamic_image.mime_types" do
       Mime::Type.register "image/avif", :avif
-      Mime::Type.register "image/bmp", :bmp
       Mime::Type.register "image/gif", :gif
       Mime::Type.register "image/heic", :heic, %w[image/heif]
       Mime::Type.register "image/jpeg", :jpg

data/lib/dynamic_image/format.rb

@@ -191,13 +191,6 @@ module DynamicImage
       signature: ->(bytes) { iso_brands(bytes).intersect?(%w[avif avis]) }
     )
 
-    register(
-      "BMP",
-      content_type: %w[image/bmp],
-      extension: %w[.bmp],
-      magic_bytes: ["\x42\x4d"]
-    )
-
     register(
       "GIF",
       animated: true,

data/lib/dynamic_image/format_negotiator.rb

@@ -74,7 +74,7 @@ module DynamicImage
     end
 
     def animated?
-      frame_count.to_i > 1
+      record.animated?
     end
 
     def alpha?

data/lib/dynamic_image/model.rb

@@ -71,13 +71,17 @@ module DynamicImage
       before_validation :read_image_metadata, if: :data_changed?
     end
 
-    # Returns true if the image holds more than one frame.
+    # Returns true if the image holds more than one frame in a format that renders them.
     #
-    # Images stored before +frame_count+ existed have none, and are taken to be still.
+    # Images stored before +frame_count+ existed have none, and are taken to be still. A multi-page document in a
+    # format that isn't animated, such as TIFF, is also still: {DynamicImage::ImageReader} loads only its first
+    # page.
     #
     # @return [Boolean]
     def animated?
-      has_attribute?(:frame_count) && frame_count.to_i > 1
+      return false unless has_attribute?(:frame_count) && frame_count.to_i > 1
+
+      DynamicImage::Format.content_type(content_type)&.animated? || false
     end
 
     # Returns the alt text for the image, or nil if none has been set.

data/lib/dynamic_image/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_image
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
 - Inge Jørgensen