activestorage 5.2.3.rc1 → 6.0.0.beta1

data/config/routes.rb

@@ -1,17 +1,15 @@
 # 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
-
-  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) }
+  scope ActiveStorage.routes_prefix do
+    get "/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
 
+    get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
 
-  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
@@ -25,7 +23,10 @@ Rails.application.routes.draw do
   resolve("ActiveStorage::Preview") { |preview, options| route_for(:rails_representation, preview, 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
+  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

data/db/update_migrate/20180723000244_add_foreign_key_constraint_to_active_storage_attachments_for_blob_id.rb

@@ -0,0 +1,7 @@
+class AddForeignKeyConstraintToActiveStorageAttachmentsForBlobId < ActiveRecord::Migration[6.0]
+  def up
+    unless foreign_key_exists?(:active_storage_attachments, column: :blob_id)
+      add_foreign_key :active_storage_attachments, :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-2018 David Heinemeier Hansson, Basecamp
+# Copyright (c) 2017-2019 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
@@ -42,12 +42,23 @@ module ActiveStorage
 
   mattr_accessor :logger
   mattr_accessor :verifier
-  mattr_accessor :queue
+  mattr_accessor :queues, default: {}
   mattr_accessor :previewers, default: []
   mattr_accessor :analyzers, default: []
+  mattr_accessor :variant_processor, default: :mini_magick
   mattr_accessor :paths, default: {}
   mattr_accessor :variable_content_types, default: []
   mattr_accessor :content_types_to_serve_as_binary, default: []
   mattr_accessor :content_types_allowed_inline, default: []
   mattr_accessor :binary_content_type, default: "application/octet-stream"
+  mattr_accessor :service_urls_expire_in, default: 5.minutes
+  mattr_accessor :routes_prefix, default: "/rails/active_storage"
+
+  module Transformers
+    extend ActiveSupport::Autoload
+
+    autoload :Transformer
+    autoload :ImageProcessingTransformer
+    autoload :MiniMagickTransformer
+  end
 end

data/lib/active_storage/analyzer.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-require "active_storage/downloading"
-
 module ActiveStorage
   # This is an abstract base class for analyzers, which extract metadata from blobs. See
   # ActiveStorage::Analyzer::ImageAnalyzer for an example of a concrete subclass.
   class Analyzer
-    include Downloading
-
     attr_reader :blob
 
     # Implement this method in a concrete subclass. Have it return true when given a blob from which
@@ -26,8 +22,17 @@ module ActiveStorage
     end
 
     private
+      # Downloads the blob to a tempfile on disk. Yields the tempfile.
+      def download_blob_to_tempfile(&block) #:doc:
+        blob.open tempdir: tempdir, &block
+      end
+
       def logger #:doc:
         ActiveStorage.logger
       end
+
+      def tempdir #:doc:
+        Dir.tmpdir
+      end
   end
 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:
   #
@@ -18,7 +16,7 @@ module ActiveStorage
   #
   # 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?
@@ -109,7 +107,7 @@ module ActiveStorage
           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
 

data/lib/active_storage/attached.rb

@@ -1,40 +1,25 @@
 # frozen_string_literal: true
 
-require "action_dispatch"
-require "action_dispatch/http/upload"
 require "active_support/core_ext/module/delegation"
 
 module ActiveStorage
   # Abstract base class for the concrete ActiveStorage::Attached::One and ActiveStorage::Attached::Many
   # classes that both provide proxy access to the blob association for a record.
   class Attached
-    attr_reader :name, :record, :dependent
+    attr_reader :name, :record
 
-    def initialize(name, record, dependent:)
-      @name, @record, @dependent = name, record, dependent
+    def initialize(name, record)
+      @name, @record = name, record
     end
 
     private
-      def create_blob_from(attachable)
-        case attachable
-        when ActiveStorage::Blob
-          attachable
-        when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
-          ActiveStorage::Blob.create_after_upload! \
-            io: attachable.open,
-            filename: attachable.original_filename,
-            content_type: attachable.content_type
-        when Hash
-          ActiveStorage::Blob.create_after_upload!(attachable)
-        when String
-          ActiveStorage::Blob.find_signed(attachable)
-        else
-          nil
-        end
+      def change
+        record.attachment_changes[name]
       end
   end
 end
 
+require "active_storage/attached/model"
 require "active_storage/attached/one"
 require "active_storage/attached/many"
-require "active_storage/attached/macros"
+require "active_storage/attached/changes"

data/lib/active_storage/attached/changes.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Attached::Changes #:nodoc:
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :CreateOne
+      autoload :CreateMany
+      autoload :CreateOneOfMany
+
+      autoload :DeleteOne
+      autoload :DeleteMany
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::CreateMany #:nodoc:
+    attr_reader :name, :record, :attachables
+
+    def initialize(name, record, attachables)
+      @name, @record, @attachables = name, record, Array(attachables)
+    end
+
+    def attachments
+      @attachments ||= subchanges.collect(&:attachment)
+    end
+
+    def blobs
+      @blobs ||= subchanges.collect(&:blob)
+    end
+
+    def upload
+      subchanges.each(&:upload)
+    end
+
+    def save
+      assign_associated_attachments
+      reset_associated_blobs
+    end
+
+    private
+      def subchanges
+        @subchanges ||= attachables.collect { |attachable| build_subchange_from(attachable) }
+      end
+
+      def build_subchange_from(attachable)
+        ActiveStorage::Attached::Changes::CreateOneOfMany.new(name, record, attachable)
+      end
+
+
+      def assign_associated_attachments
+        record.public_send("#{name}_attachments=", attachments)
+      end
+
+      def reset_associated_blobs
+        record.public_send("#{name}_blobs").reset
+      end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "action_dispatch"
+require "action_dispatch/http/upload"
+
+module ActiveStorage
+  class Attached::Changes::CreateOne #:nodoc:
+    attr_reader :name, :record, :attachable
+
+    def initialize(name, record, attachable)
+      @name, @record, @attachable = name, record, attachable
+    end
+
+    def attachment
+      @attachment ||= find_or_build_attachment
+    end
+
+    def blob
+      @blob ||= find_or_build_blob
+    end
+
+    def upload
+      case attachable
+      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        blob.upload_without_unfurling(attachable.open)
+      when Hash
+        blob.upload_without_unfurling(attachable.fetch(:io))
+      end
+    end
+
+    def save
+      record.public_send("#{name}_attachment=", attachment)
+    end
+
+    private
+      def find_or_build_attachment
+        find_attachment || build_attachment
+      end
+
+      def find_attachment
+        if record.public_send("#{name}_blob") == blob
+          record.public_send("#{name}_attachment")
+        end
+      end
+
+      def build_attachment
+        ActiveStorage::Attachment.new(record: record, name: name, blob: blob)
+      end
+
+      def find_or_build_blob
+        case attachable
+        when ActiveStorage::Blob
+          attachable
+        when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+          ActiveStorage::Blob.build_after_unfurling \
+            io: attachable.open,
+            filename: attachable.original_filename,
+            content_type: attachable.content_type
+        when Hash
+          ActiveStorage::Blob.build_after_unfurling(attachable)
+        when String
+          ActiveStorage::Blob.find_signed(attachable)
+        else
+          raise ArgumentError, "Could not find or build blob: expected attachable, got #{attachable.inspect}"
+        end
+      end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::CreateOneOfMany < Attached::Changes::CreateOne #:nodoc:
+    private
+      def find_attachment
+        record.public_send("#{name}_attachments").detect { |attachment| attachment.blob_id == blob.id }
+      end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DeleteMany #:nodoc:
+    attr_reader :name, :record
+
+    def initialize(name, record)
+      @name, @record = name, record
+    end
+
+    def attachments
+      ActiveStorage::Attachment.none
+    end
+
+    def blobs
+      ActiveStorage::Blob.none
+    end
+
+    def save
+      record.public_send("#{name}_attachments=", [])
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DeleteOne #:nodoc:
+    attr_reader :name, :record
+
+    def initialize(name, record)
+      @name, @record = name, record
+    end
+
+    def attachment
+      nil
+    end
+
+    def save
+      record.public_send("#{name}_attachment=", nil)
+    end
+  end
+end

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