activestorage 5.2.6 → 6.0.0.beta1

data/lib/active_storage/attached/many.rb

@@ -9,22 +9,29 @@ module ActiveStorage
     #
     # All methods called on this proxy object that aren't listed here will automatically be delegated to +attachments+.
     def attachments
-      record.public_send("#{name}_attachments")
+      change.present? ? change.attachments : record.public_send("#{name}_attachments")
     end
 
-    # Associates one or several attachments with the current record, saving them to the database.
+    # Returns all attached blobs.
+    def blobs
+      change.present? ? change.blobs : record.public_send("#{name}_blobs")
+    end
+
+    # Attaches one or more +attachables+ to the record.
+    #
+    # If the record is persisted and unchanged, the attachments are saved to
+    # the database immediately. Otherwise, they'll be saved to the DB when the
+    # record is next saved.
     #
     #   document.images.attach(params[:images]) # Array of ActionDispatch::Http::UploadedFile objects
     #   document.images.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
     #   document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpg")
     #   document.images.attach([ first_blob, second_blob ])
     def attach(*attachables)
-      attachables.flatten.collect do |attachable|
-        if record.new_record?
-          attachments.build(record: record, blob: create_blob_from(attachable))
-        else
-          attachments.create!(record: record, blob: create_blob_from(attachable))
-        end
+      if record.persisted? && !record.changed?
+        record.update(name => blobs + attachables.flatten)
+      else
+        record.public_send("#{name}=", blobs + attachables.flatten)
       end
     end
 
@@ -41,7 +48,7 @@ module ActiveStorage
 
     # Deletes associated attachments without purging them, leaving their respective blobs in place.
     def detach
-      attachments.destroy_all if attached?
+      attachments.delete_all if attached?
     end
 
     ##
@@ -50,7 +57,6 @@ module ActiveStorage
     # Directly purges each associated attachment (i.e. destroys the blobs and
     # attachments and deletes the files on the service).
 
-
     ##
     # :method: purge_later
     #

data/lib/active_storage/attached/model.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Provides the class-level DSL for declaring an Active Record model's attachments.
+  module Attached::Model
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Specifies the relation between a single attachment and the model.
+      #
+      #   class User < ActiveRecord::Base
+      #     has_one_attached :avatar
+      #   end
+      #
+      # There is no column defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachment.
+      #
+      # To avoid N+1 queries, you can include the attached blobs in your query like so:
+      #
+      #   User.with_attached_avatar
+      #
+      # Under the covers, this relationship is implemented as a +has_one+ association to a
+      # ActiveStorage::Attachment record and a +has_one-through+ association to a
+      # ActiveStorage::Blob record. These associations are available as +avatar_attachment+
+      # and +avatar_blob+. But you shouldn't need to work with these associations directly in
+      # most circumstances.
+      #
+      # The system has been designed to having you go through the ActiveStorage::Attached::One
+      # proxy that provides the dynamic proxy to the associations and factory methods, like +attach+.
+      #
+      # 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)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            @active_storage_attached_#{name} ||= ActiveStorage::Attached::One.new("#{name}", self)
+          end
+
+          def #{name}=(attachable)
+            attachment_changes["#{name}"] =
+              if attachable.nil?
+                ActiveStorage::Attached::Changes::DeleteOne.new("#{name}", self)
+              else
+                ActiveStorage::Attached::Changes::CreateOne.new("#{name}", self, attachable)
+              end
+          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
+
+        scope :"with_attached_#{name}", -> { includes("#{name}_attachment": :blob) }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        ActiveRecord::Reflection.add_attachment_reflection(
+          self,
+          name,
+          ActiveRecord::Reflection.create(:has_one_attached, name, nil, { dependent: dependent }, self)
+        )
+      end
+
+      # Specifies the relation between multiple attachments and the model.
+      #
+      #   class Gallery < ActiveRecord::Base
+      #     has_many_attached :photos
+      #   end
+      #
+      # There are no columns defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachments.
+      #
+      # To avoid N+1 queries, you can include the attached blobs in your query like so:
+      #
+      #   Gallery.where(user: Current.user).with_attached_photos
+      #
+      # Under the covers, this relationship is implemented as a +has_many+ association to a
+      # ActiveStorage::Attachment record and a +has_many-through+ association to a
+      # ActiveStorage::Blob record. These associations are available as +photos_attachments+
+      # and +photos_blobs+. But you shouldn't need to work with these associations directly in
+      # most circumstances.
+      #
+      # The system has been designed to having you go through the ActiveStorage::Attached::Many
+      # proxy that provides the dynamic proxy to the associations and factory methods, like +#attach+.
+      #
+      # 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)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            @active_storage_attached_#{name} ||= ActiveStorage::Attached::Many.new("#{name}", self)
+          end
+
+          def #{name}=(attachables)
+            attachment_changes["#{name}"] =
+              if attachables.nil? || Array(attachables).none?
+                ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
+              else
+                ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
+              end
+          end
+        CODE
+
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
+          def purge
+            each(&:purge)
+            reset
+          end
+
+          def purge_later
+            each(&:purge_later)
+            reset
+          end
+        end
+        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob
+
+        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        ActiveRecord::Reflection.add_attachment_reflection(
+          self,
+          name,
+          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
+        )
+      end
+    end
+
+    def attachment_changes #:nodoc:
+      @attachment_changes ||= {}
+    end
+
+    def reload(*) #:nodoc:
+      super.tap { @attachment_changes = nil }
+    end
+  end
+end

data/lib/active_storage/attached/one.rb

@@ -10,26 +10,28 @@ module ActiveStorage
     # You don't have to call this method to access the attachment's methods as
     # they are all available at the model level.
     def attachment
-      record.public_send("#{name}_attachment")
+      change.present? ? change.attachment : record.public_send("#{name}_attachment")
     end
 
-    # Associates a given attachment with the current record, saving it to the database.
+    def blank?
+      !attached?
+    end
+
+    # Attaches an +attachable+ to the record.
+    #
+    # If the record is persisted and unchanged, the attachment is saved to
+    # the database immediately. Otherwise, it'll be saved to the DB when the
+    # record is next saved.
     #
     #   person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
     #   person.avatar.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
     #   person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
     #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
     def attach(attachable)
-      blob_was = blob if attached?
-      blob = create_blob_from(attachable)
-
-      unless blob == blob_was
-        transaction do
-          detach
-          write_attachment build_attachment(blob: blob)
-        end
-
-        blob_was.purge_later if blob_was && dependent == :purge_later
+      if record.persisted? && !record.changed?
+        record.update(name => attachable)
+      else
+        record.public_send("#{name}=", attachable)
       end
     end
 
@@ -47,7 +49,7 @@ module ActiveStorage
     # Deletes the attachment without purging it, leaving its blob in place.
     def detach
       if attached?
-        attachment.destroy
+        attachment.delete
         write_attachment nil
       end
     end
@@ -65,16 +67,11 @@ module ActiveStorage
     def purge_later
       if attached?
         attachment.purge_later
+        write_attachment nil
       end
     end
 
     private
-      delegate :transaction, to: :record
-
-      def build_attachment(blob:)
-        ActiveStorage::Attachment.new(record: record, name: name, blob: blob)
-      end
-
       def write_attachment(attachment)
         record.public_send("#{name}_attachment=", attachment)
       end

data/lib/active_storage/downloader.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Downloader #:nodoc:
+    def initialize(blob, tempdir: nil)
+      @blob    = blob
+      @tempdir = tempdir
+    end
+
+    def download_blob_to_tempfile
+      open_tempfile do |file|
+        download_blob_to file
+        verify_integrity_of file
+        yield file
+      end
+    end
+
+    private
+      attr_reader :blob, :tempdir
+
+      def open_tempfile
+        file = Tempfile.open([ "ActiveStorage-#{blob.id}-", blob.filename.extension_with_delimiter ], tempdir)
+
+        begin
+          yield file
+        ensure
+          file.close!
+        end
+      end
+
+      def download_blob_to(file)
+        file.binmode
+        blob.download { |chunk| file.write(chunk) }
+        file.flush
+        file.rewind
+      end
+
+      def verify_integrity_of(file)
+        unless Digest::MD5.file(file).base64digest == blob.checksum
+          raise ActiveStorage::IntegrityError
+        end
+      end
+  end
+end

data/lib/active_storage/downloading.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
 require "tmpdir"
+require "active_support/core_ext/string/filters"
 
 module ActiveStorage
   module Downloading
+    def self.included(klass)
+      ActiveSupport::Deprecation.warn <<~MESSAGE.squish, caller_locations(2)
+        ActiveStorage::Downloading is deprecated and will be removed in Active Storage 6.1.
+        Use ActiveStorage::Blob#open instead.
+      MESSAGE
+    end
+
     private
       # Opens a new tempfile in #tempdir and copies blob data into it. Yields the tempfile.
       def download_blob_to_tempfile #:doc:

data/lib/active_storage/engine.rb

@@ -10,6 +10,8 @@ require "active_storage/previewer/video_previewer"
 require "active_storage/analyzer/image_analyzer"
 require "active_storage/analyzer/video_analyzer"
 
+require "active_storage/reflection"
+
 module ActiveStorage
   class Engine < Rails::Engine # :nodoc:
     isolate_namespace ActiveStorage
@@ -18,12 +20,15 @@ module ActiveStorage
     config.active_storage.previewers = [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
     config.active_storage.analyzers = [ ActiveStorage::Analyzer::ImageAnalyzer, ActiveStorage::Analyzer::VideoAnalyzer ]
     config.active_storage.paths = ActiveSupport::OrderedOptions.new
+    config.active_storage.queues = ActiveSupport::OrderedOptions.new
 
     config.active_storage.variable_content_types = %w(
       image/png
       image/gif
       image/jpg
       image/jpeg
+      image/pjpeg
+      image/tiff
       image/vnd.adobe.photoshop
       image/vnd.microsoft.icon
     )
@@ -46,6 +51,7 @@ module ActiveStorage
       image/gif
       image/jpg
       image/jpeg
+      image/tiff
       image/vnd.adobe.photoshop
       image/vnd.microsoft.icon
       application/pdf
@@ -55,14 +61,16 @@ module ActiveStorage
 
     initializer "active_storage.configs" do
       config.after_initialize do |app|
-        ActiveStorage.logger     = app.config.active_storage.logger || Rails.logger
-        ActiveStorage.queue      = app.config.active_storage.queue
-        ActiveStorage.previewers = app.config.active_storage.previewers || []
-        ActiveStorage.analyzers  = app.config.active_storage.analyzers || []
-        ActiveStorage.paths      = app.config.active_storage.paths || {}
+        ActiveStorage.logger            = app.config.active_storage.logger || Rails.logger
+        ActiveStorage.variant_processor = app.config.active_storage.variant_processor || :mini_magick
+        ActiveStorage.previewers        = app.config.active_storage.previewers || []
+        ActiveStorage.analyzers         = app.config.active_storage.analyzers || []
+        ActiveStorage.paths             = app.config.active_storage.paths || {}
+        ActiveStorage.routes_prefix     = app.config.active_storage.routes_prefix || "/rails/active_storage"
 
         ActiveStorage.variable_content_types = app.config.active_storage.variable_content_types || []
         ActiveStorage.content_types_to_serve_as_binary = app.config.active_storage.content_types_to_serve_as_binary || []
+        ActiveStorage.service_urls_expire_in = app.config.active_storage.service_urls_expire_in || 5.minutes
         ActiveStorage.content_types_allowed_inline = app.config.active_storage.content_types_allowed_inline || []
         ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
       end
@@ -72,7 +80,7 @@ module ActiveStorage
       require "active_storage/attached"
 
       ActiveSupport.on_load(:active_record) do
-        extend ActiveStorage::Attached::Macros
+        include ActiveStorage::Attached::Model
       end
     end
 
@@ -108,5 +116,26 @@ module ActiveStorage
         end
       end
     end
+
+    initializer "active_storage.queues" do
+      config.after_initialize do |app|
+        if queue = app.config.active_storage.queue
+          ActiveSupport::Deprecation.warn \
+            "config.active_storage.queue is deprecated and will be removed in Rails 6.1. " \
+            "Set config.active_storage.queues.purge and config.active_storage.queues.analysis instead."
+
+          ActiveStorage.queues = { purge: queue, analysis: queue }
+        else
+          ActiveStorage.queues = app.config.active_storage.queues || {}
+        end
+      end
+    end
+
+    initializer "active_storage.reflection" do
+      ActiveSupport.on_load(:active_record) do
+        include Reflection::ActiveRecordExtensions
+        ActiveRecord::Reflection.singleton_class.prepend(Reflection::ReflectionExtension)
+      end
+    end
   end
 end

data/lib/active_storage/errors.rb

@@ -1,7 +1,26 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  class InvariableError < StandardError; end
-  class UnpreviewableError < StandardError; end
-  class UnrepresentableError < StandardError; end
+  # Generic base class for all Active Storage exceptions.
+  class Error < StandardError; end
+
+  # Raised when ActiveStorage::Blob#variant is called on a blob that isn't variable.
+  # Use ActiveStorage::Blob#variable? to determine whether a blob is variable.
+  class InvariableError < Error; end
+
+  # Raised when ActiveStorage::Blob#preview is called on a blob that isn't previewable.
+  # Use ActiveStorage::Blob#previewable? to determine whether a blob is previewable.
+  class UnpreviewableError < Error; end
+
+  # Raised when ActiveStorage::Blob#representation is called on a blob that isn't representable.
+  # Use ActiveStorage::Blob#representable? to determine whether a blob is representable.
+  class UnrepresentableError < Error; end
+
+  # Raised when uploaded or downloaded data does not match a precomputed checksum.
+  # Indicates that a network error or a software bug caused data corruption.
+  class IntegrityError < Error; end
+
+  # Raised when ActiveStorage::Blob#download is called on a blob where the
+  # backing file is no longer present in its service.
+  class FileNotFoundError < Error; end
 end

data/lib/active_storage/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveStorage
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 2
-    TINY  = 6
-    PRE   = nil
+    MAJOR = 6
+    MINOR = 0
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end