active_storage_validations 1.3.3 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5908eeb81003dac14877a0427050b3db222977413379a2c55382676272115e4
-  data.tar.gz: 5a49abac59e29c7ba055284fd437a8c1872f9e200c0b7491c613dae8f5152438
+  metadata.gz: 1fe705d1a3b76d875ddc0a61d7d3caa439ddad3ba4a8b5be3c203f8d8cdd00ca
+  data.tar.gz: 826dbac96af4e1ed424ad16670aea3e428296ab07ae9bfdad29e4c0b453d114d
 SHA512:
-  metadata.gz: b46c3457c3042e514e9401eb011d2c9bfd880ff3c42d38595b3e33010b95f57e5310bffbbc6af350aacbb55accf3f60cd33b3f7333ee33fceed105aac4e49d64
-  data.tar.gz: bebee3a79850fa031e4f8cbdd8d16aec5212e3214d17da6f38f72feb4713320f1ba2b351ba331ac155e0aa637632a50781d36749983aa643fa5f9591ba4a86ea
+  metadata.gz: 4ccb7a673c9c5a7d6508e49c6b4b92b50b08faa9395a6e6c7da3bef460a6b72b64900d2ce7e529c5f18224c5b96e23bf82e8142f5d6dc047c327216b117bff21
+  data.tar.gz: f29bcdf4a6142b99d1cabf53086b682925256afc433e106a52feca3e96f097203c5e27ed7419ea51fc9b4ee6a2c454b06b0cdbb56a1d3f890fa6f452b529be4f

data/README.md

@@ -354,8 +354,8 @@ describe User do
 
   # limit
   # #min, #max
-  it { is_expected.to validate_limit_of(:avatar).min(1) }
-  it { is_expected.to validate_limit_of(:avatar).max(5) }
+  it { is_expected.to validate_limits_of(:avatar).min(1) }
+  it { is_expected.to validate_limits_of(:avatar).max(5) }
 
   # content_type:
   # #allowing, #rejecting

data/lib/active_storage_validations/analyzer/image_analyzer/image_magick.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem.
+  # MiniMagick requires the {ImageMagick}[http://www.imagemagick.org] system library.
+  # This is the default Rails image analyzer.
+  class Analyzer::ImageAnalyzer::ImageMagick < Analyzer::ImageAnalyzer
+
+    private
+
+    def read_image
+      begin
+        require "mini_magick" unless defined?(MiniMagick)
+      rescue LoadError
+        logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+        return {}
+      end
+
+      Tempfile.create(binmode: true) do |tempfile|
+        begin
+          if image(tempfile).valid?
+            yield image(tempfile)
+          else
+            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+            {}
+          end
+        ensure
+          tempfile.close
+        end
+      end
+    rescue MiniMagick::Error => error
+      logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+      {}
+    end
+
+    def image_from_path(path)
+      instrument("mini_magick") do
+        MiniMagick::Image.new(path)
+      end
+    end
+
+    def rotated_image?(image)
+      %w[ RightTop LeftBottom TopRight BottomLeft ].include?(image["%[orientation]"])
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/image_analyzer/vips.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # This analyzer relies on the third-party {ruby-vips}[https://github.com/libvips/ruby-vips] gem.
+  # Ruby-vips requires the {libvips}[https://libvips.github.io/libvips/] system library.
+  class Analyzer::ImageAnalyzer::Vips < Analyzer::ImageAnalyzer
+
+    private
+
+    def read_image
+      begin
+        require "vips" unless defined?(::Vips)
+      rescue LoadError
+        logger.info "Skipping image analysis because the ruby-vips gem isn't installed"
+        return {}
+      end
+
+      Tempfile.create(binmode: true) do |tempfile|
+        begin
+          if image(tempfile)
+            yield image(tempfile)
+          else
+            logger.info "Skipping image analysis because Vips doesn't support the file"
+            {}
+          end
+        ensure
+          tempfile.close
+        end
+      end
+    rescue ::Vips::Error => error
+      logger.error "Skipping image analysis due to a Vips error: #{error.message}"
+      {}
+    end
+
+    def image_from_path(path)
+      instrument("vips") do
+        begin
+          ::Vips::Image.new_from_file(path, access: :sequential)
+        rescue ::Vips::Error
+          # Vips throw errors rather than returning false when reading a not
+          # supported attachable.
+          # We stumbled upon this issue while reading 0 byte size attachable
+          # https://github.com/janko/image_processing/issues/97
+          logger.info "Skipping image analysis because Vips doesn't support the file"
+          nil
+        end
+      end
+    end
+
+    ROTATIONS = /Right-top|Left-bottom|Top-right|Bottom-left/
+    def rotated_image?(image)
+      ROTATIONS === image.get("exif-ifd0-Orientation")
+    rescue ::Vips::Error
+      false
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/image_analyzer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # = Active Storage Image \Analyzer
+  #
+  # This is an abstract base class for image analyzers, which extract width and height from an image attachable.
+  #
+  # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick.new(attachable).metadata
+  #   # => { width: 4104, height: 2736 }
+  class Analyzer::ImageAnalyzer < Analyzer
+    def metadata
+      read_image do |image|
+        if rotated_image?(image)
+          { width: image.height, height: image.width }
+        else
+          { width: image.width, height: image.height }
+        end
+      end
+    end
+
+    private
+
+    def image(tempfile)
+      case @attachable
+      when ActiveStorage::Blob, String
+        blob = @attachable.is_a?(String) ? ActiveStorage::Blob.find_signed!(@attachable) : @attachable
+        image_from_tempfile_path(tempfile, blob)
+      when Hash
+        io = @attachable[:io]
+        if io.is_a?(StringIO)
+          image_from_tempfile_path(tempfile, io)
+        else
+          File.open(io) do |file|
+            image_from_path(file.path)
+          end
+        end
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        image_from_path(@attachable.path)
+      when File
+        supports_file_attachment? ? image_from_path(@attachable.path) : raise_rails_like_error(@attachable)
+      when Pathname
+        supports_pathname_attachment? ? image_from_path(@attachable.to_s) : raise_rails_like_error(@attachable)
+      else
+        raise_rails_like_error(@attachable)
+      end
+    end
+
+    def image_from_tempfile_path(tempfile, file_representation)
+      if file_representation.is_a?(ActiveStorage::Blob)
+        file_representation.download { |chunk| tempfile.write(chunk) }
+      else
+        IO.copy_stream(file_representation, tempfile)
+        file_representation.rewind
+      end
+
+      tempfile.flush
+      tempfile.rewind
+      image_from_path(tempfile.path)
+    end
+
+    def read_image
+      raise NotImplementedError
+    end
+
+    def image_from_path(path)
+      raise NotImplementedError
+    end
+
+    def rotated_image?(image)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/active_storage_validations/analyzer/null_analyzer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # = Active Storage Null Analyzer
+  #
+  # This is a fallback analyzer when the attachable media type is not supported
+  # by our gem.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::NullAnalyzer.new(attachable).metadata
+  #   # => {}
+  class Analyzer::NullAnalyzer < Analyzer
+    def metadata
+      {}
+    end
+  end
+end

data/lib/active_storage_validations/analyzer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'shared/asv_attachable'
+require_relative 'shared/asv_loggable'
+
+module ActiveStorageValidations
+  # = Active Storage Validations \Analyzer
+  #
+  # This is an abstract base class for analyzers, which extract metadata from attachables.
+  # See ActiveStorageValidations::Analyzer::ImageAnalyzer for an example of a concrete subclass.
+  #
+  # Heavily (not to say 100%) inspired by Rails own ActiveStorage::Analyzer
+  class Analyzer
+    include ASVAttachable
+    include ASVLoggable
+
+    attr_reader :attachable
+
+    def initialize(attachable)
+      @attachable = attachable
+    end
+
+    # Override this method in a concrete subclass. Have it return a Hash of metadata.
+    def metadata
+      raise NotImplementedError
+    end
+
+    private
+
+    def instrument(analyzer, &block)
+      ActiveSupport::Notifications.instrument("analyze.active_storage_validations", analyzer: analyzer, &block)
+    end
+  end
+end

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
@@ -9,6 +10,7 @@ require_relative 'shared/asv_symbolizable'
 module ActiveStorageValidations
   class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVOptionable
@@ -53,7 +55,7 @@ module ActiveStorageValidations
     end
 
     def image_metadata_missing?(record, attribute, attachable, flat_options, metadata)
-      return false if metadata[:width].to_i > 0 && metadata[:height].to_i > 0
+      return false if metadata.present? && metadata[:width].to_i > 0 && metadata[:height].to_i > 0
 
       errors_options = initialize_error_options(options, attachable)
       errors_options[:aspect_ratio] = flat_options[:with]

data/lib/active_storage_validations/content_type_spoof_detector.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_loggable'
 require 'open3'
@@ -8,6 +9,7 @@ module ActiveStorageValidations
   class ContentTypeSpoofDetector
     class FileCommandLineToolNotInstalledError < StandardError; end
 
+    include ASVAnalyzable
     include ASVAttachable
     include ASVLoggable
 

data/lib/active_storage_validations/content_type_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
@@ -10,6 +11,7 @@ require_relative 'content_type_spoof_detector'
 module ActiveStorageValidations
   class ContentTypeValidator < ActiveModel::EachValidator # :nodoc:
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVOptionable
@@ -52,27 +54,36 @@ module ActiveStorageValidations
     end
 
     def set_attachable_cached_values(attachable)
-      @attachable_content_type = attachable_content_type(attachable)
+      @attachable_content_type = attachable_content_type_rails_like(attachable)
       @attachable_filename = attachable_filename(attachable).to_s
     end
 
+    # Check if the provided content_type is authorized and not spoofed against
+    # the file io.
     def is_valid?(record, attribute, attachable)
-      extension_matches_content_type?(record, attribute, attachable) &&
-        authorized_content_type?(record, attribute, attachable) &&
+      authorized_content_type?(record, attribute, attachable) &&
         not_spoofing_content_type?(record, attribute, attachable)
     end
 
-    def extension_matches_content_type?(record, attribute, attachable)
-      return true if !@attachable_filename || !@attachable_content_type
-
-      extension = @attachable_filename.split('.').last
-      possible_extensions = Marcel::TYPE_EXTS[@attachable_content_type]
-      return true if possible_extensions && extension.downcase.in?(possible_extensions)
-
-      errors_options = initialize_and_populate_error_options(options, attachable)
-      add_error(record, attribute, ERROR_TYPES.first, **errors_options)
-      false
-    end
+    # Dead code that we keep here for some time, maybe we will find a solution
+    # to this check later? (November 2024)
+    #
+    # We do not perform any validations against the extension because it is an
+    # unreliable source of truth. For example, a `.csv` file could have its
+    # `text/csv` content_type changed to  `application/vnd.ms-excel` because
+    # it had been opened by Excel at some point, making the file extension vs
+    # file content_type check invalid.
+    # def extension_matches_content_type?(record, attribute, attachable)
+    #   return true if !@attachable_filename || !@attachable_content_type
+
+    #   extension = @attachable_filename.split('.').last
+    #   possible_extensions = Marcel::TYPE_EXTS[@attachable_content_type]
+    #   return true if possible_extensions && extension.downcase.in?(possible_extensions)
+
+    #   errors_options = initialize_and_populate_error_options(options, attachable)
+    #   add_error(record, attribute, ERROR_TYPES.first, **errors_options)
+    #   false
+    # end
 
     def authorized_content_type?(record, attribute, attachable)
       attachable_content_type_is_authorized = @authorized_content_types.any? do |authorized_content_type|

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_optionable'
@@ -9,6 +10,7 @@ require_relative 'shared/asv_symbolizable'
 module ActiveStorageValidations
   class DimensionValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVOptionable

data/lib/active_storage_validations/matchers/processable_image_validator_matcher.rb

@@ -43,10 +43,10 @@ module ActiveStorageValidations
         @subject = subject.is_a?(Class) ? subject.new : subject
 
         is_a_valid_active_storage_attribute? &&
-        is_context_valid? &&
-        is_custom_message_valid? &&
-        is_valid_when_image_processable? &&
-        is_invalid_when_image_not_processable?
+          is_context_valid? &&
+          is_custom_message_valid? &&
+          is_valid_when_image_processable? &&
+          is_invalid_when_image_not_processable?
       end
 
       private

data/lib/active_storage_validations/matchers.rb

@@ -27,7 +27,8 @@ module ActiveStorageValidations
 
     def self.mock_metadata(attachment, width, height)
       mock = Struct.new(:metadata).new({ width: width, height: height })
-      stub_method(ActiveStorageValidations::Metadata, :new, mock) do
+
+      stub_method(ActiveStorageValidations::Analyzer, :new, mock) do
         yield
       end
     end

data/lib/active_storage_validations/processable_image_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'shared/asv_active_storageable'
+require_relative 'shared/asv_analyzable'
 require_relative 'shared/asv_attachable'
 require_relative 'shared/asv_errorable'
 require_relative 'shared/asv_symbolizable'
@@ -8,6 +9,7 @@ require_relative 'shared/asv_symbolizable'
 module ActiveStorageValidations
   class ProcessableImageValidator < ActiveModel::EachValidator # :nodoc
     include ASVActiveStorageable
+    include ASVAnalyzable
     include ASVAttachable
     include ASVErrorable
     include ASVSymbolizable

data/lib/active_storage_validations/shared/asv_analyzable.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveStorageValidations
+  # ActiveStorageValidations::ASVAnalyzable
+  #
+  # Validator methods for choosing the right analyzer depending on the file
+  # media type and available third-party analyzers.
+  module ASVAnalyzable
+    extend ActiveSupport::Concern
+
+    DEFAULT_IMAGE_PROCESSOR = :mini_magick.freeze
+
+    private
+
+    def metadata_for(attachable)
+      analyzer_for(attachable).metadata
+    end
+
+    def analyzer_for(attachable)
+      case attachable_media_type(attachable)
+      when "image" then image_analyzer_for(attachable)
+      else fallback_analyzer_for(attachable)
+      end
+    end
+
+    def image_analyzer_for(attachable)
+      case image_processor
+      when :mini_magick
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::ImageMagick.new(attachable)
+      when :vips
+        ActiveStorageValidations::Analyzer::ImageAnalyzer::Vips.new(attachable)
+      end
+    end
+
+    def image_processor
+      # Rails returns nil for default image processor, because it is set in an after initialize callback
+      # https://github.com/rails/rails/blob/main/activestorage/lib/active_storage/engine.rb
+      ActiveStorage.variant_processor || DEFAULT_IMAGE_PROCESSOR
+    end
+
+    def fallback_analyzer_for(attachable)
+      ActiveStorageValidations::Analyzer::NullAnalyzer.new(attachable)
+    end
+  end
+end

data/lib/active_storage_validations/shared/asv_attachable.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../metadata"
-
 module ActiveStorageValidations
   # ActiveStorageValidations::ASVAttachable
   #
@@ -20,7 +18,7 @@ module ActiveStorageValidations
     # to perform file analyses.
     def validate_changed_files_from_metadata(record, attribute)
       attachables_from_changes(record, attribute).each do |attachable|
-        is_valid?(record, attribute, attachable, Metadata.new(attachable).metadata)
+        is_valid?(record, attribute, attachable, metadata_for(attachable))
       end
     end
 
@@ -64,25 +62,67 @@ module ActiveStorageValidations
     def attachable_content_type(attachable)
       full_attachable_content_type(attachable) && full_attachable_content_type(attachable).downcase.split(/[;,\s]/, 2).first
     end
+      
+    # Retrieve the content_type from attachable using the same logic as Rails
+    # ActiveStorage::Blob::Identifiable#identify_content_type
+    def attachable_content_type_rails_like(attachable)
+      Marcel::MimeType.for(
+        attachable_io(attachable, max_byte_size: 4.kilobytes),
+        name: attachable_filename(attachable).to_s,
+        declared_type: full_attachable_content_type(attachable)
+      )
+    end
 
+    # Retrieve the media type of the attachable, which is the first part of the
+    # content type (or mime type).
+    # Possible values are: application/audio/example/font/image/model/text/video
+    def attachable_media_type(attachable)
+      (full_attachable_content_type(attachable) || marcel_content_type_from_filename(attachable)).split("/").first
+    end
+    
     # Retrieve the io from attachable.
-    def attachable_io(attachable)
+    def attachable_io(attachable, max_byte_size: nil)
+      io = case attachable
+           when ActiveStorage::Blob
+             (max_byte_size && supports_blob_download_chunk?) ? attachable.download_chunk(0...max_byte_size) : attachable.download
+           when ActionDispatch::Http::UploadedFile
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when Rack::Test::UploadedFile
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when String
+             blob = ActiveStorage::Blob.find_signed!(attachable)
+             (max_byte_size && supports_blob_download_chunk?) ? blob.download_chunk(0...max_byte_size) : blob.download
+           when Hash
+             max_byte_size ? attachable[:io].read(max_byte_size) : attachable[:io].read
+           when File
+             raise_rails_like_error(attachable) unless supports_file_attachment?
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           when Pathname
+             raise_rails_like_error(attachable) unless supports_pathname_attachment?
+             max_byte_size ? attachable.read(max_byte_size) : attachable.read
+           else
+             raise_rails_like_error(attachable)
+           end
+
+      rewind_attachable_io(attachable)
+      io
+    end
+
+    # Rewind the io attachable.
+    def rewind_attachable_io(attachable)
       case attachable
-      when ActiveStorage::Blob
-        attachable.download
-      when ActionDispatch::Http::UploadedFile
-        attachable.read
-      when Rack::Test::UploadedFile
-        attachable.read
-      when String
-        blob = ActiveStorage::Blob.find_signed!(attachable)
-        blob.download
+      when ActiveStorage::Blob, String
+        # nothing to do
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        attachable.rewind
       when Hash
-        attachable[:io].read
+        attachable[:io].rewind
       when File
-        supports_file_attachment? ? attachable : raise_rails_like_error(attachable)
+        raise_rails_like_error(attachable) unless supports_file_attachment?
+        attachable.rewind
       when Pathname
-        supports_pathname_attachment? ? attachable.read : raise_rails_like_error(attachable)
+        raise_rails_like_error(attachable) unless supports_pathname_attachment?
+        File.open(attachable) { |f| f.rewind }
       else
         raise_rails_like_error(attachable)
       end
@@ -128,6 +168,13 @@ module ActiveStorageValidations
     end
     alias :supports_pathname_attachment? :supports_file_attachment?
 
+    # Check if the current Rails version supports ActiveStorage::Blob#download_chunk
+    #
+    # https://github.com/rails/rails/blob/7-0-stable/activestorage/CHANGELOG.md#rails-700alpha1-september-15-2021
+    def supports_blob_download_chunk?
+      Rails.gem_version >= Gem::Version.new('7.0.0.alpha1')
+    end
+
     # Retrieve the content_type from the file name only
     def marcel_content_type_from_filename(attachable)
       Marcel::MimeType.for(name: attachable_filename(attachable).to_s)

data/lib/active_storage_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveStorageValidations
-  VERSION = '1.3.3'
+  VERSION = '1.3.5'
 end

data/lib/active_storage_validations.rb

@@ -3,6 +3,12 @@
 require 'active_model'
 require 'active_support/concern'
 
+require 'active_storage_validations/analyzer'
+require 'active_storage_validations/analyzer/image_analyzer'
+require 'active_storage_validations/analyzer/image_analyzer/image_magick'
+require 'active_storage_validations/analyzer/image_analyzer/vips'
+require 'active_storage_validations/analyzer/null_analyzer'
+
 require 'active_storage_validations/railtie'
 require 'active_storage_validations/engine'
 require 'active_storage_validations/attached_validator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.5
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2024-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -259,6 +259,11 @@ files:
 - config/locales/vi.yml
 - config/locales/zh-CN.yml
 - lib/active_storage_validations.rb
+- lib/active_storage_validations/analyzer.rb
+- lib/active_storage_validations/analyzer/image_analyzer.rb
+- lib/active_storage_validations/analyzer/image_analyzer/image_magick.rb
+- lib/active_storage_validations/analyzer/image_analyzer/vips.rb
+- lib/active_storage_validations/analyzer/null_analyzer.rb
 - lib/active_storage_validations/aspect_ratio_validator.rb
 - lib/active_storage_validations/attached_validator.rb
 - lib/active_storage_validations/base_size_validator.rb
@@ -285,10 +290,10 @@ files:
 - lib/active_storage_validations/matchers/shared/asv_validatable.rb
 - lib/active_storage_validations/matchers/size_validator_matcher.rb
 - lib/active_storage_validations/matchers/total_size_validator_matcher.rb
-- lib/active_storage_validations/metadata.rb
 - lib/active_storage_validations/processable_image_validator.rb
 - lib/active_storage_validations/railtie.rb
 - lib/active_storage_validations/shared/asv_active_storageable.rb
+- lib/active_storage_validations/shared/asv_analyzable.rb
 - lib/active_storage_validations/shared/asv_attachable.rb
 - lib/active_storage_validations/shared/asv_errorable.rb
 - lib/active_storage_validations/shared/asv_loggable.rb

data/lib/active_storage_validations/metadata.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'shared/asv_loggable'
-
-module ActiveStorageValidations
-  class Metadata
-    include ASVLoggable
-
-    class InvalidImageError < StandardError; end
-
-    attr_reader :attachable
-
-    DEFAULT_IMAGE_PROCESSOR = :mini_magick.freeze
-
-    def initialize(attachable)
-      require_image_processor
-      @attachable = attachable
-    end
-
-    def valid?
-      read_image
-      true
-    rescue InvalidImageError
-      false
-    end
-
-    def metadata
-      read_image do |image|
-        if rotated_image?(image)
-          { width: image.height, height: image.width }
-        else
-          { width: image.width, height: image.height }
-        end
-      end
-    rescue InvalidImageError
-      logger.info "Skipping image analysis because ImageMagick or Vips doesn't support the file"
-      {}
-    end
-
-    private
-
-    def image_processor
-      # Rails returns nil for default image processor, because it is set in an after initialize callback
-      # https://github.com/rails/rails/blob/89d8569abe2564c8187debf32dd3b4e33d6ad983/activestorage/lib/active_storage/engine.rb
-      Rails.application.config.active_storage.variant_processor || DEFAULT_IMAGE_PROCESSOR
-    end
-
-    def require_image_processor
-      case image_processor
-      when :vips then require 'vips' unless defined?(Vips)
-      when :mini_magick then require 'mini_magick' unless defined?(MiniMagick)
-      end
-    end
-
-    def exception_class
-      case image_processor
-      when :vips then Vips::Error
-      when :mini_magick then MiniMagick::Error
-      end
-    end
-
-    def vips_image_processor?
-      image_processor == :vips
-    end
-
-    def read_image
-      is_string = attachable.is_a?(String)
-      if is_string || attachable.is_a?(ActiveStorage::Blob)
-        blob = is_string ? ActiveStorage::Blob.find_signed!(attachable) : attachable
-
-        tempfile = Tempfile.new(["ActiveStorage-#{blob.id}-", blob.filename.extension_with_delimiter])
-        tempfile.binmode
-
-        blob.download do |chunk|
-          tempfile.write(chunk)
-        end
-
-        tempfile.flush
-        tempfile.rewind
-
-        image = new_image_from_path(tempfile.path)
-      else
-        file_path = read_file_path
-        image = new_image_from_path(file_path)
-      end
-
-
-      raise InvalidImageError unless valid_image?(image)
-      yield image if block_given?
-    rescue LoadError, NameError
-      logger.info "Skipping image analysis because the mini_magick or ruby-vips gem isn't installed"
-      {}
-    rescue exception_class => error
-      logger.error "Skipping image analysis due to an #{exception_class.name.split('::').map(&:downcase).join(' ').capitalize} error: #{error.message}"
-      {}
-    ensure
-      image = nil
-    end
-
-    def new_image_from_path(path)
-      if vips_image_processor? && (supported_vips_suffix?(path) || vips_version_below_8_8? || open_uri_tempfile?(path))
-        begin
-          Vips::Image.new_from_file(path)
-        rescue exception_class
-          # We handle cases where an error is raised when reading the attachable
-          # because Vips can throw errors rather than returning false
-          # We stumble upon this issue while reading 0 byte size attachable
-          # https://github.com/janko/image_processing/issues/97
-          false
-        end
-      elsif defined?(MiniMagick)
-        MiniMagick::Image.new(path)
-      end
-    end
-
-    def supported_vips_suffix?(path)
-      Vips::get_suffixes.include?(File.extname(path).downcase)
-    end
-
-    def vips_version_below_8_8?
-      # FYI, Vips 8.8 was released in 2019
-      # https://github.com/libvips/libvips/releases/tag/v8.8.0
-      !Vips::respond_to?(:vips_foreign_get_suffixes)
-    end
-
-    def open_uri_tempfile?(path)
-      # When trying to open urls for 'large' images, OpenURI will return a
-      # tempfile. That tempfile does not have an extension indicating the type
-      # of file. However, Vips will be able to process it anyway.
-      # The 'large' file value is derived from OpenUri::Buffer class (> 10ko)
-      path.split('/').last.starts_with?("open-uri")
-    end
-
-    def valid_image?(image)
-      return false unless image
-
-      vips_image_processor? && image.is_a?(Vips::Image) ? image.avg : image.valid?
-    rescue exception_class
-      false
-    end
-
-    def rotated_image?(image)
-      if vips_image_processor? && image.is_a?(Vips::Image)
-        image.get('exif-ifd0-Orientation').include?('Right-top') ||
-          image.get('exif-ifd0-Orientation').include?('Left-bottom')
-      else
-        %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
-      end
-    rescue exception_class # field "exif-ifd0-Orientation" not found
-      false
-    end
-
-    def read_file_path
-      case attachable
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-        attachable.path
-      when Hash
-        io = attachable.fetch(:io)
-        if io.is_a?(StringIO)
-          tempfile = Tempfile.new([File.basename(attachable[:filename], '.*'), File.extname(attachable[:filename])])
-          tempfile.binmode
-          IO.copy_stream(io, tempfile)
-          io.rewind
-          tempfile.flush
-          tempfile.rewind
-          tempfile.path
-        else
-          File.open(io).path
-        end
-      when File
-        attachable.path
-      when Pathname
-        attachable.to_s
-      else
-        raise "Something wrong with params."
-      end
-    end
-  end
-end