activestorage 5.2.7.1 → 6.1.4.6

data/app/models/active_storage/variant.rb

@@ -1,24 +1,31 @@
 # frozen_string_literal: true
 
-require "active_storage/downloading"
-
 # Image blobs can have variants that are the result of a set of transformations applied to the original.
 # These variants are used to create thumbnails, fixed-size avatars, or any other derivative image from the
 # original.
 #
-# Variants rely on {MiniMagick}[https://github.com/minimagick/minimagick] for the actual transformations
-# of the file, so you must add <tt>gem "mini_magick"</tt> to your Gemfile if you wish to use variants.
+# Variants rely on {ImageProcessing}[https://github.com/janko-m/image_processing] gem for the actual transformations
+# of the file, so you must add <tt>gem "image_processing"</tt> to your Gemfile if you wish to use variants. By
+# default, images will be processed with {ImageMagick}[http://imagemagick.org] using the
+# {MiniMagick}[https://github.com/minimagick/minimagick] gem, but you can also switch to the
+# {libvips}[http://libvips.github.io/libvips/] processor operated by the {ruby-vips}[https://github.com/libvips/ruby-vips]
+# gem).
+#
+#   Rails.application.config.active_storage.variant_processor
+#   # => :mini_magick
+#
+#   Rails.application.config.active_storage.variant_processor = :vips
+#   # => :vips
 #
-# Note that to create a variant it's necessary to download the entire blob file from the service and load it
-# into memory. The larger the image, the more memory is used. Because of this process, you also want to be
-# considerate about when the variant is actually processed. You shouldn't be processing variants inline in a
-# template, for example. Delay the processing to an on-demand controller, like the one provided in
+# Note that to create a variant it's necessary to download the entire blob file from the service. Because of this process,
+# you also want to be considerate about when the variant is actually processed. You shouldn't be processing variants inline
+# in a template, for example. Delay the processing to an on-demand controller, like the one provided in
 # ActiveStorage::RepresentationsController.
 #
 # To refer to such a delayed on-demand variant, simply link to the variant through the resolved route provided
 # by Active Storage like so:
 #
-#   <%= image_tag Current.user.avatar.variant(resize: "100x100") %>
+#   <%= image_tag Current.user.avatar.variant(resize_to_limit: [100, 100]) %>
 #
 # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::RepresentationsController
 # can then produce on-demand.
@@ -27,22 +34,26 @@ require "active_storage/downloading"
 # has already been processed and uploaded to the service, and, if so, just return that. Otherwise it will perform
 # the transformations, upload the variant to the service, and return itself again. Example:
 #
-#   avatar.variant(resize: "100x100").processed.service_url
+#   avatar.variant(resize_to_limit: [100, 100]).processed.url
 #
 # This will create and process a variant of the avatar blob that's constrained to a height and width of 100.
 # Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
 #
-# A list of all possible transformations is available at https://www.imagemagick.org/script/mogrify.php. You can
-# combine as many as you like freely:
+# You can combine any number of ImageMagick/libvips operations into a variant, as well as any macros provided by the
+# ImageProcessing gem (such as +resize_to_limit+):
+#
+#   avatar.variant(resize_to_limit: [800, 800], monochrome: true, rotate: "-90")
+#
+# Visit the following links for a list of available ImageProcessing commands and ImageMagick/libvips operations:
 #
-#   avatar.variant(resize: "100x100", monochrome: true, rotate: "-90")
+# * {ImageProcessing::MiniMagick}[https://github.com/janko-m/image_processing/blob/master/doc/minimagick.md#methods]
+# * {ImageMagick reference}[https://www.imagemagick.org/script/mogrify.php]
+# * {ImageProcessing::Vips}[https://github.com/janko-m/image_processing/blob/master/doc/vips.md#methods]
+# * {ruby-vips reference}[http://www.rubydoc.info/gems/ruby-vips/Vips/Image]
 class ActiveStorage::Variant
-  include ActiveStorage::Downloading
-
-  WEB_IMAGE_CONTENT_TYPES = %w( image/png image/jpeg image/jpg image/gif )
-
   attr_reader :blob, :variation
   delegate :service, to: :blob
+  delegate :content_type, to: :variation
 
   def initialize(blob, variation_or_variation_key)
     @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
@@ -59,18 +70,34 @@ class ActiveStorage::Variant
     "variants/#{blob.key}/#{Digest::SHA256.hexdigest(variation.key)}"
   end
 
-  # Returns the URL of the variant on the service. This URL is intended to be short-lived for security and not used directly
-  # with users. Instead, the +service_url+ should only be exposed as a redirect from a stable, possibly authenticated URL.
-  # Hiding the +service_url+ behind a redirect also gives you the power to change services without updating all URLs. And
-  # it allows permanent URLs that redirect to the +service_url+ to be cached in the view.
+  # Returns the URL of the blob variant on the service. See {ActiveStorage::Blob#url} for details.
   #
   # Use <tt>url_for(variant)</tt> (or the implied form, like +link_to variant+ or +redirect_to variant+) to get the stable URL
   # for a variant that points to the ActiveStorage::RepresentationsController, which in turn will use this +service_call+ method
   # for its redirection.
-  def service_url(expires_in: service.url_expires_in, disposition: :inline)
+  def url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline)
     service.url key, expires_in: expires_in, disposition: disposition, filename: filename, content_type: content_type
   end
 
+  alias_method :service_url, :url
+  deprecate service_url: :url
+
+  # Downloads the file associated with this variant. If no block is given, the entire file is read into memory and returned.
+  # That'll use a lot of RAM for very large files. If a block is given, then the download is streamed and yielded in chunks.
+  def download(&block)
+    service.download key, &block
+  end
+
+  def filename
+    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
+  end
+
+  alias_method :content_type_for_serving, :content_type
+
+  def forced_disposition_for_serving #:nodoc:
+    nil
+  end
+
   # Returns the receiving variant. Allows ActiveStorage::Variant and ActiveStorage::Preview instances to be used interchangeably.
   def image
     self
@@ -82,51 +109,10 @@ class ActiveStorage::Variant
     end
 
     def process
-      open_image do |image|
-        transform image
-        format image
-        upload image
-      end
-    end
-
-
-    def filename
-      if WEB_IMAGE_CONTENT_TYPES.include?(blob.content_type)
-        blob.filename
-      else
-        ActiveStorage::Filename.new("#{blob.filename.base}.png")
-      end
-    end
-
-    def content_type
-      blob.content_type.presence_in(WEB_IMAGE_CONTENT_TYPES) || "image/png"
-    end
-
-
-    def open_image(&block)
-      image = download_image
-
-      begin
-        yield image
-      ensure
-        image.destroy!
+      blob.open do |input|
+        variation.transform(input) do |output|
+          service.upload(key, output, content_type: content_type)
+        end
       end
     end
-
-    def download_image
-      require "mini_magick"
-      MiniMagick::Image.create(blob.filename.extension_with_delimiter) { |file| download_blob_to(file) }
-    end
-
-    def transform(image)
-      variation.transform(image)
-    end
-
-    def format(image)
-      image.format("PNG") unless WEB_IMAGE_CONTENT_TYPES.include?(blob.content_type)
-    end
-
-    def upload(image)
-      File.open(image.path, "r") { |file| service.upload(key, file) }
-    end
 end

data/app/models/active_storage/variant_record.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ActiveStorage::VariantRecord < ActiveStorage::Record
+  self.table_name = "active_storage_variant_records"
+
+  belongs_to :blob
+  has_one_attached :image
+end

data/app/models/active_storage/variant_with_record.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class ActiveStorage::VariantWithRecord
+  attr_reader :blob, :variation
+
+  def initialize(blob, variation)
+    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation)
+  end
+
+  def processed
+    process
+    self
+  end
+
+  def process
+    transform_blob { |image| create_or_find_record(image: image) } unless processed?
+  end
+
+  def processed?
+    record.present?
+  end
+
+  def image
+    record&.image
+  end
+
+  delegate :key, :url, :download, to: :image, allow_nil: true
+
+  alias_method :service_url, :url
+  deprecate service_url: :url
+
+  private
+    def transform_blob
+      blob.open do |input|
+        variation.transform(input) do |output|
+          yield io: output, filename: "#{blob.filename.base}.#{variation.format.downcase}",
+            content_type: variation.content_type, service_name: blob.service.name
+        end
+      end
+    end
+
+    def create_or_find_record(image:)
+      @record =
+        ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role) do
+          blob.variant_records.create_or_find_by!(variation_digest: variation.digest) do |record|
+            record.image.attach(image)
+          end
+        end
+    end
+
+    def record
+      @record ||= blob.variant_records.find_by(variation_digest: variation.digest)
+    end
+end

data/app/models/active_storage/variation.rb

@@ -1,28 +1,19 @@
 # frozen_string_literal: true
 
+require "mini_mime"
+
 # A set of transformations that can be applied to a blob to create a variant. This class is exposed via
 # the ActiveStorage::Blob#variant method and should rarely be used directly.
 #
 # In case you do need to use this directly, it's instantiated using a hash of transformations where
 # the key is the command and the value is the arguments. Example:
 #
-#   ActiveStorage::Variation.new(resize: "100x100", monochrome: true, trim: true, rotate: "-90")
-#
-# You can also combine multiple transformations in one step, e.g. for center-weighted cropping:
+#   ActiveStorage::Variation.new(resize_to_limit: [100, 100], monochrome: true, trim: true, rotate: "-90")
 #
-#   ActiveStorage::Variation.new(combine_options: {
-#     resize: "100x100^",
-#     gravity: "center",
-#     crop: "100x100+0+0",
-#   })
-#
-# A list of all possible transformations is available at https://www.imagemagick.org/script/mogrify.php.
+# The options map directly to {ImageProcessing}[https://github.com/janko-m/image_processing] commands.
 class ActiveStorage::Variation
   attr_reader :transformations
 
-  class UnsupportedImageProcessingMethod < StandardError; end
-  class UnsupportedImageProcessingArgument < StandardError; end
-
   class << self
     # Returns a Variation instance based on the given variator. If the variator is a Variation, it is
     # returned unmodified. If it is a String, it is passed to ActiveStorage::Variation.decode. Otherwise,
@@ -51,99 +42,44 @@ class ActiveStorage::Variation
   end
 
   def initialize(transformations)
-    @transformations = transformations
+    @transformations = transformations.deep_symbolize_keys
   end
 
-  # Accepts an open MiniMagick image instance, like what's returned by <tt>MiniMagick::Image.read(io)</tt>,
-  # and performs the +transformations+ against it. The transformed image instance is then returned.
-  def transform(image)
+  def default_to(defaults)
+    self.class.new transformations.reverse_merge(defaults)
+  end
+
+  # Accepts a File object, performs the +transformations+ against it, and
+  # saves the transformed image into a temporary file.
+  def transform(file, &block)
     ActiveSupport::Notifications.instrument("transform.active_storage") do
-      transformations.each do |name, argument_or_subtransformations|
-        validate_transformation(name, argument_or_subtransformations)
-        image.mogrify do |command|
-          if name.to_s == "combine_options"
-            argument_or_subtransformations.each do |subtransformation_name, subtransformation_argument|
-              validate_transformation(subtransformation_name, subtransformation_argument)
-              pass_transform_argument(command, subtransformation_name, subtransformation_argument)
-            end
-          else
-            validate_transformation(name, argument_or_subtransformations)
-            pass_transform_argument(command, name, argument_or_subtransformations)
-          end
-        end
+      transformer.transform(file, format: format, &block)
+    end
+  end
+
+  def format
+    transformations.fetch(:format, :png).tap do |format|
+      if MiniMime.lookup_by_extension(format.to_s).nil?
+        raise ArgumentError, "Invalid variant format (#{format.inspect})"
       end
     end
   end
 
+  def content_type
+    MiniMime.lookup_by_extension(format.to_s).content_type
+  end
+
   # Returns a signed key for all the +transformations+ that this variation was instantiated with.
   def key
     self.class.encode(transformations)
   end
 
-  private
-    def pass_transform_argument(command, method, argument)
-      if eligible_argument?(argument)
-        command.public_send(method, argument)
-      else
-        command.public_send(method)
-      end
-    end
-
-    def eligible_argument?(argument)
-      argument.present? && argument != true
-    end
-
-    def validate_transformation(name, argument)
-      method_name = name.to_s.gsub("-","_")
-
-      unless ActiveStorage.supported_image_processing_methods.any? { |method| method_name == method }
-        raise UnsupportedImageProcessingMethod, <<~ERROR.squish
-          One or more of the provided transformation methods is not supported.
-        ERROR
-      end
-
-      if argument.present?
-        if argument.is_a?(String) || argument.is_a?(Symbol)
-          validate_arg_string(argument)
-        elsif argument.is_a?(Array)
-          validate_arg_array(argument)
-        elsif argument.is_a?(Hash)
-          validate_arg_hash(argument)
-        end
-      end
-    end
-
-    def validate_arg_string(argument)
-      if ActiveStorage.unsupported_image_processing_arguments.any? { |bad_arg| argument.to_s.downcase.include?(bad_arg) }; raise UnsupportedImageProcessingArgument end
-    end
-
-    def validate_arg_array(argument)
-      argument.each do |arg|
-        if arg.is_a?(Integer) || arg.is_a?(Float)
-          next
-        elsif arg.is_a?(String) || arg.is_a?(Symbol)
-          validate_arg_string(arg)
-        elsif arg.is_a?(Array)
-          validate_arg_array(arg)
-        elsif arg.is_a?(Hash)
-          validate_arg_hash(arg)
-        end
-      end
-    end
-
-    def validate_arg_hash(argument)
-      argument.each do |key, value|
-        validate_arg_string(key)
+  def digest
+    Digest::SHA1.base64digest Marshal.dump(transformations)
+  end
 
-        if value.is_a?(Integer) || value.is_a?(Float)
-          next
-        elsif value.is_a?(String) || value.is_a?(Symbol)
-          validate_arg_string(value)
-        elsif value.is_a?(Array)
-          validate_arg_array(value)
-        elsif value.is_a?(Hash)
-          validate_arg_hash(value)
-        end
-      end
+  private
+    def transformer
+      ActiveStorage::Transformers::ImageProcessingTransformer.new(transformations.except(:format))
     end
 end

data/config/routes.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 Rails.application.routes.draw do
-  get "/rails/active_storage/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
+  scope ActiveStorage.routes_prefix do
+    get "/blobs/redirect/:signed_id/*filename" => "active_storage/blobs/redirect#show", as: :rails_service_blob
+    get "/blobs/proxy/:signed_id/*filename" => "active_storage/blobs/proxy#show", as: :rails_service_blob_proxy
+    get "/blobs/:signed_id/*filename" => "active_storage/blobs/redirect#show"
 
-  direct :rails_blob do |blob, options|
-    route_for(:rails_service_blob, blob.signed_id, blob.filename, options)
-  end
-
-  resolve("ActiveStorage::Blob")       { |blob, options| route_for(:rails_blob, blob, options) }
-  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.blob, options) }
+    get "/representations/redirect/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/redirect#show", as: :rails_blob_representation
+    get "/representations/proxy/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/proxy#show", as: :rails_blob_representation_proxy
+    get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations/redirect#show"
 
-
-  get "/rails/active_storage/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
+    get  "/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service
+    put  "/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service
+    post "/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+  end
 
   direct :rails_representation do |representation, options|
     signed_blob_id = representation.blob.signed_id
@@ -21,11 +23,60 @@ Rails.application.routes.draw do
     route_for(:rails_blob_representation, signed_blob_id, variation_key, filename, options)
   end
 
-  resolve("ActiveStorage::Variant") { |variant, options| route_for(:rails_representation, variant, options) }
-  resolve("ActiveStorage::Preview") { |preview, options| route_for(:rails_representation, preview, options) }
+  resolve("ActiveStorage::Variant") { |variant, options| route_for(ActiveStorage.resolve_model_to_route, variant, options) }
+  resolve("ActiveStorage::VariantWithRecord") { |variant, options| route_for(ActiveStorage.resolve_model_to_route, variant, options) }
+  resolve("ActiveStorage::Preview") { |preview, options| route_for(ActiveStorage.resolve_model_to_route, preview, options) }
 
+  direct :rails_blob do |blob, options|
+    route_for(:rails_service_blob, blob.signed_id, blob.filename, options)
+  end
+
+  resolve("ActiveStorage::Blob")       { |blob, options| route_for(ActiveStorage.resolve_model_to_route, blob, options) }
+  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(ActiveStorage.resolve_model_to_route, attachment.blob, options) }
 
-  get  "/rails/active_storage/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service
-  put  "/rails/active_storage/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service
-  post "/rails/active_storage/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
-end
+  direct :rails_storage_proxy do |model, options|
+    if model.respond_to?(:signed_id)
+      route_for(
+        :rails_service_blob_proxy,
+        model.signed_id,
+        model.filename,
+        options
+      )
+    else
+      signed_blob_id = model.blob.signed_id
+      variation_key  = model.variation.key
+      filename       = model.blob.filename
+
+      route_for(
+        :rails_blob_representation_proxy,
+        signed_blob_id,
+        variation_key,
+        filename,
+        options
+      )
+    end
+  end
+
+  direct :rails_storage_redirect do |model, options|
+    if model.respond_to?(:signed_id)
+      route_for(
+        :rails_service_blob,
+        model.signed_id,
+        model.filename,
+        options
+      )
+    else
+      signed_blob_id = model.blob.signed_id
+      variation_key  = model.variation.key
+      filename       = model.blob.filename
+
+      route_for(
+        :rails_blob_representation,
+        signed_blob_id,
+        variation_key,
+        filename,
+        options
+      )
+    end
+  end
+end if ActiveStorage.draw_routes

data/db/migrate/20170806125915_create_active_storage_tables.rb

@@ -1,13 +1,14 @@
 class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
   def change
     create_table :active_storage_blobs do |t|
-      t.string   :key,        null: false
-      t.string   :filename,   null: false
+      t.string   :key,          null: false
+      t.string   :filename,     null: false
       t.string   :content_type
       t.text     :metadata
-      t.bigint   :byte_size,  null: false
-      t.string   :checksum,   null: false
-      t.datetime :created_at, null: false
+      t.string   :service_name, null: false
+      t.bigint   :byte_size,    null: false
+      t.string   :checksum,     null: false
+      t.datetime :created_at,   null: false
 
       t.index [ :key ], unique: true
     end
@@ -22,5 +23,13 @@ class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
       t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true
       t.foreign_key :active_storage_blobs, column: :blob_id
     end
+
+    create_table :active_storage_variant_records do |t|
+      t.belongs_to :blob, null: false, index: false
+      t.string :variation_digest, null: false
+
+      t.index %i[ blob_id variation_digest ], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
   end
 end

data/db/update_migrate/20190112182829_add_service_name_to_active_storage_blobs.rb

@@ -0,0 +1,17 @@
+class AddServiceNameToActiveStorageBlobs < ActiveRecord::Migration[6.0]
+  def up
+    unless column_exists?(:active_storage_blobs, :service_name)
+      add_column :active_storage_blobs, :service_name, :string
+
+      if configured_service = ActiveStorage::Blob.service.name
+        ActiveStorage::Blob.unscoped.update_all(service_name: configured_service)
+      end
+
+      change_column :active_storage_blobs, :service_name, :string, null: false
+    end
+  end
+
+  def down
+    remove_column :active_storage_blobs, :service_name
+  end
+end

data/db/update_migrate/20191206030411_create_active_storage_variant_records.rb

@@ -0,0 +1,11 @@
+class CreateActiveStorageVariantRecords < ActiveRecord::Migration[6.0]
+  def change
+    create_table :active_storage_variant_records do |t|
+      t.belongs_to :blob, null: false, index: false
+      t.string :variation_digest, null: false
+
+      t.index %i[ blob_id variation_digest ], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -25,17 +25,27 @@ module ActiveStorage
           { width: image.width, height: image.height }
         end
       end
-    rescue LoadError
-      logger.info "Skipping image analysis because the mini_magick gem isn't installed"
-      {}
     end
 
     private
       def read_image
         download_blob_to_tempfile do |file|
           require "mini_magick"
-          yield MiniMagick::Image.new(file.path)
+          image = MiniMagick::Image.new(file.path)
+
+          if image.valid?
+            yield image
+          else
+            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+            {}
+          end
         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}"
+        {}
       end
 
       def rotated_image?(image)

data/lib/active_storage/analyzer/null_analyzer.rb

@@ -6,6 +6,10 @@ module ActiveStorage
       true
     end
 
+    def self.analyze_later?
+      false
+    end
+
     def metadata
       {}
     end

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/compact"
-
 module ActiveStorage
   # Extracts the following from a video blob:
   #
@@ -13,12 +11,12 @@ module ActiveStorage
   #
   # Example:
   #
-  #   ActiveStorage::VideoAnalyzer.new(blob).metadata
+  #   ActiveStorage::Analyzer::VideoAnalyzer.new(blob).metadata
   #   # => { width: 640.0, height: 480.0, duration: 5.0, angle: 0, display_aspect_ratio: [4, 3] }
   #
   # When a video's angle is 90 or 270 degrees, its width and height are automatically swapped for convenience.
   #
-  # This analyzer requires the {ffmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
   class Analyzer::VideoAnalyzer < Analyzer
     def self.accept?(blob)
       blob.video?
@@ -46,7 +44,8 @@ module ActiveStorage
       end
 
       def duration
-        Float(video_stream["duration"]) if video_stream["duration"]
+        duration = video_stream["duration"] || container["duration"]
+        Float(duration) if duration
       end
 
       def angle
@@ -100,16 +99,26 @@ module ActiveStorage
         probe["streams"] || []
       end
 
+      def container
+        probe["format"] || {}
+      end
+
       def probe
-        download_blob_to_tempfile { |file| probe_from(file) }
+        @probe ||= download_blob_to_tempfile { |file| probe_from(file) }
       end
 
       def probe_from(file)
-        IO.popen([ ffprobe_path, "-print_format", "json", "-show_streams", "-v", "error", file.path ]) do |output|
+        IO.popen([ ffprobe_path,
+          "-print_format", "json",
+          "-show_streams",
+          "-show_format",
+          "-v", "error",
+          file.path
+        ]) do |output|
           JSON.parse(output.read)
         end
       rescue Errno::ENOENT
-        logger.info "Skipping video analysis because ffmpeg isn't installed"
+        logger.info "Skipping video analysis because FFmpeg isn't installed"
         {}
       end