activestorage 6.0.3.2 → 6.1.0

data/config/routes.rb

@@ -2,9 +2,13 @@
 
 Rails.application.routes.draw do
   scope ActiveStorage.routes_prefix do
-    get "/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
+    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"
 
-    get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
+    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  "/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
@@ -19,14 +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(:rails_blob, blob, options) }
-  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.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|
+    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.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2017-2019 David Heinemeier Hansson, Basecamp
+# Copyright (c) 2017-2020 David Heinemeier Hansson, Basecamp
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -53,6 +53,7 @@ module ActiveStorage
   mattr_accessor :paths, default: {}
 
   mattr_accessor :variable_content_types,           default: []
+  mattr_accessor :web_image_content_types,          default: []
   mattr_accessor :binary_content_type,              default: "application/octet-stream"
   mattr_accessor :content_types_to_serve_as_binary, default: []
   mattr_accessor :content_types_allowed_inline,     default: []
@@ -60,14 +61,16 @@ module ActiveStorage
   mattr_accessor :service_urls_expire_in, default: 5.minutes
 
   mattr_accessor :routes_prefix, default: "/rails/active_storage"
+  mattr_accessor :draw_routes, default: true
+  mattr_accessor :resolve_model_to_route, default: :rails_storage_redirect
 
   mattr_accessor :replace_on_assign_to_many, default: false
+  mattr_accessor :track_variants, default: false
 
   module Transformers
     extend ActiveSupport::Autoload
 
     autoload :Transformer
     autoload :ImageProcessingTransformer
-    autoload :MiniMagickTransformer
   end
 end

data/lib/active_storage/analyzer.rb

@@ -12,6 +12,12 @@ module ActiveStorage
       false
     end
 
+    # Implement this method in concrete subclasses. It will determine if blob analysis
+    # should be done in a job or performed inline. By default, analysis is enqueued in a job.
+    def self.analyze_later?
+      true
+    end
+
     def initialize(blob)
       @blob = blob
     end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -43,6 +43,9 @@ module ActiveStorage
       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

@@ -44,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
@@ -98,12 +99,22 @@ 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

data/lib/active_storage/attached/changes/create_many.rb

@@ -6,6 +6,7 @@ module ActiveStorage
 
     def initialize(name, record, attachables)
       @name, @record, @attachables = name, record, Array(attachables)
+      blobs.each(&:identify_without_saving)
     end
 
     def attachments

data/lib/active_storage/attached/changes/create_one.rb

@@ -9,6 +9,7 @@ module ActiveStorage
 
     def initialize(name, record, attachable)
       @name, @record, @attachable = name, record, attachable
+      blob.identify_without_saving
     end
 
     def attachment
@@ -53,17 +54,29 @@ module ActiveStorage
         when ActiveStorage::Blob
           attachable
         when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-          ActiveStorage::Blob.build_after_unfurling \
+          ActiveStorage::Blob.build_after_unfurling(
             io: attachable.open,
             filename: attachable.original_filename,
-            content_type: attachable.content_type
+            content_type: attachable.content_type,
+            record: record,
+            service_name: attachment_service_name
+          )
         when Hash
-          ActiveStorage::Blob.build_after_unfurling(**attachable)
+          ActiveStorage::Blob.build_after_unfurling(
+            **attachable.reverse_merge(
+              record: record,
+              service_name: attachment_service_name
+            ).symbolize_keys
+          )
         when String
-          ActiveStorage::Blob.find_signed(attachable)
+          ActiveStorage::Blob.find_signed!(attachable, record: record)
         else
           raise ArgumentError, "Could not find or build blob: expected attachable, got #{attachable.inspect}"
         end
       end
+
+      def attachment_service_name
+        record.attachment_reflections[name].options[:service_name]
+      end
   end
 end

data/lib/active_storage/attached/many.rb

@@ -29,15 +29,16 @@ module ActiveStorage
     #   document.images.attach([ first_blob, second_blob ])
     def attach(*attachables)
       if record.persisted? && !record.changed?
-        record.update(name => blobs + attachables.flatten)
+        record.public_send("#{name}=", blobs + attachables.flatten)
+        record.save
       else
         record.public_send("#{name}=", (change&.attachables || blobs) + attachables.flatten)
       end
     end
 
-    # Returns true if any attachments has been made.
+    # Returns true if any attachments have been made.
     #
-    #   class Gallery < ActiveRecord::Base
+    #   class Gallery < ApplicationRecord
     #     has_many_attached :photos
     #   end
     #

data/lib/active_storage/attached/model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/try"
+
 module ActiveStorage
   # Provides the class-level DSL for declaring an Active Record model's attachments.
   module Attached::Model
@@ -8,7 +10,7 @@ module ActiveStorage
     class_methods do
       # Specifies the relation between a single attachment and the model.
       #
-      #   class User < ActiveRecord::Base
+      #   class User < ApplicationRecord
       #     has_one_attached :avatar
       #   end
       #
@@ -30,10 +32,29 @@ module ActiveStorage
       #
       # If the +:dependent+ option isn't set, the attachment will be purged
       # (i.e. destroyed) whenever the record is destroyed.
-      def has_one_attached(name, dependent: :purge_later)
+      #
+      # If you need the attachment to use a service which differs from the globally configured one,
+      # pass the +:service+ option. For instance:
+      #
+      #   class User < ActiveRecord::Base
+      #     has_one_attached :avatar, service: :s3
+      #   end
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachment,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar, strict_loading: true
+      #   end
+      #
+      def has_one_attached(name, dependent: :purge_later, service: nil, strict_loading: false)
+        validate_service_configuration(name, service)
+
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
           def #{name}
-            @active_storage_attached_#{name} ||= ActiveStorage::Attached::One.new("#{name}", self)
+            @active_storage_attached ||= {}
+            @active_storage_attached[:#{name}] ||= ActiveStorage::Attached::One.new("#{name}", self)
           end
 
           def #{name}=(attachable)
@@ -46,8 +67,8 @@ module ActiveStorage
           end
         CODE
 
-        has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: :destroy
-        has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob
+        has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
+        has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
         scope :"with_attached_#{name}", -> { includes("#{name}_attachment": :blob) }
 
@@ -55,16 +76,19 @@ module ActiveStorage
 
         after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
 
-        ActiveRecord::Reflection.add_attachment_reflection(
-          self,
+        reflection = ActiveRecord::Reflection.create(
+          :has_one_attached,
           name,
-          ActiveRecord::Reflection.create(:has_one_attached, name, nil, { dependent: dependent }, self)
+          nil,
+          { dependent: dependent, service_name: service },
+          self
         )
+        ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
       end
 
       # Specifies the relation between multiple attachments and the model.
       #
-      #   class Gallery < ActiveRecord::Base
+      #   class Gallery < ApplicationRecord
       #     has_many_attached :photos
       #   end
       #
@@ -86,10 +110,29 @@ module ActiveStorage
       #
       # If the +:dependent+ option isn't set, all the attachments will be purged
       # (i.e. destroyed) whenever the record is destroyed.
-      def has_many_attached(name, dependent: :purge_later)
+      #
+      # If you need the attachment to use a service which differs from the globally configured one,
+      # pass the +:service+ option. For instance:
+      #
+      #   class Gallery < ActiveRecord::Base
+      #     has_many_attached :photos, service: :s3
+      #   end
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachments,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos, strict_loading: true
+      #   end
+      #
+      def has_many_attached(name, dependent: :purge_later, service: nil, strict_loading: false)
+        validate_service_configuration(name, service)
+
         generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
           def #{name}
-            @active_storage_attached_#{name} ||= ActiveStorage::Attached::Many.new("#{name}", self)
+            @active_storage_attached ||= {}
+            @active_storage_attached[:#{name}] ||= ActiveStorage::Attached::Many.new("#{name}", self)
           end
 
           def #{name}=(attachables)
@@ -109,7 +152,7 @@ module ActiveStorage
           end
         CODE
 
-        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading do
           def purge
             each(&:purge)
             reset
@@ -120,7 +163,7 @@ module ActiveStorage
             reset
           end
         end
-        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob
+        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
         scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
 
@@ -128,12 +171,24 @@ module ActiveStorage
 
         after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
 
-        ActiveRecord::Reflection.add_attachment_reflection(
-          self,
+        reflection = ActiveRecord::Reflection.create(
+          :has_many_attached,
           name,
-          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
+          nil,
+          { dependent: dependent, service_name: service },
+          self
         )
+        ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
       end
+
+      private
+        def validate_service_configuration(association_name, service)
+          if service.present?
+            ActiveStorage::Blob.services.fetch(service) do
+              raise ArgumentError, "Cannot configure service :#{service} for #{name}##{association_name}"
+            end
+          end
+        end
     end
 
     def attachment_changes #:nodoc:
@@ -144,6 +199,12 @@ module ActiveStorage
       super || attachment_changes.any?
     end
 
+    def initialize_dup(*) #:nodoc:
+      super
+      @active_storage_attached = nil
+      @attachment_changes = nil
+    end
+
     def reload(*) #:nodoc:
       super.tap { @attachment_changes = nil }
     end