activestorage 6.1.3.2 → 7.0.0.alpha2

data/app/models/active_storage/current.rb

@@ -1,5 +1,15 @@
 # frozen_string_literal: true
 
-class ActiveStorage::Current < ActiveSupport::CurrentAttributes #:nodoc:
-  attribute :host
+class ActiveStorage::Current < ActiveSupport::CurrentAttributes # :nodoc:
+  attribute :url_options
+
+  def host=(host)
+    ActiveSupport::Deprecation.warn("ActiveStorage::Current.host= is deprecated, instead use ActiveStorage::Current.url_options=")
+    self.url_options = { host: host }
+  end
+
+  def host
+    ActiveSupport::Deprecation.warn("ActiveStorage::Current.host is deprecated, instead use ActiveStorage::Current.url_options")
+    self.url_options&.dig(:host)
+  end
 end

data/app/models/active_storage/preview.rb

@@ -66,9 +66,6 @@ class ActiveStorage::Preview
     end
   end
 
-  alias_method :service_url, :url
-  deprecate service_url: :url
-
   # Returns a combination key of the blob and the variation that together identifies a specific variant.
   def key
     if processed?
@@ -78,6 +75,11 @@ class ActiveStorage::Preview
     end
   end
 
+  # Downloads the file associated with this preview's 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. Raises ActiveStorage::Preview::UnprocessedError
+  # if the preview has not been processed yet.
   def download(&block)
     if processed?
       variant.download(&block)
@@ -93,7 +95,7 @@ class ActiveStorage::Preview
 
     def process
       previewer.preview(service_name: blob.service_name) do |attachable|
-        ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role) do
+        ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role) do
           image.attach(attachable)
         end
       end

data/app/models/active_storage/record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class ActiveStorage::Record < ActiveRecord::Base #:nodoc:
+class ActiveStorage::Record < ActiveRecord::Base # :nodoc:
   self.abstract_class = true
 end
 

data/app/models/active_storage/variant.rb

@@ -42,7 +42,7 @@
 # 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")
+#   avatar.variant(resize_to_limit: [800, 800], colourspace: "b-w", rotate: "-90")
 #
 # Visit the following links for a list of available ImageProcessing commands and ImageMagick/libvips operations:
 #
@@ -67,7 +67,7 @@ class ActiveStorage::Variant
 
   # Returns a combination key of the blob and the variation that together identifies a specific variant.
   def key
-    "variants/#{blob.key}/#{Digest::SHA256.hexdigest(variation.key)}"
+    "variants/#{blob.key}/#{OpenSSL::Digest::SHA256.hexdigest(variation.key)}"
   end
 
   # Returns the URL of the blob variant on the service. See {ActiveStorage::Blob#url} for details.
@@ -79,9 +79,6 @@ class ActiveStorage::Variant
     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)
@@ -89,12 +86,12 @@ class ActiveStorage::Variant
   end
 
   def filename
-    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format}"
+    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
   end
 
   alias_method :content_type_for_serving, :content_type
 
-  def forced_disposition_for_serving #:nodoc:
+  def forced_disposition_for_serving # :nodoc:
     nil
   end
 

data/app/models/active_storage/variant_record.rb

@@ -6,3 +6,5 @@ class ActiveStorage::VariantRecord < ActiveStorage::Record
   belongs_to :blob
   has_one_attached :image
 end
+
+ActiveSupport.run_load_hooks :active_storage_variant_record, ActiveStorage::VariantRecord

data/app/models/active_storage/variant_with_record.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+# Like an ActiveStorage::Variant, but keeps detail about the variant in the database as an
+# ActiveStorage::VariantRecord. This is only used if `ActiveStorage.track_variants` is enabled.
 class ActiveStorage::VariantWithRecord
   attr_reader :blob, :variation
+  delegate :service, to: :blob
 
   def initialize(blob, variation)
     @blob, @variation = blob, ActiveStorage::Variation.wrap(variation)
@@ -26,14 +29,11 @@ class ActiveStorage::VariantWithRecord
 
   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}",
+          yield io: output, filename: "#{blob.filename.base}.#{variation.format.downcase}",
             content_type: variation.content_type, service_name: blob.service.name
         end
       end
@@ -41,7 +41,7 @@ class ActiveStorage::VariantWithRecord
 
     def create_or_find_record(image:)
       @record =
-        ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role) do
+        ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role) do
           blob.variant_records.create_or_find_by!(variation_digest: variation.digest) do |record|
             record.image.attach(image)
           end
@@ -49,6 +49,10 @@ class ActiveStorage::VariantWithRecord
     end
 
     def record
-      @record ||= blob.variant_records.find_by(variation_digest: variation.digest)
+      @record ||= if blob.variant_records.loaded?
+        blob.variant_records.find { |v| v.variation_digest == variation.digest }
+      else
+        blob.variant_records.find_by(variation_digest: variation.digest)
+      end
     end
 end

data/app/models/active_storage/variation.rb

@@ -8,7 +8,7 @@ require "mini_mime"
 # 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_to_limit: [100, 100], monochrome: true, trim: true, rotate: "-90")
+#   ActiveStorage::Variation.new(resize_to_limit: [100, 100], colourspace: "b-w", rotate: "-90", saver: { trim: true })
 #
 # The options map directly to {ImageProcessing}[https://github.com/janko-m/image_processing] commands.
 class ActiveStorage::Variation
@@ -75,7 +75,7 @@ class ActiveStorage::Variation
   end
 
   def digest
-    Digest::SHA1.base64digest Marshal.dump(transformations)
+    OpenSSL::Digest::SHA1.base64digest Marshal.dump(transformations)
   end
 
   private

data/config/routes.rb

@@ -16,11 +16,7 @@ Rails.application.routes.draw do
   end
 
   direct :rails_representation do |representation, options|
-    signed_blob_id = representation.blob.signed_id
-    variation_key  = representation.variation.key
-    filename       = representation.blob.filename
-
-    route_for(:rails_blob_representation, signed_blob_id, variation_key, filename, options)
+    route_for(ActiveStorage.resolve_model_to_route, representation, options)
   end
 
   resolve("ActiveStorage::Variant") { |variant, options| route_for(ActiveStorage.resolve_model_to_route, variant, options) }
@@ -28,22 +24,24 @@ Rails.application.routes.draw do
   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)
+    route_for(ActiveStorage.resolve_model_to_route, blob, 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) }
 
   direct :rails_storage_proxy do |model, options|
+    expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+
     if model.respond_to?(:signed_id)
       route_for(
         :rails_service_blob_proxy,
-        model.signed_id,
+        model.signed_id(expires_in: expires_in),
         model.filename,
         options
       )
     else
-      signed_blob_id = model.blob.signed_id
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in)
       variation_key  = model.variation.key
       filename       = model.blob.filename
 
@@ -58,15 +56,17 @@ Rails.application.routes.draw do
   end
 
   direct :rails_storage_redirect do |model, options|
+    expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+
     if model.respond_to?(:signed_id)
       route_for(
         :rails_service_blob,
-        model.signed_id,
+        model.signed_id(expires_in: expires_in),
         model.filename,
         options
       )
     else
-      signed_blob_id = model.blob.signed_id
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in)
       variation_key  = model.variation.key
       filename       = model.blob.filename
 

data/db/migrate/20170806125915_create_active_storage_tables.rb

@@ -1,6 +1,9 @@
 class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
   def change
-    create_table :active_storage_blobs do |t|
+    # Use Active Record's configured type for primary and foreign keys
+    primary_key_type, foreign_key_type = primary_and_foreign_key_types
+
+    create_table :active_storage_blobs, id: primary_key_type do |t|
       t.string   :key,          null: false
       t.string   :filename,     null: false
       t.string   :content_type
@@ -8,28 +11,46 @@ class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
       t.string   :service_name, null: false
       t.bigint   :byte_size,    null: false
       t.string   :checksum,     null: false
-      t.datetime :created_at,   null: false
+
+      if connection.supports_datetime_with_precision?
+        t.datetime :created_at, precision: 6, null: false
+      else
+        t.datetime :created_at, null: false
+      end
 
       t.index [ :key ], unique: true
     end
 
-    create_table :active_storage_attachments do |t|
+    create_table :active_storage_attachments, id: primary_key_type do |t|
       t.string     :name,     null: false
-      t.references :record,   null: false, polymorphic: true, index: false
-      t.references :blob,     null: false
+      t.references :record,   null: false, polymorphic: true, index: false, type: foreign_key_type
+      t.references :blob,     null: false, type: foreign_key_type
 
-      t.datetime :created_at, null: false
+      if connection.supports_datetime_with_precision?
+        t.datetime :created_at, precision: 6, null: false
+      else
+        t.datetime :created_at, null: false
+      end
 
       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
+    create_table :active_storage_variant_records, id: primary_key_type do |t|
+      t.belongs_to :blob, null: false, index: false, type: foreign_key_type
       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
+
+  private
+    def primary_and_foreign_key_types
+      config = Rails.configuration.generators
+      setting = config.options[config.orm][:primary_key_type]
+      primary_key_type = setting || :primary_key
+      foreign_key_type = setting || :bigint
+      [primary_key_type, foreign_key_type]
+    end
 end

data/db/update_migrate/20191206030411_create_active_storage_variant_records.rb

@@ -1,11 +1,24 @@
 class CreateActiveStorageVariantRecords < ActiveRecord::Migration[6.0]
   def change
-    create_table :active_storage_variant_records do |t|
-      t.belongs_to :blob, null: false, index: false
+    # Use Active Record's configured type for primary key
+    create_table :active_storage_variant_records, id: primary_key_type do |t|
+      t.belongs_to :blob, null: false, index: false, type: blobs_primary_key_type
       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
+
+  private
+    def primary_key_type
+      config = Rails.configuration.generators
+      config.options[config.orm][:primary_key_type] || :primary_key
+    end
+
+    def blobs_primary_key_type
+      pkey_name = connection.primary_key(:active_storage_blobs)
+      pkey_column = connection.columns(:active_storage_blobs).find { |c| c.name == pkey_name }
+      pkey_column.bigint? ? :bigint : pkey_column.type
+    end
 end

data/lib/active_storage/analyzer/audio_analyzer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Extracts duration (seconds) and bit_rate (bits/s) from an audio blob.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::AudioAnalyzer.new(blob).metadata
+  #   # => { duration: 5.0, bit_rate: 320340 }
+  #
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  class Analyzer::AudioAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.audio?
+    end
+
+    def metadata
+      { duration: duration, bit_rate: bit_rate }.compact
+    end
+
+    private
+      def duration
+        duration = audio_stream["duration"]
+        Float(duration) if duration
+      end
+
+      def bit_rate
+        bit_rate = audio_stream["bit_rate"]
+        Integer(bit_rate) if bit_rate
+      end
+
+      def audio_stream
+        @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
+      end
+
+      def streams
+        probe["streams"] || []
+      end
+
+      def probe
+        @probe ||= download_blob_to_tempfile { |file| probe_from(file) }
+      end
+
+      def probe_from(file)
+        instrument(File.basename(ffprobe_path)) do
+          IO.popen([ ffprobe_path,
+            "-print_format", "json",
+            "-show_streams",
+            "-show_format",
+            "-v", "error",
+            file.path
+          ]) do |output|
+            JSON.parse(output.read)
+          end
+        end
+      rescue Errno::ENOENT
+        logger.info "Skipping audio analysis because FFmpeg isn't installed"
+        {}
+      end
+
+      def ffprobe_path
+        ActiveStorage.paths[:ffprobe] || "ffprobe"
+      end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem. MiniMagick requires
+  # the {ImageMagick}[http://www.imagemagick.org] system library.
+  class Analyzer::ImageAnalyzer::ImageMagick < Analyzer::ImageAnalyzer
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :mini_magick
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "mini_magick"
+
+          image = instrument("mini_magick") do
+            MiniMagick::Image.new(file.path)
+          end
+
+          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)
+        %w[ RightTop LeftBottom TopRight BottomLeft ].include?(image["%[orientation]"])
+      end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # 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
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :vips
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "ruby-vips"
+
+          image = instrument("vips") do
+            ::Vips::Image.new_from_file(file.path, access: :sequential)
+          end
+
+          if valid_image?(image)
+            yield image
+          else
+            logger.info "Skipping image analysis because Vips doesn't support the file"
+            {}
+          end
+        end
+      rescue LoadError
+        logger.info "Skipping image analysis because the ruby-vips gem isn't installed"
+        {}
+      rescue ::Vips::Error => error
+        logger.error "Skipping image analysis due to an Vips error: #{error.message}"
+        {}
+      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
+
+      def valid_image?(image)
+        image.avg
+        true
+      rescue ::Vips::Error
+        false
+      end
+  end
+end