activestorage 5.2.4.rc1 → 6.0.0.beta1

data/lib/active_storage/service/azure_storage_service.rb

@@ -19,10 +19,8 @@ module ActiveStorage
 
     def upload(key, io, checksum: nil, **)
       instrument :upload, key: key, checksum: checksum do
-        begin
+        handle_errors do
           blobs.create_block_blob(container, key, IO.try_convert(io) || io, content_md5: checksum)
-        rescue Azure::Core::Http::HTTPError
-          raise ActiveStorage::IntegrityError
         end
       end
     end
@@ -34,26 +32,29 @@ module ActiveStorage
         end
       else
         instrument :download, key: key do
-          _, io = blobs.get_blob(container, key)
-          io.force_encoding(Encoding::BINARY)
+          handle_errors do
+            _, io = blobs.get_blob(container, key)
+            io.force_encoding(Encoding::BINARY)
+          end
         end
       end
     end
 
     def download_chunk(key, range)
       instrument :download_chunk, key: key, range: range do
-        _, io = blobs.get_blob(container, key, start_range: range.begin, end_range: range.exclude_end? ? range.end - 1 : range.end)
-        io.force_encoding(Encoding::BINARY)
+        handle_errors do
+          _, io = blobs.get_blob(container, key, start_range: range.begin, end_range: range.exclude_end? ? range.end - 1 : range.end)
+          io.force_encoding(Encoding::BINARY)
+        end
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          blobs.delete_blob(container, key)
-        rescue Azure::Core::Http::HTTPError
-          # Ignore files already deleted
-        end
+        blobs.delete_blob(container, key)
+      rescue Azure::Core::Http::HTTPError => e
+        raise unless e.type == "BlobNotFound"
+        # Ignore files already deleted
       end
     end
 
@@ -139,11 +140,26 @@ module ActiveStorage
         chunk_size = 5.megabytes
         offset = 0
 
+        raise ActiveStorage::FileNotFoundError unless blob.present?
+
         while offset < blob.properties[:content_length]
           _, chunk = blobs.get_blob(container, key, start_range: offset, end_range: offset + chunk_size - 1)
           yield chunk.force_encoding(Encoding::BINARY)
           offset += chunk_size
         end
       end
+
+      def handle_errors
+        yield
+      rescue Azure::Core::Http::HTTPError => e
+        case e.type
+        when "BlobNotFound"
+          raise ActiveStorage::FileNotFoundError
+        when "Md5Mismatch"
+          raise ActiveStorage::IntegrityError
+        else
+          raise
+        end
+      end
   end
 end

data/lib/active_storage/service/configurator.rb

@@ -26,7 +26,9 @@ module ActiveStorage
 
       def resolve(class_name)
         require "active_storage/service/#{class_name.to_s.underscore}_service"
-        ActiveStorage::Service.const_get(:"#{class_name}Service")
+        ActiveStorage::Service.const_get(:"#{class_name.camelize}Service")
+      rescue LoadError
+        raise "Missing service adapter for #{class_name.inspect}"
       end
   end
 end

data/lib/active_storage/service/disk_service.rb

@@ -22,18 +22,16 @@ module ActiveStorage
       end
     end
 
-    def download(key)
+    def download(key, &block)
       if block_given?
         instrument :streaming_download, key: key do
-          File.open(path_for(key), "rb") do |file|
-            while data = file.read(5.megabytes)
-              yield data
-            end
-          end
+          stream key, &block
         end
       else
         instrument :download, key: key do
           File.binread path_for(key)
+        rescue Errno::ENOENT
+          raise ActiveStorage::FileNotFoundError
         end
       end
     end
@@ -44,16 +42,16 @@ module ActiveStorage
           file.seek range.begin
           file.read range.size
         end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          File.delete path_for(key)
-        rescue Errno::ENOENT
-          # Ignore files already deleted
-        end
+        File.delete path_for(key)
+      rescue Errno::ENOENT
+        # Ignore files already deleted
       end
     end
 
@@ -86,12 +84,8 @@ module ActiveStorage
           purpose: :blob_key }
         )
 
-        current_uri = URI.parse(current_host)
-
         generated_url = url_helpers.rails_disk_service_url(verified_key_with_expiration,
-          protocol: current_uri.scheme,
-          host: current_uri.host,
-          port: current_uri.port,
+          host: current_host,
           disposition: content_disposition,
           content_type: content_type,
           filename: filename
@@ -132,6 +126,16 @@ module ActiveStorage
     end
 
     private
+      def stream(key)
+        File.open(path_for(key), "rb") do |file|
+          while data = file.read(5.megabytes)
+            yield data
+          end
+        end
+      rescue Errno::ENOENT
+        raise ActiveStorage::FileNotFoundError
+      end
+
       def folder_for(key)
         [ key[0..1], key[2..3] ].join("/")
       end

data/lib/active_storage/service/gcs_service.rb

@@ -1,11 +1,7 @@
 # frozen_string_literal: true
 
-gem "google-cloud-storage", "~> 1.8"
-
+gem "google-cloud-storage", "~> 1.11"
 require "google/cloud/storage"
-require "net/http"
-
-require "active_support/core_ext/object/to_query"
 
 module ActiveStorage
   # Wraps the Google Cloud Storage as an Active Storage service. See ActiveStorage::Service for the generic API
@@ -17,15 +13,27 @@ module ActiveStorage
 
     def upload(key, io, checksum: nil, content_type: nil, disposition: nil, filename: nil)
       instrument :upload, key: key, checksum: checksum do
-        begin
-          # GCS's signed URLs don't include params such as response-content-type response-content_disposition
-          # in the signature, which means an attacker can modify them and bypass our effort to force these to
-          # binary and attachment when the file's content type requires it. The only way to force them is to
-          # store them as object's metadata.
-          content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
-          bucket.create_file(io, key, md5: checksum, content_type: content_type, content_disposition: content_disposition)
-        rescue Google::Cloud::InvalidArgumentError
-          raise ActiveStorage::IntegrityError
+        # GCS's signed URLs don't include params such as response-content-type response-content_disposition
+        # in the signature, which means an attacker can modify them and bypass our effort to force these to
+        # binary and attachment when the file's content type requires it. The only way to force them is to
+        # store them as object's metadata.
+        content_disposition = content_disposition_with(type: disposition, filename: filename) if disposition && filename
+        bucket.create_file(io, key, md5: checksum, content_type: content_type, content_disposition: content_disposition)
+      rescue Google::Cloud::InvalidArgumentError
+        raise ActiveStorage::IntegrityError
+      end
+    end
+
+    def download(key, &block)
+      if block_given?
+        instrument :streaming_download, key: key do
+          stream(key, &block)
+        end
+      else
+        instrument :download, key: key do
+          file_for(key).download.string
+        rescue Google::Cloud::NotFoundError
+          raise ActiveStorage::FileNotFoundError
         end
       end
     end
@@ -39,49 +47,28 @@ module ActiveStorage
       end
     end
 
-    # FIXME: Download in chunks when given a block.
-    def download(key)
-      instrument :download, key: key do
-        io = file_for(key).download
-        io.rewind
-
-        if block_given?
-          yield io.string
-        else
-          io.string
-        end
-      end
-    end
-
     def download_chunk(key, range)
       instrument :download_chunk, key: key, range: range do
-        file = file_for(key)
-        uri  = URI(file.signed_url(expires: 30.seconds))
-
-        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |client|
-          client.get(uri, "Range" => "bytes=#{range.begin}-#{range.exclude_end? ? range.end - 1 : range.end}").body
-        end
+        file_for(key).download(range: range).string
+      rescue Google::Cloud::NotFoundError
+        raise ActiveStorage::FileNotFoundError
       end
     end
 
     def delete(key)
       instrument :delete, key: key do
-        begin
-          file_for(key).delete
-        rescue Google::Cloud::NotFoundError
-          # Ignore files already deleted
-        end
+        file_for(key).delete
+      rescue Google::Cloud::NotFoundError
+        # Ignore files already deleted
       end
     end
 
     def delete_prefixed(prefix)
       instrument :delete_prefixed, prefix: prefix do
         bucket.files(prefix: prefix).all do |file|
-          begin
-            file.delete
-          rescue Google::Cloud::NotFoundError
-            # Ignore concurrently-deleted files
-          end
+          file.delete
+        rescue Google::Cloud::NotFoundError
+          # Ignore concurrently-deleted files
         end
       end
     end
@@ -124,8 +111,23 @@ module ActiveStorage
     private
       attr_reader :config
 
-      def file_for(key)
-        bucket.file(key, skip_lookup: true)
+      def file_for(key, skip_lookup: true)
+        bucket.file(key, skip_lookup: skip_lookup)
+      end
+
+      # Reads the file for the given key in chunks, yielding each to the block.
+      def stream(key)
+        file = file_for(key, skip_lookup: false)
+
+        chunk_size = 5.megabytes
+        offset = 0
+
+        raise ActiveStorage::FileNotFoundError unless file.present?
+
+        while offset < file.size
+          yield file.download(range: offset..(offset + chunk_size - 1)).string
+          offset += chunk_size
+        end
       end
 
       def bucket

data/lib/active_storage/service/mirror_service.rb

@@ -9,7 +9,7 @@ module ActiveStorage
   class Service::MirrorService < Service
     attr_reader :primary, :mirrors
 
-    delegate :download, :download_chunk, :exist?, :url, :path_for, to: :primary
+    delegate :download, :download_chunk, :exist?, :url, to: :primary
 
     # Stitch together from named services.
     def self.build(primary:, mirrors:, configurator:, **options) #:nodoc:

data/lib/active_storage/service/s3_service.rb

@@ -18,11 +18,9 @@ module ActiveStorage
 
     def upload(key, io, checksum: nil, **)
       instrument :upload, key: key, checksum: checksum do
-        begin
-          object_for(key).put(upload_options.merge(body: io, content_md5: checksum))
-        rescue Aws::S3::Errors::BadDigest
-          raise ActiveStorage::IntegrityError
-        end
+        object_for(key).put(upload_options.merge(body: io, content_md5: checksum))
+      rescue Aws::S3::Errors::BadDigest
+        raise ActiveStorage::IntegrityError
       end
     end
 
@@ -34,6 +32,8 @@ module ActiveStorage
       else
         instrument :download, key: key do
           object_for(key).get.body.string.force_encoding(Encoding::BINARY)
+        rescue Aws::S3::Errors::NoSuchKey
+          raise ActiveStorage::FileNotFoundError
         end
       end
     end
@@ -41,6 +41,8 @@ module ActiveStorage
     def download_chunk(key, range)
       instrument :download_chunk, key: key, range: range do
         object_for(key).get(range: "bytes=#{range.begin}-#{range.exclude_end? ? range.end - 1 : range.end}").body.read.force_encoding(Encoding::BINARY)
+      rescue Aws::S3::Errors::NoSuchKey
+        raise ActiveStorage::FileNotFoundError
       end
     end
 
@@ -103,6 +105,8 @@ module ActiveStorage
         chunk_size = 5.megabytes
         offset = 0
 
+        raise ActiveStorage::FileNotFoundError unless object.exists?
+
         while offset < object.content_length
           yield object.get(range: "bytes=#{offset}-#{offset + chunk_size - 1}").body.read.force_encoding(Encoding::BINARY)
           offset += chunk_size

data/lib/active_storage/transformers/image_processing_transformer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "image_processing"
+
+module ActiveStorage
+  module Transformers
+    class ImageProcessingTransformer < Transformer
+      private
+        def process(file, format:)
+          processor.
+            source(file).
+            loader(page: 0).
+            convert(format).
+            apply(operations).
+            call
+        end
+
+        def processor
+          ImageProcessing.const_get(ActiveStorage.variant_processor.to_s.camelize)
+        end
+
+        def operations
+          transformations.each_with_object([]) do |(name, argument), list|
+            if name.to_s == "combine_options"
+              ActiveSupport::Deprecation.warn <<~WARNING
+                Active Storage's ImageProcessing transformer doesn't support :combine_options,
+                as it always generates a single ImageMagick command. Passing :combine_options will
+                not be supported in Rails 6.1.
+              WARNING
+
+              list.concat argument.keep_if { |key, value| value.present? }.to_a
+            elsif argument.present?
+              list << [ name, argument ]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_storage/transformers/mini_magick_transformer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "mini_magick"
+
+module ActiveStorage
+  module Transformers
+    class MiniMagickTransformer < Transformer
+      private
+        def process(file, format:)
+          image = MiniMagick::Image.new(file.path, file)
+
+          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
+
+          image.format(format) if format
+
+          image.tempfile.tap(&:open)
+        end
+
+        def pass_transform_argument(command, method, argument)
+          if argument == true
+            command.public_send(method)
+          elsif argument.present?
+            command.public_send(method, argument)
+          end
+        end
+    end
+  end
+end

data/lib/active_storage/transformers/transformer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Transformers
+    # A Transformer applies a set of transformations to an image.
+    #
+    # The following concrete subclasses are included in Active Storage:
+    #
+    # * ActiveStorage::Transformers::ImageProcessingTransformer:
+    #   backed by ImageProcessing, a common interface for MiniMagick and ruby-vips
+    #
+    # * ActiveStorage::Transformers::MiniMagickTransformer:
+    #   backed by MiniMagick, a wrapper around the ImageMagick CLI
+    class Transformer
+      attr_reader :transformations
+
+      def initialize(transformations)
+        @transformations = transformations
+      end
+
+      # Applies the transformations to the source image in +file+, producing a target image in the
+      # specified +format+. Yields an open Tempfile containing the target image. Closes and unlinks
+      # the output tempfile after yielding to the given block. Returns the result of the block.
+      def transform(file, format:)
+        output = process(file, format: format)
+
+        begin
+          yield output
+        ensure
+          output.close!
+        end
+      end
+
+      private
+        # Returns an open Tempfile containing a transformed image in the given +format+.
+        # All subclasses implement this method.
+        def process(file, format:) #:doc:
+          raise NotImplementedError
+        end
+    end
+  end
+end