active_storage_validations 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77830eb3fb31d94775a69c7c76aceecc968c359359c2652221d5bfb75469ed4c
-  data.tar.gz: ae4fb05883cf2fc96f8f01a6a893949ca1c567a502cbfbb98c53b37b6809287e
+  metadata.gz: 90da6d94caed4f46393b01b35be7b3d0015304c991c4a04919122ec0256a2692
+  data.tar.gz: 3ea9462025ac280ac8201f46448c721e4d6633fcb13403c0fce75a5e89b841ad
 SHA512:
-  metadata.gz: 1993163590b8360ff78542812a3e69f842de7f2b9868351a9c4bddf60a51c8cbc243d1abd676c0b767581ab3a9063d8fa112739170a8d6b721252d8e0fae9456
-  data.tar.gz: abf00aa0ac44061f51a884b9362104b1d660311d6f4ac8f6cc3d464ff3cc695da0fe7dbb8eba549aa11d51ef09384ec1e486a89c8fe27497b614b8de9f962020
+  metadata.gz: efdb486d80faeb8fd8a0d629f8c666cd34d7936d43d6b15a4806c169258f4c203fcd25618988af5e50c93a8b6020e64f4fabd30d6b16560cbda3e5553ce2699b
+  data.tar.gz: 7b588e741bb0dbb44c0fa5c1506b37711d13eb605098ed4e04e27ec02450ab902c76364e9d72fb4b1a246c6ed641c611640c632ebbfb44835a82bc0e6e74a6ed

data/README.md

@@ -13,6 +13,7 @@ This gems doing it for you. Just use `attached: true` or `content_type: 'image/p
 * validates size of files
 * validates dimension of images/videos
 * validates number of uploaded files (min/max required)
+* validates aspect ratio (if square, portrait, landscape, is_16_9, ...)
 * custom error messages
 
 ## Usage
@@ -31,6 +32,9 @@ class User < ApplicationRecord
   validates :photos, attached: true, content_type: ['image/png', 'image/jpg', 'image/jpeg'],
                                      dimension: { width: { min: 800, max: 2400 },
                                                   height: { min: 600, max: 1800 }, message: 'is not given between dimension' }
+  validates :image, attached: true, 
+                    content_type: ['image/png', 'image/jpg'],
+                    aspect_ratio: :landscape
 end
 ```
 
@@ -91,6 +95,7 @@ en:
       content_type_invalid: "has an invalid content type"
       file_size_out_of_range: "size %{file_size} is not between required range"
       limit_out_of_range: "total number is out of range"
+      image_metadata_missing: "is not a valid image"
       dimension_min_inclusion: "must be greater than or equal to %{width} x %{height} pixel."
       dimension_max_inclusion: "must be less than or equal to %{width} x %{height} pixel."
       dimension_width_inclusion: "width is not included between %{min} and %{max} pixel."
@@ -101,6 +106,12 @@ en:
       dimension_height_less_than_or_equal_to: "height must be less than or equal to %{length} pixel."
       dimension_width_equal_to: "width must be equal to %{length} pixel."
       dimension_height_equal_to: "height must be equal to %{length} pixel."
+      aspect_ratio_not_square: "doesn't a square image"
+      aspect_ratio_not_portrait: "doesn't contain a portrait image"
+      aspect_ratio_not_landscape: "doesn't contain a landscape image"
+      aspect_ratio_is_not: "doesn't contain aspect ratio of %{aspect_ratio}"
+      aspect_ratio_unknown: "has an unknown aspect ratio"
+
 ```
 
 In some cases Active Storage Validations provides variables to help you customize messages:
@@ -128,10 +139,11 @@ limit_out_of_range: "total number is out of range. range: [%{min}, %{max}]"
 Add this line to your application's Gemfile:
 
 ```ruby
+# Rails 5.2 and Rails 6
 gem 'active_storage_validations'
 
-# Optional, to use :dimension validator
-gem 'mini_magick'
+# Optional, to use :dimension validator or :aspect_ratio validator
+gem 'mini_magick', '>= 4.9.5'
 ```
 
 And then execute:
@@ -156,7 +168,10 @@ Very simple example of validation with file attached, content type check and cus
 
 ## Tests & Contributing
 
-To run tests in root folder of gem `rake test`.
+To run tests in root folder of gem:
+
+* `BUNDLE_GEMFILE=gemfiles/rails_5_2.gemfile bundle exec rake test` to run for Rails 5.2
+* `BUNDLE_GEMFILE=gemfiles/rails_6.0.gemfile bundle exec rake test` to run for Rails 6.0
 
 To play with app `cd test/dummy` and `rails s -b 0.0.0.0` (before `rails db:migrate`).
 

data/config/locales/de.yml

@@ -4,6 +4,7 @@ de:
       content_type_invalid: "hat einen ungültigen Dateityp"
       file_size_out_of_range: "Dateigröße von %{file_size} ist außerhalb des erlaubten Bereichs"
       limit_out_of_range: "Anzahl ist außerhalb des gültigen Bereichs"
+      image_metadata_missing: "ist nicht ein gültigen Bild"
       dimension_min_inclusion: "muss größer oder gleich %{width} x %{height} Pixel sein"
       dimension_max_inclusion: "muss kleiner oder gleich %{width} x %{height} Pixel sein"
       dimension_width_inclusion: "Breite ist nicht zwischen %{min} und %{max} Pixel enthalten"

data/config/locales/en.yml

@@ -4,6 +4,7 @@ en:
       content_type_invalid: "has an invalid content type"
       file_size_out_of_range: "size %{file_size} is not between required range"
       limit_out_of_range: "total number is out of range"
+      image_metadata_missing: "is not a valid image"
       dimension_min_inclusion: "must be greater than or equal to %{width} x %{height} pixel"
       dimension_max_inclusion: "must be less than or equal to %{width} x %{height} pixel"
       dimension_width_inclusion: "width is not included between %{min} and %{max} pixel"
@@ -14,3 +15,8 @@ en:
       dimension_height_less_than_or_equal_to: "height must be less than or equal to %{length} pixel"
       dimension_width_equal_to: "width must be equal to %{length} pixel"
       dimension_height_equal_to: "height must be equal to %{length} pixel"
+      aspect_ratio_not_square: "doesn't a square image"
+      aspect_ratio_not_portrait: "doesn't contain a portrait image"
+      aspect_ratio_not_landscape: "doesn't contain a landscape image"
+      aspect_ratio_is_not: "doesn't contain aspect ratio of %{aspect_ratio}"
+      aspect_ratio_unknown: "has an unknown aspect ratio"

data/lib/active_storage_validations.rb

@@ -7,6 +7,7 @@ require 'active_storage_validations/content_type_validator'
 require 'active_storage_validations/size_validator'
 require 'active_storage_validations/limit_validator'
 require 'active_storage_validations/dimension_validator'
+require 'active_storage_validations/aspect_ratio_validator'
 
 ActiveSupport.on_load(:active_record) do
   send :include, ActiveStorageValidations

data/lib/active_storage_validations/aspect_ratio_validator.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative 'metadata.rb'
+
+if Rails::VERSION::MAJOR >= 6
+  module ActiveStorageValidations
+    class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
+      AVAILABLE_CHECKS = %i[with].freeze
+      PRECISION = 3
+
+      def initialize(options)
+        require 'mini_magick' unless defined?(MiniMagick)
+        super(options)
+      end
+
+
+      def check_validity!
+        return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass "aspect_ratio: :OPTION" option to the validator'
+      end
+
+
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+
+        changes = record.attachment_changes[attribute.to_s]
+        return true if changes.blank?
+
+        files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
+
+        files.each do |file|
+          metadata = Metadata.new(file).metadata
+          next if is_valid?(record, attribute, metadata)
+          break
+        end
+      end
+
+
+      private
+
+
+      def is_valid?(record, attribute, metadata)
+        if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
+          add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+          return false
+        end
+
+        case options[:with]
+        when :square
+          return true if metadata[:width] == metadata[:height]
+          add_error(record, attribute, :aspect_ratio_not_square)
+
+        when :portrait
+          return true if metadata[:height] > metadata[:width]
+          add_error(record, attribute, :aspect_ratio_not_portrait)
+
+        when :landscape
+          return true if metadata[:width] > metadata[:height]
+          add_error(record, attribute, :aspect_ratio_not_landscape)
+
+        else
+          if options[:with] =~ /is\_(\d*)\_(\d*)/
+            x = $1.to_i
+            y = $2.to_i
+
+            return true if (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+
+            add_error(record, attribute, :aspect_ratio_is_not, "#{x}x#{y}")
+          else
+            add_error(record, attribute, :aspect_ratio_unknown)
+          end
+        end
+        false
+      end
+
+
+      def add_error(record, attribute, type, interpolate = options[:with])
+        key = options[:message].presence || type
+        return if record.errors.added?(attribute, key)
+        record.errors.add(attribute, key, aspect_ratio: interpolate)
+      end
+
+    end
+  end
+
+else
+  # Rails 5
+  module ActiveStorageValidations
+    class AspectRatioValidator < ActiveModel::EachValidator # :nodoc
+      AVAILABLE_CHECKS = %i[with].freeze
+      PRECISION = 3
+
+      def initialize(options)
+        require 'mini_magick' unless defined?(MiniMagick)
+        super(options)
+      end
+
+
+      def check_validity!
+        return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass "aspect_ratio: :OPTION" option to the validator'
+      end
+
+
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+  
+        files = Array.wrap(record.send(attribute))
+  
+        files.each do |file|
+          # Analyze file first if not analyzed to get all required metadata.
+          file.analyze; file.reload unless file.analyzed?
+          metadata = file.metadata
+  
+          next if is_valid?(record, attribute, metadata)
+          break
+        end
+      end
+
+
+      private
+
+
+      def is_valid?(record, attribute, metadata)
+        if metadata[:width].to_i <= 0 || metadata[:height].to_i <= 0
+          add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+          return false
+        end
+
+        case options[:with]
+        when :square
+          return true if metadata[:width] == metadata[:height]
+          add_error(record, attribute, :aspect_ratio_not_square)
+
+        when :portrait
+          return true if metadata[:height] > metadata[:width]
+          add_error(record, attribute, :aspect_ratio_not_portrait)
+
+        when :landscape
+          return true if metadata[:width] > metadata[:height]
+          add_error(record, attribute, :aspect_ratio_not_landscape)
+
+        else
+          if options[:with] =~ /is\_(\d*)\_(\d*)/
+            x = $1.to_i
+            y = $2.to_i
+
+            return true if (x.to_f / y).round(PRECISION) == (metadata[:width].to_f / metadata[:height]).round(PRECISION)
+
+            add_error(record, attribute, :aspect_ratio_is_not, "#{x}x#{y}")
+          else
+            add_error(record, attribute, :aspect_ratio_unknown)
+          end
+        end
+        false
+      end
+
+
+      def add_error(record, attribute, type, interpolate = options[:with])
+        key = options[:message].presence || type
+        return if record.errors.added?(attribute, key)
+        record.errors.add(attribute, key, aspect_ratio: interpolate)
+      end
+
+    end
+  end
+end

data/lib/active_storage_validations/dimension_validator.rb

@@ -1,98 +1,229 @@
 # frozen_string_literal: true
 
-module ActiveStorageValidations
-  class DimensionValidator < ActiveModel::EachValidator # :nodoc
-    AVAILABLE_CHECKS = %i[width height min max].freeze
-
-    def initialize(options)
-      require 'mini_magick'
-
-      [:width, :height].each do |length|
-        if options[length] and options[length].is_a?(Hash)
-          if range = options[length][:in]
-            raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
-            options[length][:min], options[length][:max] = range.min, range.max
+require_relative 'metadata.rb'
+
+if Rails::VERSION::MAJOR >= 6
+  module ActiveStorageValidations
+    class DimensionValidator < ActiveModel::EachValidator # :nodoc
+      AVAILABLE_CHECKS = %i[width height min max].freeze
+
+      def initialize(options)
+        require 'mini_magick' unless defined?(MiniMagick)
+
+        [:width, :height].each do |length|
+          if options[length] and options[length].is_a?(Hash)
+            if range = options[length][:in]
+              raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
+              options[length][:min], options[length][:max] = range.min, range.max
+            end
           end
         end
-      end
-      [:min, :max].each do |dim|
-        if range = options[dim]
-          raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
-          options[:width] = { dim => range.first }
-          options[:height] = { dim => range.last }
+        [:min, :max].each do |dim|
+          if range = options[dim]
+            raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
+            options[:width] = { dim => range.first }
+            options[:height] = { dim => range.last }
+          end
         end
+        super
       end
-      super
-    end
 
 
-    def check_validity!
-      return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
-      raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
-    end
+      def check_validity!
+        return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
+      end
+
 
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+
+        changes = record.attachment_changes[attribute.to_s]
+        return true if changes.blank?
+
+        files = Array.wrap(changes.is_a?(ActiveStorage::Attached::Changes::CreateMany) ? changes.attachables : changes.attachable)
+        files.each do |file|
+          metadata = Metadata.new(file).metadata
+          next if is_valid?(record, attribute, metadata)
+          break
+        end
+      end
 
-    def validate_each(record, attribute, _value)
-      return true unless record.send(attribute).attached?
 
-      files = Array.wrap(record.send(attribute))
+      def is_valid?(record, attribute, file_metadata)
+        # Validation fails unless file metadata contains valid width and height.
+        if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
+          add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+          return false
+        end
 
-      files.each do |file|
-        # Analyze file first if not analyzed to get all required metadata.
-        file.analyze; file.reload unless file.analyzed?
+        # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
+        if options[:min] || options[:max]
+          if options[:min] && (
+            (options[:width][:min] && file_metadata[:width] < options[:width][:min]) ||
+            (options[:height][:min] && file_metadata[:height] < options[:height][:min])
+            )
+            add_error(record, attribute, options[:message].presence || :"dimension_min_inclusion", width: options[:width][:min], height: options[:height][:min])
+            return false
+          end
+          if options[:max] && (
+            (options[:width][:max] && file_metadata[:width] > options[:width][:max]) ||
+            (options[:height][:max] && file_metadata[:height] > options[:height][:max])
+            )
+            add_error(record, attribute, options[:message].presence || :"dimension_max_inclusion", width: options[:width][:max], height: options[:height][:max])
+            return false
+          end
 
-        # File has no dimension and no width and height in metadata.
-        raise StandardError, 'File has no dimension and no width and height in metadata' unless (['width', 'height'] - file.metadata.keys).empty?
+        # Validation based on checks :width and :height.
+        else
+          [:width, :height].each do |length|
+            next unless options[length]
+            if options[length].is_a?(Hash)
+              if options[length][:in] && (file_metadata[length] < options[length][:min] || file_metadata[length] > options[length][:max])
+                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_inclusion", min: options[length][:min], max: options[length][:max])
+                return false
+              else
+                if options[length][:min] && file_metadata[length] < options[length][:min]
+                  add_error(record, attribute, options[:message].presence || :"dimension_#{length}_greater_than_or_equal_to", length: options[length][:min])
+                  return false
+                end
+                if options[length][:max] && file_metadata[length] > options[length][:max]
+                  add_error(record, attribute, options[:message].presence || :"dimension_#{length}_less_than_or_equal_to", length: options[length][:max])
+                  return false
+                end
+              end
+            else
+              if file_metadata[length] != options[length]
+                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_equal_to", length: options[length])
+                return false            
+              end
+            end
+          end
+        end
 
-        next if dimension_valid?(record, attribute, file.metadata)
-        break
+        true # valid file
       end
+
+      def add_error(record, attribute, type, *attrs)
+        key = options[:message].presence || type
+        return if record.errors.added?(attribute, key)
+        record.errors.add(attribute, key, *attrs)
+      end    
+
     end
+  end
+
 
 
-    def dimension_valid?(record, attribute, file_metadata)
-      valid = true
+else
+  # Rails 5
+  module ActiveStorageValidations
+    class DimensionValidator < ActiveModel::EachValidator # :nodoc
+      AVAILABLE_CHECKS = %i[width height min max].freeze
 
-      # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
-      if options[:min] || options[:max]
-        if options[:min] && (
-           (options[:width][:min] && file_metadata[:width] < options[:width][:min]) ||
-           (options[:height][:min] && file_metadata[:height] < options[:height][:min])
-          )
-          valid = record.errors.add(attribute, options[:message].presence || :"dimension_min_inclusion", width: options[:width][:min], height: options[:height][:min]).empty?
+      def initialize(options)
+        require 'mini_magick' unless defined?(MiniMagick)
+
+        [:width, :height].each do |length|
+          if options[length] and options[length].is_a?(Hash)
+            if range = options[length][:in]
+              raise ArgumentError, ":in must be a Range" unless range.is_a?(Range)
+              options[length][:min], options[length][:max] = range.min, range.max
+            end
+          end
         end
-        if options[:max] && (
-           (options[:width][:max] && file_metadata[:width] > options[:width][:max]) ||
-           (options[:height][:max] && file_metadata[:height] > options[:height][:max])
-          )
-          valid = record.errors.add(attribute, options[:message].presence || :"dimension_max_inclusion", width: options[:width][:max], height: options[:height][:max]).empty?
+        [:min, :max].each do |dim|
+          if range = options[dim]
+            raise ArgumentError, ":#{dim} must be a Range (width..height)" unless range.is_a?(Range)
+            options[:width] = { dim => range.first }
+            options[:height] = { dim => range.last }
+          end
         end
+        super
+      end
 
-      # Validation based on checks :width and :height.
-      else
-        [:width, :height].each do |length|
-          next unless options[length]
-          if options[length].is_a?(Hash)
-            if options[length][:in] && (file_metadata[length] < options[length][:min] || file_metadata[length] > options[length][:max])
-              valid = record.errors.add(attribute, options[:message].presence || :"dimension_#{length}_inclusion", min: options[length][:min], max: options[length][:max]).empty?
-            else
-              if options[length][:min] && file_metadata[length] < options[length][:min]
-                valid = record.errors.add(attribute, options[:message].presence || :"dimension_#{length}_greater_than_or_equal_to", length: options[length][:min]).empty?
+
+      def check_validity!
+        return true if AVAILABLE_CHECKS.any? { |argument| options.key?(argument) }
+        raise ArgumentError, 'You must pass either :width, :height, :min or :max to the validator'
+      end
+
+
+      def validate_each(record, attribute, _value)
+        return true unless record.send(attribute).attached?
+  
+        files = Array.wrap(record.send(attribute))
+        files.each do |file|
+          # Analyze file first if not analyzed to get all required metadata.
+          file.analyze; file.reload unless file.analyzed?
+          metadata = file.metadata rescue {}
+          next if is_valid?(record, attribute, metadata)
+          break
+        end
+      end
+
+
+      def is_valid?(record, attribute, file_metadata)
+        # Validation fails unless file metadata contains valid width and height.
+        if file_metadata[:width].to_i <= 0 || file_metadata[:height].to_i <= 0
+          add_error(record, attribute, options[:message].presence || :image_metadata_missing)
+          return false
+        end
+
+        # Validation based on checks :min and :max (:min, :max has higher priority to :width, :height).
+        if options[:min] || options[:max]
+          if options[:min] && (
+            (options[:width][:min] && file_metadata[:width] < options[:width][:min]) ||
+            (options[:height][:min] && file_metadata[:height] < options[:height][:min])
+            )
+            add_error(record, attribute, options[:message].presence || :"dimension_min_inclusion", width: options[:width][:min], height: options[:height][:min])
+            return false
+          end
+          if options[:max] && (
+            (options[:width][:max] && file_metadata[:width] > options[:width][:max]) ||
+            (options[:height][:max] && file_metadata[:height] > options[:height][:max])
+            )
+            add_error(record, attribute, options[:message].presence || :"dimension_max_inclusion", width: options[:width][:max], height: options[:height][:max])
+            return false
+          end
+
+        # Validation based on checks :width and :height.
+        else
+          [:width, :height].each do |length|
+            next unless options[length]
+            if options[length].is_a?(Hash)
+              if options[length][:in] && (file_metadata[length] < options[length][:min] || file_metadata[length] > options[length][:max])
+                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_inclusion", min: options[length][:min], max: options[length][:max])
+                return false
+              else
+                if options[length][:min] && file_metadata[length] < options[length][:min]
+                  add_error(record, attribute, options[:message].presence || :"dimension_#{length}_greater_than_or_equal_to", length: options[length][:min])
+                  return false
+                end
+                if options[length][:max] && file_metadata[length] > options[length][:max]
+                  add_error(record, attribute, options[:message].presence || :"dimension_#{length}_less_than_or_equal_to", length: options[length][:max])
+                  return false
+                end
               end
-              if options[length][:max] && file_metadata[length] > options[length][:max]
-                valid = record.errors.add(attribute, options[:message].presence || :"dimension_#{length}_less_than_or_equal_to", length: options[length][:max]).empty?
+            else
+              if file_metadata[length] != options[length]
+                add_error(record, attribute, options[:message].presence || :"dimension_#{length}_equal_to", length: options[length])
+                return false            
               end
             end
-          else
-            if file_metadata[length] != options[length]
-              valid = record.errors.add(attribute, options[:message].presence || :"dimension_#{length}_equal_to", length: options[length]).empty?
-            end
           end
         end
+
+        true # valid file
       end
 
-      valid
-    end
+      def add_error(record, attribute, type, *attrs)
+        key = options[:message].presence || type
+        return if record.errors.added?(attribute, key)
+        record.errors.add(attribute, key, *attrs)
+      end    
 
+    end
   end
-end
+
+end

data/lib/active_storage_validations/metadata.rb

@@ -0,0 +1,76 @@
+module ActiveStorageValidations
+  class Metadata
+    attr_reader :file
+
+    def initialize(file)
+      @file = file
+    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
+    end
+
+    private
+
+    def read_image
+      if file.is_a?(String)
+        blob = ActiveStorage::Blob.find_signed(file)
+
+        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 = MiniMagick::Image.new(tempfile.path)
+      else
+        image = MiniMagick::Image.new(read_file_path)
+      end
+
+      if image.valid?
+        yield image
+      else
+        logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+        {}
+      end
+    rescue LoadError
+      logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+      {}
+    rescue MiniMagick::Error => error
+      logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+      {}
+    ensure
+      image = nil
+    end
+
+    def rotated_image?(image)
+      %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
+    end
+
+    def read_file_path
+      case file
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        file.path
+      when Hash
+        File.open(file.fetch(:io)).path
+      else
+        raise "Something wrong with params."
+      end
+    end
+
+    def logger
+      Rails.logger
+    end
+
+  end
+end

data/lib/active_storage_validations/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_storage_validations
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Igor Kasyanchuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-22 00:00:00.000000000 Z
+date: 2019-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: 4.9.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: 4.9.5
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Validations for Active Storage (presence)
 email:
 - igorkasyanchuk@gmail.com
@@ -93,16 +107,18 @@ files:
 - config/locales/de.yml
 - config/locales/en.yml
 - lib/active_storage_validations.rb
+- lib/active_storage_validations/aspect_ratio_validator.rb
 - lib/active_storage_validations/attached_validator.rb
 - lib/active_storage_validations/content_type_validator.rb
 - lib/active_storage_validations/dimension_validator.rb
 - lib/active_storage_validations/engine.rb
 - lib/active_storage_validations/limit_validator.rb
+- lib/active_storage_validations/metadata.rb
 - lib/active_storage_validations/railtie.rb
 - lib/active_storage_validations/size_validator.rb
 - lib/active_storage_validations/version.rb
 - lib/tasks/active_storage_validations_tasks.rake
-homepage: https://github.com/igorkasyanchuk
+homepage: https://github.com/igorkasyanchuk/active_storage_validations
 licenses:
 - MIT
 metadata: {}