activestorage 5.2.6.3 → 6.0.0.beta1

data/app/models/active_storage/variation.rb

@@ -6,315 +6,12 @@
 # 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
 
-  class UnsupportedImageProcessingMethod < StandardError; end
-  class UnsupportedImageProcessingArgument < StandardError; end
-
-  SUPPORTED_IMAGE_PROCESSING_METHODS = [
-   "adaptive_blur",
-   "adaptive_resize",
-   "adaptive_sharpen",
-   "adjoin",
-   "affine",
-   "alpha",
-   "annotate",
-   "antialias",
-   "append",
-   "apply",
-   "attenuate",
-   "authenticate",
-   "auto_gamma",
-   "auto_level",
-   "auto_orient",
-   "auto_threshold",
-   "backdrop",
-   "background",
-   "bench",
-   "bias",
-   "bilateral_blur",
-   "black_point_compensation",
-   "black_threshold",
-   "blend",
-   "blue_primary",
-   "blue_shift",
-   "blur",
-   "border",
-   "bordercolor",
-   "borderwidth",
-   "brightness_contrast",
-   "cache",
-   "canny",
-   "caption",
-   "channel",
-   "channel_fx",
-   "charcoal",
-   "chop",
-   "clahe",
-   "clamp",
-   "clip",
-   "clip_path",
-   "clone",
-   "clut",
-   "coalesce",
-   "colorize",
-   "colormap",
-   "color_matrix",
-   "colors",
-   "colorspace",
-   "colourspace",
-   "color_threshold",
-   "combine",
-   "combine_options",
-   "comment",
-   "compare",
-   "complex",
-   "compose",
-   "composite",
-   "compress",
-   "connected_components",
-   "contrast",
-   "contrast_stretch",
-   "convert",
-   "convolve",
-   "copy",
-   "crop",
-   "cycle",
-   "deconstruct",
-   "define",
-   "delay",
-   "delete",
-   "density",
-   "depth",
-   "descend",
-   "deskew",
-   "despeckle",
-   "direction",
-   "displace",
-   "dispose",
-   "dissimilarity_threshold",
-   "dissolve",
-   "distort",
-   "dither",
-   "draw",
-   "duplicate",
-   "edge",
-   "emboss",
-   "encoding",
-   "endian",
-   "enhance",
-   "equalize",
-   "evaluate",
-   "evaluate_sequence",
-   "extent",
-   "extract",
-   "family",
-   "features",
-   "fft",
-   "fill",
-   "filter",
-   "flatten",
-   "flip",
-   "floodfill",
-   "flop",
-   "font",
-   "foreground",
-   "format",
-   "frame",
-   "function",
-   "fuzz",
-   "fx",
-   "gamma",
-   "gaussian_blur",
-   "geometry",
-   "gravity",
-   "grayscale",
-   "green_primary",
-   "hald_clut",
-   "highlight_color",
-   "hough_lines",
-   "iconGeometry",
-   "iconic",
-   "identify",
-   "ift",
-   "illuminant",
-   "immutable",
-   "implode",
-   "insert",
-   "intensity",
-   "intent",
-   "interlace",
-   "interline_spacing",
-   "interpolate",
-   "interpolative_resize",
-   "interword_spacing",
-   "kerning",
-   "kmeans",
-   "kuwahara",
-   "label",
-   "lat",
-   "layers",
-   "level",
-   "level_colors",
-   "limit",
-   "limits",
-   "linear_stretch",
-   "linewidth",
-   "liquid_rescale",
-   "list",
-   "loader",
-   "log",
-   "loop",
-   "lowlight_color",
-   "magnify",
-   "map",
-   "mattecolor",
-   "median",
-   "mean_shift",
-   "metric",
-   "mode",
-   "modulate",
-   "moments",
-   "monitor",
-   "monochrome",
-   "morph",
-   "morphology",
-   "mosaic",
-   "motion_blur",
-   "name",
-   "negate",
-   "noise",
-   "normalize",
-   "opaque",
-   "ordered_dither",
-   "orient",
-   "page",
-   "paint",
-   "pause",
-   "perceptible",
-   "ping",
-   "pointsize",
-   "polaroid",
-   "poly",
-   "posterize",
-   "precision",
-   "preview",
-   "process",
-   "quality",
-   "quantize",
-   "quiet",
-   "radial_blur",
-   "raise",
-   "random_threshold",
-   "range_threshold",
-   "red_primary",
-   "regard_warnings",
-   "region",
-   "remote",
-   "render",
-   "repage",
-   "resample",
-   "resize",
-   "resize_to_fill",
-   "resize_to_fit",
-   "resize_to_limit",
-   "resize_and_pad",
-   "respect_parentheses",
-   "reverse",
-   "roll",
-   "rotate",
-   "sample",
-   "sampling_factor",
-   "saver",
-   "scale",
-   "scene",
-   "screen",
-   "seed",
-   "segment",
-   "selective_blur",
-   "separate",
-   "sepia_tone",
-   "shade",
-   "shadow",
-   "shared_memory",
-   "sharpen",
-   "shave",
-   "shear",
-   "sigmoidal_contrast",
-   "silent",
-   "similarity_threshold",
-   "size",
-   "sketch",
-   "smush",
-   "snaps",
-   "solarize",
-   "sort_pixels",
-   "sparse_color",
-   "splice",
-   "spread",
-   "statistic",
-   "stegano",
-   "stereo",
-   "storage_type",
-   "stretch",
-   "strip",
-   "stroke",
-   "strokewidth",
-   "style",
-   "subimage_search",
-   "swap",
-   "swirl",
-   "synchronize",
-   "taint",
-   "text_font",
-   "threshold",
-   "thumbnail",
-   "tile_offset",
-   "tint",
-   "title",
-   "transform",
-   "transparent",
-   "transparent_color",
-   "transpose",
-   "transverse",
-   "treedepth",
-   "trim",
-   "type",
-   "undercolor",
-   "unique_colors",
-   "units",
-   "unsharp",
-   "update",
-   "valid_image",
-   "view",
-   "vignette",
-   "virtual_pixel",
-   "visual",
-   "watermark",
-   "wave",
-   "wavelet_denoise",
-   "weight",
-   "white_balance",
-   "white_point",
-   "white_threshold",
-   "window",
-   "window_group",
-  ].concat(ActiveStorage.supported_image_processing_methods)
-
-  UNSUPPORTED_IMAGE_PROCESSING_ARGUMENTS = ActiveStorage.unsupported_image_processing_arguments
-
   class << self
     # Returns a Variation instance based on the given variator. If the variator is a Variation, it is
     # returned unmodified. If it is a String, it is passed to ActiveStorage::Variation.decode. Otherwise,
@@ -346,24 +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|
-        validate_transformation(name, argument_or_subtransformations)
-        image.mogrify do |command|
-          if name.to_s == "combine_options"
-            argument_or_subtransformations.each do |subtransformation_name, subtransformation_argument|
-              validate_transformation(subtransformation_name, subtransformation_argument)
-              pass_transform_argument(command, subtransformation_name, subtransformation_argument)
-            end
-          else
-            validate_transformation(name, argument_or_subtransformations)
-            pass_transform_argument(command, name, argument_or_subtransformations)
-          end
-        end
-      end
+      transformer.transform(file, format: format, &block)
     end
   end
 
@@ -373,69 +59,22 @@ class ActiveStorage::Variation
   end
 
   private
-    def pass_transform_argument(command, method, argument)
-      if eligible_argument?(argument)
-        command.public_send(method, argument)
-      else
-        command.public_send(method)
-      end
-    end
-
-    def eligible_argument?(argument)
-      argument.present? && argument != true
-    end
-
-    def validate_transformation(name, argument)
-      method_name = name.to_s.gsub("-","_")
-
-      unless SUPPORTED_IMAGE_PROCESSING_METHODS.any? { |method| method_name == method }
-        raise UnsupportedImageProcessingMethod, <<~ERROR.squish
-          One or more of the provided transformation methods is not supported.
-        ERROR
-      end
-
-      if argument.present?
-        if argument.is_a?(String) || argument.is_a?(Symbol)
-          validate_arg_string(argument)
-        elsif argument.is_a?(Array)
-          validate_arg_array(argument)
-        elsif argument.is_a?(Hash)
-          validate_arg_hash(argument)
-        end
-      end
-    end
-
-    def validate_arg_string(argument)
-      if UNSUPPORTED_IMAGE_PROCESSING_ARGUMENTS.any? { |bad_arg| argument.to_s.downcase.include?(bad_arg) }; raise UnsupportedImageProcessingArgument end
-    end
-
-    def validate_arg_array(argument)
-      argument.each do |arg|
-        if arg.is_a?(Integer) || arg.is_a?(Float)
-          next
-        elsif arg.is_a?(String) || arg.is_a?(Symbol)
-          validate_arg_string(arg)
-        elsif arg.is_a?(Array)
-          validate_arg_array(arg)
-        elsif arg.is_a?(Hash)
-          validate_arg_hash(arg)
-        end
-      end
-    end
-
-    def validate_arg_hash(argument)
-      argument.each do |key, value|
-        validate_arg_string(key)
-
-        if value.is_a?(Integer) || value.is_a?(Float)
-          next
-        elsif value.is_a?(String) || value.is_a?(Symbol)
-          validate_arg_string(value)
-        elsif value.is_a?(Array)
-          validate_arg_array(value)
-        elsif value.is_a?(Hash)
-          validate_arg_hash(value)
+    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
+        ActiveStorage::Transformers::MiniMagickTransformer.new(transformations)
       end
     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/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/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/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