dynamic_image 3.1.3 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd3ffefb6b55bdcc4893536be40a12711ee0cab2de28b847c64c8a969b268197
-  data.tar.gz: 28ee34454f455efafb4204de4a4a82fa35da6f84f0d5aaacb96948f3bede3b8c
+  metadata.gz: 3053f66d3a18e5e0ebc6cc6ab5efe548d8fe296e80708fbde264d808184b54cf
+  data.tar.gz: 45d1d51fa23b0501d3af442abcac9d3bbc13e943ebe89343a2746cdda92e979d
 SHA512:
-  metadata.gz: 0b2e45b8a4343a878d40ebc7a95fec1214b4b88249bdd4b3fa643fc2ff53d8f4b796a95dfb058f1209424732c2db8d00911b2a3b3d668eadd2e7bc0baf7ae1aa
-  data.tar.gz: ca1e46c071da033e84438d39ece4d1cba5a302ef91ac1075f577045de9b0ed2e43f062e884f15e40c4c14dd7954846a0c3d4c69809657c5a5b460298b3defce0
+  metadata.gz: aaa7011dc360af36d61ec8435a11a37704a7062271edacea578c0f8c5d5322a913abebf3d11840702153d22f5f1308fcda74764ed120f4effb0fd8427f91febc
+  data.tar.gz: 96d997eb20a89e071e8dbcf6e4aee0289ecb11def3a089f03f1a87235a897b4c0b5a0b233d2d54792f729ea83bef3e90fa46e52e8e296d4e74a0b073bca734e8

data/README.md

@@ -357,7 +357,9 @@ image.save
 `rotate` turns the image, taking the crop along with it. The angle must
 be a multiple of 90.
 
-`resize` scales the stored file down and replaces the original.
+`resize` scales the stored file to fit within the given size and replaces
+the original. Note that it scales up as well as down: an image smaller
+than the given size will be upscaled.
 
 ### Outside of views
 
@@ -456,10 +458,12 @@ and the [changelog](CHANGELOG.md) for release notes.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on
-[GitHub](https://github.com/elektronaut/dynamic_image). See
-[CONTRIBUTING.md](CONTRIBUTING.md) for how to run the tests and how
-commits are formatted, and note that this project ships with a
+Bug reports, feature requests, and pull requests are welcome. Read
+[CONTRIBUTING.md](CONTRIBUTING.md) first. Report security vulnerabilities
+privately as described in [SECURITY.md](SECURITY.md).
+
+CONTRIBUTING.md also covers how to run the tests and how commits are
+formatted. Everyone participating is expected to follow the
 [code of conduct](CODE_OF_CONDUCT.md).
 
 ## License

data/lib/dynamic_image/breakpoints.rb

@@ -61,15 +61,15 @@ module DynamicImage
     private
 
     def fixed(available)
-      widths = spec.map(&:to_i).select { _1 <= available }.uniq.sort
+      widths = spec.map(&:to_i).select { it <= available }.uniq.sort
       widths.any? ? widths : [available]
     end
 
     def stepped(available)
       top = [available, spec.end || available].min
-      rest = Enumerator.produce(top / step) { _1 / step }
-                       .take_while { _1 >= spec.begin }
-                       .map { snap(_1) }
+      rest = Enumerator.produce(top / step) { it / step }
+                       .take_while { it >= spec.begin }
+                       .map { snap(it) }
 
       [top, *rest].reverse.uniq
     end

data/lib/dynamic_image/controller.rb

@@ -37,6 +37,7 @@ module DynamicImage
     included do
       before_action :verify_signed_params
       before_action :find_record
+      before_action :redirect_to_canonical_id
       after_action :cache_expiration_header
       helper_method :requested_size
     end
@@ -97,6 +98,15 @@ module DynamicImage
       @record = model.find(params[:id])
     end
 
+    # Redirects permanently to the same URL with the record's +to_param+ as the id, unless the URL already uses it.
+    def redirect_to_canonical_id
+      return if params[:id] == @record.to_param
+
+      expires_now
+      redirect_to url_for(params.permit(:digest, :size, :format).merge(id: @record.to_param, only_path: true)),
+                  status: :moved_permanently
+    end
+
     # The filename the image is served as, the record's own filename with the extension of the rendered format.
     # Override to name downloads something else.
     def filename(format = nil)

data/lib/dynamic_image/errors.rb

@@ -28,10 +28,13 @@ module DynamicImage
     # @see DynamicImage::DigestVerifier#verify
     class InvalidSignature < DynamicImage::Errors::Error; end
 
-    # Raised when cropping is requested without both dimensions, as in <tt>size: "400x", crop: true</tt>. There is no
-    # way to crop to an exact size when one of them is unknown.
+    # Raised when a size can't be rendered. Cropping was requested without both dimensions, as in
+    # <tt>size: "400x", crop: true</tt> — there is no way to crop to an exact size when one of them is unknown — or
+    # the size is zero on both axes, as <tt>"0x0"</tt> is, and constrains nothing, or the size works out to less
+    # than a pixel, as <tt>"1x1"</tt> does against a very wide image.
     #
     # @see DynamicImage::ImageSizing#fit
+    # @see DynamicImage::Model::Transformations#resize
     class InvalidSizeOptions < DynamicImage::Errors::Error; end
 
     # Raised when a transformation can't be applied, either because a rotation isn't a multiple of 90 degrees or

data/lib/dynamic_image/helper/pictures.rb

@@ -45,6 +45,8 @@ module DynamicImage
       # @option options [Integer] :fallback_width The width to ask for the <tt>img</tt>, overriding
       #   {DynamicImage.picture_fallback_width}
       # @return [String] the picture element
+      # @raise [DynamicImage::Errors::InvalidSizeOptions] if the image has less than a pixel to render at the
+      #   requested ratio
       #
       # @example
       #   dynamic_picture_tag(image, sizes: "50vw", alt: "A kitten")

data/lib/dynamic_image/helper.rb

@@ -54,9 +54,11 @@ module DynamicImage
     #   # => <img alt="Avatar" src="..." width="100" height="62" />
     def dynamic_image_tag(record_or_array, options = {})
       record = extract_dynamic_image_record(record_or_array)
+      requested = options[:size]
       size = fit_size!(record_or_array, options)
       url_options = options.extract!(*allowed_dynamic_image_url_options)
-      html_options = { size:, alt: record.alt_text }.merge(options)
+      html_options = { size: display_size(size, requested), alt: record.alt_text }
+                     .merge(options)
 
       image_tag(dynamic_image_path_with_size(record_or_array,
                                              size,
@@ -78,7 +80,8 @@ module DynamicImage
     #   an array is negotiated against the image by {DynamicImage::FormatNegotiator}. Defaults to
     #   {DynamicImage.default_formats}, or {DynamicImage.mailer_formats} in a mailer view.
     # @return [String]
-    # @raise [DynamicImage::Errors::InvalidSizeOptions] if <tt>crop: true</tt> is given without both dimensions
+    # @raise [DynamicImage::Errors::InvalidSizeOptions] if the size is zero on both axes, or if <tt>crop: true</tt>
+    #   is given without both dimensions or leaves less than a pixel to render
     #
     # Any options supported by +polymorphic_url+ are also accepted.
     #
@@ -217,7 +220,16 @@ module DynamicImage
     def image_sizing(record, size_opts, uncropped)
       ImageSizing
         .new(record, uncropped:)
-        .fit(size_opts[:size], size_opts).floor.to_s
+        .fit_renderable(size_opts[:size], size_opts).floor.to_s
+    end
+
+    # Ensure either dimension is at least 1px
+    def display_size(size, requested)
+      return size unless requested
+
+      Vector2d.parse(size)
+              .fit(Vector2d.parse(requested), upscale: false)
+              .floor.max(1).to_s
     end
   end
 end

data/lib/dynamic_image/image_processor/transform.rb

@@ -25,16 +25,30 @@ module DynamicImage
         end
       end
 
-      # Resize the image to a new size. The aspect ratio is not preserved; crop first if that matters.
+      # Resizes the image to fit within +new_size+, retaining its aspect ratio. Crop first if the image needs to
+      # fill the size exactly.
       #
-      # @param new_size [Vector2d] the size to resize to
+      # @param new_size [Vector2d] the size to fit within
       # @return [DynamicImage::ImageProcessor] a new processor
       def resize(new_size)
-        new_size = Vector2d(new_size)
-        apply image.thumbnail_image(new_size.x.to_i,
-                                    height: new_size.y.to_i,
+        resize_exact(size.fit(Vector2d(new_size)))
+      end
+
+      # Resizes the image to exactly +new_size+, rounded to whole pixels. The aspect ratio is not retained, so the
+      # image is stretched if the size doesn't match its own ratio.
+      #
+      # Use this when the size has already been worked out and has to be honored as given, as it is for a size
+      # coming from a URL. {DynamicImage::ImageSizing} computed it against this image, the helper committed to it in
+      # the markup, and refitting it here would land on a different size than the one advertised.
+      #
+      # @param new_size [Vector2d] the size to render
+      # @return [DynamicImage::ImageProcessor] a new processor
+      def resize_exact(new_size)
+        new_size = Vector2d(new_size).round
+        apply image.thumbnail_image(new_size.x,
+                                    height: new_size.y,
                                     crop: :none,
-                                    size: :both)
+                                    size: :force)
       end
 
       # Rotates the image. The rotation must be a multiple of 90 degrees.

data/lib/dynamic_image/image_processor.rb

@@ -21,7 +21,7 @@ module DynamicImage
   #   DynamicImage::ImageProcessor
   #     .new(file)
   #     .crop(crop_start, crop_size)
-  #     .resize(size)
+  #     .resize_exact(size)
   #     .convert(:jpeg)
   #     .read
   class ImageProcessor

data/lib/dynamic_image/image_sizing.rb

@@ -7,6 +7,11 @@ module DynamicImage
   # image, and it can be used on its own when you need the size without rendering anything: reserving space in a
   # layout, filling in <tt>og:image:width</tt>, or laying out a PDF.
   #
+  # The size it returns is the size that gets rendered. The helper floors it into the URL and the markup, and
+  # {DynamicImage::ImageProcessor::Transform#resize_exact} honors that number instead of fitting it again. Scaling
+  # is done in floating point, so +snap+ pulls an axis that lands a rounding error below a whole pixel back onto it
+  # before the helper's floor can drop the pixel.
+  #
   # @example
   #   sizing = DynamicImage::ImageSizing.new(image)
   #   sizing.fit("400x400") # => Vector2d(400.0, 250.0)
@@ -27,6 +32,7 @@ module DynamicImage
     #
     # @param ratio_vector [Vector2d] the aspect ratio to crop to
     # @return [Array(Vector2d, Vector2d)] the crop size and crop start
+    # @raise [DynamicImage::Errors::InvalidSizeOptions] if the vector is zero on both axes
     #
     # @example
     #   image = Image.find(params[:id]) # 320x200 image
@@ -35,6 +41,8 @@ module DynamicImage
     #   sizing.crop_geometry(Vector2d(100, 100))
     #   # => [Vector2d(200, 200), Vector2d(60, 0)]
     def crop_geometry(ratio_vector)
+      require_nonzero!(ratio_vector)
+
       # Maximize the crop area to fit the image size
       crop_size = ratio_vector.fit(size).round
 
@@ -66,7 +74,7 @@ module DynamicImage
       ratio = DynamicImage::Ratio.parse(ratio)
       return size.x.floor unless ratio
 
-      crop_geometry(vector(ratio, 1)).first.x.floor
+      crop_geometry(Vector2d.new(ratio, 1)).first.x.floor
     end
 
     # Adjusts +fit_size+ to fit the image dimensions. Any dimension set to zero will be ignored.
@@ -79,7 +87,8 @@ module DynamicImage
     # @option options [Boolean] :upscale Don't limit to the size of the image. Images smaller than the given size will
     #   be scaled up.
     # @return [Vector2d] the resulting size
-    # @raise [DynamicImage::Errors::InvalidSizeOptions] if <tt>crop: true</tt> is given and either dimension is zero
+    # @raise [DynamicImage::Errors::InvalidSizeOptions] if <tt>crop: true</tt> is given and either dimension is zero,
+    #   if the size is zero on both axes, or if the result is less than a pixel in either dimension
     #
     # @example
     #   image = Image.find(params[:id]) # 320x200 image
@@ -89,7 +98,7 @@ module DynamicImage
     #   # => Vector2d(160.0, 100.0)
     #
     #   sizing.fit(Vector2d(500, 500))
-    #   # => Vector2d(320.0, 200.0)
+    #   # => Vector2d(320, 200)
     #
     #   sizing.fit(Vector2d(500, 500), crop: true)
     #   # => Vector2d(200.0, 200.0)
@@ -98,36 +107,66 @@ module DynamicImage
     #   # => Vector2d(500.0, 312.5)
     def fit(fit_size, options = {})
       fit_size = parse_vector(fit_size)
-      require_dimensions!(fit_size)     if options[:crop]
-      fit_size = size.fit(fit_size)     unless options[:crop]
-      fit_size = size.contain(fit_size) unless options[:upscale]
+      require_dimensions!(fit_size) if options[:crop]
+      require_nonzero!(fit_size)
+      fit_size = snap(scale(fit_size, options))
+      require_pixels!(fit_size)
       fit_size
     end
 
+    # Fits the size like {#fit}, but returns the smallest size the image can be rendered at rather than raising when
+    # the result lands under a pixel.
+    #
+    # @param fit_size [Vector2d, String] the size to fit within, as taken by {#fit}
+    # @param options [Hash] as taken by {#fit}
+    # @return [Vector2d] the resulting size
+    # @raise [DynamicImage::Errors::InvalidSizeOptions] if the size is zero on both axes, or if <tt>crop: true</tt>
+    #   is given and the crop is less than a pixel
+    #
+    # @example
+    #   image = Image.find(params[:id]) # 2000x1 image
+    #   sizing = DynamicImage::ImageSizing.new(image)
+    #
+    #   sizing.fit_renderable("1200x") # => Vector2d(2000.0, 1.0)
+    def fit_renderable(fit_size, options = {})
+      require_nonzero!(parse_vector(fit_size))
+      return fit(fit_size, options) if options[:crop] || renderable?(fit_size, options)
+
+      size.cover(1).round
+    end
+
+    # Returns true if the image can be rendered at +fit_size+, false if {#fit} rejects it.
+    #
+    # @param fit_size [Vector2d, String] the size to fit within, as taken by {#fit}
+    # @param options [Hash] as taken by {#fit}
+    # @return [Boolean]
+    #
+    # @example
+    #   image = Image.find(params[:id]) # 320x200 image
+    #   sizing = DynamicImage::ImageSizing.new(image)
+    #
+    #   sizing.renderable?(Vector2d(100, 0)) # => true
+    #   sizing.renderable?(Vector2d(1, 0))   # => false
+    def renderable?(fit_size, options = {})
+      vector = parse_vector(fit_size)
+      return false if options[:crop] && !(vector.x.positive? && vector.y.positive?)
+      return false if vector.x.zero? && vector.y.zero?
+
+      pixels?(snap(scale(vector, options)))
+    end
+
     private
 
     def crop_gravity
-      if uncropped? && !record.crop_gravity?
-        size / 2
-      else
-        record.crop_gravity
-      end
+      uncropped? && !record.crop_gravity? ? size / 2 : record.crop_gravity
     end
 
     def crop_start
-      if uncropped?
-        Vector2d.new(0, 0)
-      else
-        record.crop_start
-      end
+      uncropped? ? Vector2d.new(0, 0) : record.crop_start
     end
 
     def size
-      if uncropped?
-        record.real_size
-      else
-        record.size
-      end
+      uncropped? ? record.real_size : record.size
     end
 
     # Clamps the rectangle defined by +start+ and +size+ to fit inside 0, 0 and +max_size+. It is assumed that +size+
@@ -140,6 +179,14 @@ module DynamicImage
       start
     end
 
+    # Scales +fit_size+ against the image, honouring <tt>:crop</tt> and <tt>:upscale</tt>.
+    def scale(fit_size, options)
+      upscale = options[:upscale] ? true : false
+      return size.fit(fit_size, upscale:) unless options[:crop]
+
+      upscale ? fit_size : fit_size.fit(size, upscale: false)
+    end
+
     def parse_vector(vector)
       vector.is_a?(String) ? str_to_vector(vector) : vector
     end
@@ -149,16 +196,52 @@ module DynamicImage
     def require_dimensions!(vector)
       return if vector.x.positive? && vector.y.positive?
 
-      raise DynamicImage::Errors::InvalidSizeOptions
+      raise DynamicImage::Errors::InvalidSizeOptions,
+            "both dimensions are required when cropping"
+    end
+
+    # Rejects a vector that is zero on both axes. A single zero axis means the axis is unconstrained, but a vector
+    # that is zero throughout constrains nothing and describes no image.
+    def require_nonzero!(vector)
+      return unless vector.x.zero? && vector.y.zero?
+
+      raise DynamicImage::Errors::InvalidSizeOptions, "#{vector} has no size"
+    end
+
+    # Rejects sizes that don't round to at least one pixel in each dimension, since there is no image to render at
+    # that point.
+    def require_pixels!(vector)
+      return if pixels?(vector)
+
+      raise DynamicImage::Errors::InvalidSizeOptions,
+            "#{vector} has a dimension smaller than one pixel"
+    end
+
+    def pixels?(vector)
+      vector.x >= 1 && vector.y >= 1
     end
 
     def shift_vector(vect)
-      vector(
+      Vector2d.new(
         vect.x.negative? ? vect.x.abs : 0,
         vect.y.negative? ? vect.y.abs : 0
       )
     end
 
+    # Snaps each axis of +scaled+ onto the whole pixel it is a rounding error away from. Scaling is done in floating
+    # point, so an axis that should land exactly on a pixel can come out a few ulps below it, and callers flooring
+    # the result would lose that pixel.
+    def snap(scaled)
+      Vector2d.new(snap_axis(scaled.x), snap_axis(scaled.y))
+    end
+
+    def snap_axis(value)
+      return value unless value.is_a?(Float) && value.finite?
+
+      rounded = value.round
+      (value - rounded).abs <= value.abs * 8 * Float::EPSILON ? rounded.to_f : value
+    end
+
     def str_to_vector(str)
       x, y = str.match(/(\d*)x(\d*)/)[1, 2].map(&:to_i)
       Vector2d.new(x, y)
@@ -167,9 +250,5 @@ module DynamicImage
     def uncropped?
       @uncropped
     end
-
-    def vector(width, height)
-      Vector2d.new(width, height)
-    end
   end
 end

data/lib/dynamic_image/model/transformations.rb

@@ -9,13 +9,20 @@ module DynamicImage
     # Both methods replace the data and update the stored dimensions, adjusting the crop to match. Neither saves
     # the record.
     module Transformations
-      # Resizes the image, replacing the stored file with a smaller one. The crop is scaled along with it.
+      # Resizes the image, replacing the stored file. The crop is scaled along with it.
       #
-      # @param max_size [Vector2d] the size to scale down to
+      # The image is scaled to fit within +max_size+, retaining its aspect ratio. Images smaller than +max_size+
+      # will be scaled up.
+      #
+      # @param max_size [Vector2d, String] the size to fit within, either a vector or a <tt>"{width}x{height}"</tt>
+      #   string. Either dimension may be omitted to scale by the other alone.
       # @return [self]
+      # @raise [DynamicImage::Errors::InvalidSizeOptions] if the size is zero on both axes, or if the result is less
+      #   than a pixel in either dimension
+      # @raise [DynamicImage::Errors::InvalidImage] if the stored data can't be processed
       def resize(max_size)
         transform_image do |image|
-          resized = image.resize(real_size.constrain_both(max_size))
+          resized = image.resize_exact(fit_size(max_size))
           scale_crop(resized.size)
           resized
         end
@@ -26,6 +33,7 @@ module DynamicImage
       # @param degrees [Integer] the angle, which must be a multiple of 90. Rotating by 0 is a no-op.
       # @return [self]
       # @raise [DynamicImage::Errors::InvalidTransformation] if the angle isn't a multiple of 90
+      # @raise [DynamicImage::Errors::InvalidImage] if the stored data can't be processed
       #
       # @example
       #   image.rotate(90)
@@ -48,6 +56,21 @@ module DynamicImage
 
       private
 
+      # Scales +max_size+ against the image, rejecting a size that is zero on both axes and a result smaller than a
+      # pixel in either dimension, as {DynamicImage::ImageSizing#fit} does for the sizes rendered on request.
+      def fit_size(max_size)
+        max_size = Vector2d.parse(max_size)
+        if max_size.x.zero? && max_size.y.zero?
+          raise DynamicImage::Errors::InvalidSizeOptions, "#{max_size} has no size"
+        end
+
+        new_size = real_size.fit(max_size)
+        return new_size if new_size.x >= 1 && new_size.y >= 1
+
+        raise DynamicImage::Errors::InvalidSizeOptions,
+              "#{new_size} has a dimension smaller than one pixel"
+      end
+
       def scale_crop(new_size)
         scale = new_size.to_f_vector / real_size
 
@@ -117,6 +140,8 @@ module DynamicImage
         end
         read_image_metadata
         self
+      rescue Vips::Error => e
+        raise DynamicImage::Errors::InvalidImage, e.message
       end
     end
   end

data/lib/dynamic_image/picture.rb

@@ -28,7 +28,7 @@ module DynamicImage
     # @!attribute [r] breakpoints
     #   @return [DynamicImage::Breakpoints] the candidate widths
     # @!attribute [r] fallback_width
-    #   @return [Integer] the width asked for the fallback image
+    #   @return [Integer] the width configured for the fallback image
     attr_reader :template, :record_or_array, :ratio, :sizes, :breakpoints, :fallback_width, :url_options
 
     # @param template [ActionView::Base] the view context, for routing
@@ -77,9 +77,13 @@ module DynamicImage
 
     # The candidate widths, smallest first.
     #
+    # Widths the image can't be rendered at are left out. One that can't be rendered at any of them gets a single
+    # candidate at its available width.
+    #
     # @return [Array<Integer>]
     def widths
-      @widths ||= breakpoints.widths(available_width)
+      @widths ||= breakpoints.widths(available_width).select { renderable?(it) }.presence ||
+                  [available_width].select { renderable?(it) }
     end
 
     # Every candidate, as the URL and the size it is actually rendered at.
@@ -128,9 +132,12 @@ module DynamicImage
 
     # The size asked for the fallback image, as a <tt>"{width}x{height}"</tt> string.
     #
+    # This is {#fallback_width}, unless the image can't be rendered that wide, in which case the widest candidate
+    # it can be rendered at stands in.
+    #
     # @return [String]
     def fallback_size
-      @fallback_size ||= size_for(fallback_width)
+      @fallback_size ||= size_for(renderable?(fallback_width) ? fallback_width : (widths.last || fallback_width))
     end
 
     # The size the fallback image is actually rendered at. Smaller than {#fallback_size} when the image is.
@@ -171,6 +178,10 @@ module DynamicImage
       DynamicImage::Breakpoints.new(options[:breakpoints], step: options[:step])
     end
 
+    def renderable?(width)
+      sizing.renderable?(size_for(width), crop: crop?)
+    end
+
     def record
       record_or_array.last
     end

data/lib/dynamic_image/processed_image.rb

@@ -135,7 +135,7 @@ module DynamicImage
 
     def crop_and_resize(size)
       normalized do |image|
-        image.crop(*image_sizing.crop_geometry(size)).resize(size)
+        image.crop(*image_sizing.crop_geometry(size)).resize_exact(size)
       end
     end
 

data/lib/dynamic_image/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_image
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.4.0
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -61,16 +61,22 @@ dependencies:
   name: vector2d
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '4.0'
 description: DynamicImage is a Rails plugin that simplifies image uploading and processing
 email:
 - inge@elektronaut.no
@@ -139,14 +145,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 3.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Rails plugin that simplifies image uploading and processing
 test_files: []