activestorage 5.2.6 → 6.0.0.beta1

data/app/models/active_storage/variation.rb

@@ -6,17 +6,9 @@
 # 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")
+#   ActiveStorage::Variation.new(resize_to_fit: [100, 100], monochrome: true, trim: true, rotate: "-90")
 #
-# You can also combine multiple transformations in one step, e.g. for center-weighted cropping:
-#
-#   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
 
@@ -51,21 +43,13 @@ class ActiveStorage::Variation
     @transformations = transformations
   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)
+  # Accepts a File object, performs the +transformations+ against it, and
+  # saves the transformed image into a temporary file. If +format+ is specified
+  # it will be the format of the result image, otherwise the result image
+  # retains the source format.
+  def transform(file, format: nil, &block)
     ActiveSupport::Notifications.instrument("transform.active_storage") do
-      transformations.each do |name, argument_or_subtransformations|
-        image.mogrify do |command|
-          if name.to_s == "combine_options"
-            argument_or_subtransformations.each do |subtransformation_name, subtransformation_argument|
-              pass_transform_argument(command, subtransformation_name, subtransformation_argument)
-            end
-          else
-            pass_transform_argument(command, name, argument_or_subtransformations)
-          end
-        end
-      end
+      transformer.transform(file, format: format, &block)
     end
   end
 
@@ -75,15 +59,22 @@ class ActiveStorage::Variation
   end
 
   private
-    def pass_transform_argument(command, method, argument)
-      if eligible_argument?(argument)
-        command.public_send(method, argument)
+    def transformer
+      if ActiveStorage.variant_processor
+        begin
+          require "image_processing"
+        rescue LoadError
+          ActiveSupport::Deprecation.warn <<~WARNING
+            Generating image variants will require the image_processing gem in Rails 6.1.
+            Please add `gem 'image_processing', '~> 1.2'` to your Gemfile.
+          WARNING
+
+          ActiveStorage::Transformers::MiniMagickTransformer.new(transformations)
+        else
+          ActiveStorage::Transformers::ImageProcessingTransformer.new(transformations)
+        end
       else
-        command.public_send(method)
+        ActiveStorage::Transformers::MiniMagickTransformer.new(transformations)
       end
     end
-
-    def eligible_argument?(argument)
-      argument.present? && argument != true
-    end
 end

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