activestorage 6.0.0

data/app/models/active_storage/variation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# A set of transformations that can be applied to a blob to create a variant. This class is exposed via
+# the ActiveStorage::Blob#variant method and should rarely be used directly.
+#
+# 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_to_limit: [100, 100], monochrome: true, trim: true, rotate: "-90")
+#
+# The options map directly to {ImageProcessing}[https://github.com/janko-m/image_processing] commands.
+class ActiveStorage::Variation
+  attr_reader :transformations
+
+  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,
+    # it is assumed to be a transformations Hash and is passed directly to the constructor.
+    def wrap(variator)
+      case variator
+      when self
+        variator
+      when String
+        decode variator
+      else
+        new variator
+      end
+    end
+
+    # Returns a Variation instance with the transformations that were encoded by +encode+.
+    def decode(key)
+      new ActiveStorage.verifier.verify(key, purpose: :variation)
+    end
+
+    # Returns a signed key for the +transformations+, which can be used to refer to a specific
+    # variation in a URL or combined key (like <tt>ActiveStorage::Variant#key</tt>).
+    def encode(transformations)
+      ActiveStorage.verifier.generate(transformations, purpose: :variation)
+    end
+  end
+
+  def initialize(transformations)
+    @transformations = transformations.deep_symbolize_keys
+  end
+
+  # 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
+      transformer.transform(file, format: format, &block)
+    end
+  end
+
+  # Returns a signed key for all the +transformations+ that this variation was instantiated with.
+  def key
+    self.class.encode(transformations)
+  end
+
+  private
+    def transformer
+      if ActiveStorage.variant_processor
+        begin
+          require "image_processing"
+        rescue LoadError
+          ActiveSupport::Deprecation.warn <<~WARNING.squish
+            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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  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  "/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
+    variation_key  = representation.variation.key
+    filename       = representation.blob.filename
+
+    route_for(:rails_blob_representation, signed_blob_id, variation_key, filename, options)
+  end
+
+  resolve("ActiveStorage::Variant") { |variant, options| route_for(:rails_representation, variant, options) }
+  resolve("ActiveStorage::Preview") { |preview, options| route_for(:rails_representation, preview, options) }
+
+
+  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/migrate/20170806125915_create_active_storage_tables.rb

@@ -0,0 +1,26 @@
+class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
+  def change
+    create_table :active_storage_blobs do |t|
+      t.string   :key,        null: false
+      t.string   :filename,   null: false
+      t.string   :content_type
+      t.text     :metadata
+      t.bigint   :byte_size,  null: false
+      t.string   :checksum,   null: false
+      t.datetime :created_at, null: false
+
+      t.index [ :key ], unique: true
+    end
+
+    create_table :active_storage_attachments do |t|
+      t.string     :name,     null: false
+      t.references :record,   null: false, polymorphic: true, index: false
+      t.references :blob,     null: false
+
+      t.datetime :created_at, null: false
+
+      t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+end

data/db/update_migrate/20180723000244_add_foreign_key_constraint_to_active_storage_attachments_for_blob_id.rb

@@ -0,0 +1,9 @@
+class AddForeignKeyConstraintToActiveStorageAttachmentsForBlobId < ActiveRecord::Migration[6.0]
+  def up
+    return if foreign_key_exists?(:active_storage_attachments, column: :blob_id)
+
+    if table_exists?(:active_storage_blobs)
+      add_foreign_key :active_storage_attachments, :active_storage_blobs, column: :blob_id
+    end
+  end
+end

data/lib/active_storage.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+#--
+# 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
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require "active_record"
+require "active_support"
+require "active_support/rails"
+require "active_support/core_ext/numeric/time"
+
+require "active_storage/version"
+require "active_storage/errors"
+
+require "marcel"
+
+module ActiveStorage
+  extend ActiveSupport::Autoload
+
+  autoload :Attached
+  autoload :Service
+  autoload :Previewer
+  autoload :Analyzer
+
+  mattr_accessor :logger
+  mattr_accessor :verifier
+  mattr_accessor :variant_processor, default: :mini_magick
+
+  mattr_accessor :queues, default: {}
+
+  mattr_accessor :previewers, default: []
+  mattr_accessor :analyzers,  default: []
+
+  mattr_accessor :paths, default: {}
+
+  mattr_accessor :variable_content_types,           default: []
+  mattr_accessor :binary_content_type,              default: "application/octet-stream"
+  mattr_accessor :content_types_to_serve_as_binary, default: []
+  mattr_accessor :content_types_allowed_inline,     default: []
+
+  mattr_accessor :service_urls_expire_in, default: 5.minutes
+
+  mattr_accessor :routes_prefix, default: "/rails/active_storage"
+
+  mattr_accessor :replace_on_assign_to_many, default: false
+
+  module Transformers
+    extend ActiveSupport::Autoload
+
+    autoload :Transformer
+    autoload :ImageProcessingTransformer
+    autoload :MiniMagickTransformer
+  end
+end

data/lib/active_storage/analyzer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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
+    attr_reader :blob
+
+    # Implement this method in a concrete subclass. Have it return true when given a blob from which
+    # the analyzer can extract metadata.
+    def self.accept?(blob)
+      false
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it return a Hash of metadata.
+    def metadata
+      raise NotImplementedError
+    end
+
+    private
+      # Downloads the blob to a tempfile on disk. Yields the tempfile.
+      def download_blob_to_tempfile(&block) #:doc:
+        blob.open tmpdir: tmpdir, &block
+      end
+
+      def logger #:doc:
+        ActiveStorage.logger
+      end
+
+      def tmpdir #:doc:
+        Dir.tmpdir
+      end
+  end
+end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Extracts width and height in pixels from an image blob.
+  #
+  # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::ImageAnalyzer.new(blob).metadata
+  #   # => { width: 4104, height: 2736 }
+  #
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem. MiniMagick requires
+  # the {ImageMagick}[http://www.imagemagick.org] system library.
+  class Analyzer::ImageAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.image?
+    end
+
+    def metadata
+      read_image do |image|
+        if rotated_image?(image)
+          { width: image.height, height: image.width }
+        else
+          { width: image.width, height: image.height }
+        end
+      end
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "mini_magick"
+          image = MiniMagick::Image.new(file.path)
+
+          if image.valid?
+            yield image
+          else
+            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+            {}
+          end
+        end
+      rescue LoadError
+        logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+        {}
+      end
+
+      def rotated_image?(image)
+        %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
+      end
+  end
+end

data/lib/active_storage/analyzer/null_analyzer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Analyzer::NullAnalyzer < Analyzer # :nodoc:
+    def self.accept?(blob)
+      true
+    end
+
+    def metadata
+      {}
+    end
+  end
+end

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Extracts the following from a video blob:
+  #
+  # * Width (pixels)
+  # * Height (pixels)
+  # * Duration (seconds)
+  # * Angle (degrees)
+  # * Display aspect ratio
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::VideoAnalyzer.new(blob).metadata
+  #   # => { width: 640.0, height: 480.0, duration: 5.0, angle: 0, display_aspect_ratio: [4, 3] }
+  #
+  # 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.
+  class Analyzer::VideoAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.video?
+    end
+
+    def metadata
+      { width: width, height: height, duration: duration, angle: angle, display_aspect_ratio: display_aspect_ratio }.compact
+    end
+
+    private
+      def width
+        if rotated?
+          computed_height || encoded_height
+        else
+          encoded_width
+        end
+      end
+
+      def height
+        if rotated?
+          encoded_width
+        else
+          computed_height || encoded_height
+        end
+      end
+
+      def duration
+        Float(video_stream["duration"]) if video_stream["duration"]
+      end
+
+      def angle
+        Integer(tags["rotate"]) if tags["rotate"]
+      end
+
+      def display_aspect_ratio
+        if descriptor = video_stream["display_aspect_ratio"]
+          if terms = descriptor.split(":", 2)
+            numerator   = Integer(terms[0])
+            denominator = Integer(terms[1])
+
+            [numerator, denominator] unless numerator == 0
+          end
+        end
+      end
+
+
+      def rotated?
+        angle == 90 || angle == 270
+      end
+
+      def computed_height
+        if encoded_width && display_height_scale
+          encoded_width * display_height_scale
+        end
+      end
+
+      def encoded_width
+        @encoded_width ||= Float(video_stream["width"]) if video_stream["width"]
+      end
+
+      def encoded_height
+        @encoded_height ||= Float(video_stream["height"]) if video_stream["height"]
+      end
+
+      def display_height_scale
+        @display_height_scale ||= Float(display_aspect_ratio.last) / display_aspect_ratio.first if display_aspect_ratio
+      end
+
+
+      def tags
+        @tags ||= video_stream["tags"] || {}
+      end
+
+      def video_stream
+        @video_stream ||= streams.detect { |stream| stream["codec_type"] == "video" } || {}
+      end
+
+      def streams
+        probe["streams"] || []
+      end
+
+      def probe
+        download_blob_to_tempfile { |file| probe_from(file) }
+      end
+
+      def probe_from(file)
+        IO.popen([ ffprobe_path, "-print_format", "json", "-show_streams", "-v", "error", file.path ]) do |output|
+          JSON.parse(output.read)
+        end
+      rescue Errno::ENOENT
+        logger.info "Skipping video analysis because FFmpeg isn't installed"
+        {}
+      end
+
+      def ffprobe_path
+        ActiveStorage.paths[:ffprobe] || "ffprobe"
+      end
+  end
+end