activestorage 6.0.0

data/lib/active_storage/downloader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Downloader #:nodoc:
+    attr_reader :service
+
+    def initialize(service)
+      @service = service
+    end
+
+    def open(key, checksum:, name: "ActiveStorage-", tmpdir: nil)
+      open_tempfile(name, tmpdir) do |file|
+        download key, file
+        verify_integrity_of file, checksum: checksum
+        yield file
+      end
+    end
+
+    private
+      def open_tempfile(name, tmpdir = nil)
+        file = Tempfile.open(name, tmpdir)
+
+        begin
+          yield file
+        ensure
+          file.close!
+        end
+      end
+
+      def download(key, file)
+        file.binmode
+        service.download(key) { |chunk| file.write(chunk) }
+        file.flush
+        file.rewind
+      end
+
+      def verify_integrity_of(file, checksum:)
+        unless Digest::MD5.file(file).base64digest == checksum
+          raise ActiveStorage::IntegrityError
+        end
+      end
+  end
+end

data/lib/active_storage/downloading.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "active_support/core_ext/string/filters"
+
+module ActiveStorage
+  module Downloading
+    def self.included(klass)
+      ActiveSupport::Deprecation.warn <<~MESSAGE.squish, caller_locations(2)
+        ActiveStorage::Downloading is deprecated and will be removed in Active Storage 6.1.
+        Use ActiveStorage::Blob#open instead.
+      MESSAGE
+    end
+
+    private
+      # Opens a new tempfile in #tempdir and copies blob data into it. Yields the tempfile.
+      def download_blob_to_tempfile #:doc:
+        open_tempfile_for_blob do |file|
+          download_blob_to file
+          yield file
+        end
+      end
+
+      def open_tempfile_for_blob
+        tempfile = Tempfile.open([ "ActiveStorage", blob.filename.extension_with_delimiter ], tempdir)
+
+        begin
+          yield tempfile
+        ensure
+          tempfile.close!
+        end
+      end
+
+      # Efficiently downloads blob data into the given file.
+      def download_blob_to(file) #:doc:
+        file.binmode
+        blob.download { |chunk| file.write(chunk) }
+        file.flush
+        file.rewind
+      end
+
+      # Returns the directory in which tempfiles should be opened. Defaults to +Dir.tmpdir+.
+      def tempdir #:doc:
+        Dir.tmpdir
+      end
+  end
+end

data/lib/active_storage/engine.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_controller/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+
+require "active_storage"
+
+require "active_storage/previewer/poppler_pdf_previewer"
+require "active_storage/previewer/mupdf_previewer"
+require "active_storage/previewer/video_previewer"
+
+require "active_storage/analyzer/image_analyzer"
+require "active_storage/analyzer/video_analyzer"
+
+require "active_storage/reflection"
+
+module ActiveStorage
+  class Engine < Rails::Engine # :nodoc:
+    isolate_namespace ActiveStorage
+
+    config.active_storage = ActiveSupport::OrderedOptions.new
+    config.active_storage.previewers = [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
+    config.active_storage.analyzers = [ ActiveStorage::Analyzer::ImageAnalyzer, ActiveStorage::Analyzer::VideoAnalyzer ]
+    config.active_storage.paths = ActiveSupport::OrderedOptions.new
+    config.active_storage.queues = ActiveSupport::OrderedOptions.new
+
+    config.active_storage.variable_content_types = %w(
+      image/png
+      image/gif
+      image/jpg
+      image/jpeg
+      image/pjpeg
+      image/tiff
+      image/bmp
+      image/vnd.adobe.photoshop
+      image/vnd.microsoft.icon
+    )
+
+    config.active_storage.content_types_to_serve_as_binary = %w(
+      text/html
+      text/javascript
+      image/svg+xml
+      application/postscript
+      application/x-shockwave-flash
+      text/xml
+      application/xml
+      application/xhtml+xml
+      application/mathml+xml
+      text/cache-manifest
+    )
+
+    config.active_storage.content_types_allowed_inline = %w(
+      image/png
+      image/gif
+      image/jpg
+      image/jpeg
+      image/tiff
+      image/bmp
+      image/vnd.adobe.photoshop
+      image/vnd.microsoft.icon
+      application/pdf
+    )
+
+    config.eager_load_namespaces << ActiveStorage
+
+    initializer "active_storage.configs" do
+      config.after_initialize do |app|
+        ActiveStorage.logger            = app.config.active_storage.logger || Rails.logger
+        ActiveStorage.variant_processor = app.config.active_storage.variant_processor || :mini_magick
+        ActiveStorage.previewers        = app.config.active_storage.previewers || []
+        ActiveStorage.analyzers         = app.config.active_storage.analyzers || []
+        ActiveStorage.paths             = app.config.active_storage.paths || {}
+        ActiveStorage.routes_prefix     = app.config.active_storage.routes_prefix || "/rails/active_storage"
+
+        ActiveStorage.variable_content_types = app.config.active_storage.variable_content_types || []
+        ActiveStorage.content_types_to_serve_as_binary = app.config.active_storage.content_types_to_serve_as_binary || []
+        ActiveStorage.service_urls_expire_in = app.config.active_storage.service_urls_expire_in || 5.minutes
+        ActiveStorage.content_types_allowed_inline = app.config.active_storage.content_types_allowed_inline || []
+        ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
+
+        ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many || false
+      end
+    end
+
+    initializer "active_storage.attached" do
+      require "active_storage/attached"
+
+      ActiveSupport.on_load(:active_record) do
+        include ActiveStorage::Attached::Model
+      end
+    end
+
+    initializer "active_storage.verifier" do
+      config.after_initialize do |app|
+        ActiveStorage.verifier = app.message_verifier("ActiveStorage")
+      end
+    end
+
+    initializer "active_storage.services" do
+      ActiveSupport.on_load(:active_storage_blob) do
+        if config_choice = Rails.configuration.active_storage.service
+          configs = Rails.configuration.active_storage.service_configurations ||= begin
+            config_file = Pathname.new(Rails.root.join("config/storage.yml"))
+            raise("Couldn't find Active Storage configuration in #{config_file}") unless config_file.exist?
+
+            require "yaml"
+            require "erb"
+
+            YAML.load(ERB.new(config_file.read).result) || {}
+          rescue Psych::SyntaxError => e
+            raise "YAML syntax error occurred while parsing #{config_file}. " \
+                  "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+                  "Error: #{e.message}"
+          end
+
+          ActiveStorage::Blob.service =
+            begin
+              ActiveStorage::Service.configure config_choice, configs
+            rescue => e
+              raise e, "Cannot load `Rails.config.active_storage.service`:\n#{e.message}", e.backtrace
+            end
+        end
+      end
+    end
+
+    initializer "active_storage.queues" do
+      config.after_initialize do |app|
+        if queue = app.config.active_storage.queue
+          ActiveSupport::Deprecation.warn \
+            "config.active_storage.queue is deprecated and will be removed in Rails 6.1. " \
+            "Set config.active_storage.queues.purge and config.active_storage.queues.analysis instead."
+
+          ActiveStorage.queues = { purge: queue, analysis: queue }
+        else
+          ActiveStorage.queues = app.config.active_storage.queues || {}
+        end
+      end
+    end
+
+    initializer "active_storage.reflection" do
+      ActiveSupport.on_load(:active_record) do
+        include Reflection::ActiveRecordExtensions
+        ActiveRecord::Reflection.singleton_class.prepend(Reflection::ReflectionExtension)
+      end
+    end
+  end
+end

data/lib/active_storage/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Generic base class for all Active Storage exceptions.
+  class Error < StandardError; end
+
+  # Raised when ActiveStorage::Blob#variant is called on a blob that isn't variable.
+  # Use ActiveStorage::Blob#variable? to determine whether a blob is variable.
+  class InvariableError < Error; end
+
+  # Raised when ActiveStorage::Blob#preview is called on a blob that isn't previewable.
+  # Use ActiveStorage::Blob#previewable? to determine whether a blob is previewable.
+  class UnpreviewableError < Error; end
+
+  # Raised when ActiveStorage::Blob#representation is called on a blob that isn't representable.
+  # Use ActiveStorage::Blob#representable? to determine whether a blob is representable.
+  class UnrepresentableError < Error; end
+
+  # Raised when uploaded or downloaded data does not match a precomputed checksum.
+  # Indicates that a network error or a software bug caused data corruption.
+  class IntegrityError < Error; end
+
+  # Raised when ActiveStorage::Blob#download is called on a blob where the
+  # backing file is no longer present in its service.
+  class FileNotFoundError < Error; end
+end

data/lib/active_storage/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Returns the version of the currently loaded Active Storage as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 6
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_storage/log_subscriber.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module ActiveStorage
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def service_upload(event)
+      message = "Uploaded file to key: #{key_in(event)}"
+      message += " (checksum: #{event.payload[:checksum]})" if event.payload[:checksum]
+      info event, color(message, GREEN)
+    end
+
+    def service_download(event)
+      info event, color("Downloaded file from key: #{key_in(event)}", BLUE)
+    end
+
+    alias_method :service_streaming_download, :service_download
+
+    def service_delete(event)
+      info event, color("Deleted file from key: #{key_in(event)}", RED)
+    end
+
+    def service_delete_prefixed(event)
+      info event, color("Deleted files by key prefix: #{event.payload[:prefix]}", RED)
+    end
+
+    def service_exist(event)
+      debug event, color("Checked if file exists at key: #{key_in(event)} (#{event.payload[:exist] ? "yes" : "no"})", BLUE)
+    end
+
+    def service_url(event)
+      debug event, color("Generated URL for file at key: #{key_in(event)} (#{event.payload[:url]})", BLUE)
+    end
+
+    def logger
+      ActiveStorage.logger
+    end
+
+    private
+      def info(event, colored_message)
+        super log_prefix_for_service(event) + colored_message
+      end
+
+      def debug(event, colored_message)
+        super log_prefix_for_service(event) + colored_message
+      end
+
+      def log_prefix_for_service(event)
+        color "  #{event.payload[:service]} Storage (#{event.duration.round(1)}ms) ", CYAN
+      end
+
+      def key_in(event)
+        event.payload[:key]
+      end
+  end
+end
+
+ActiveStorage::LogSubscriber.attach_to :active_storage

data/lib/active_storage/previewer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # This is an abstract base class for previewers, which generate images from blobs. See
+  # ActiveStorage::Previewer::MuPDFPreviewer and ActiveStorage::Previewer::VideoPreviewer for
+  # examples of concrete subclasses.
+  class Previewer
+    attr_reader :blob
+
+    # Implement this method in a concrete subclass. Have it return true when given a blob from which
+    # the previewer can generate an image.
+    def self.accept?(blob)
+      false
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it yield an attachable preview image (i.e.
+    # anything accepted by ActiveStorage::Attached::One#attach).
+    def preview
+      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
+
+      # Executes a system command, capturing its binary output in a tempfile. Yields the tempfile.
+      #
+      # Use this method to shell out to a system library (e.g. muPDF or FFmpeg) for preview image
+      # generation. The resulting tempfile can be used as the +:io+ value in an attachable Hash:
+      #
+      #   def preview
+      #     download_blob_to_tempfile do |input|
+      #       draw "my-drawing-command", input.path, "--format", "png", "-" do |output|
+      #         yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+      #       end
+      #     end
+      #   end
+      #
+      # The output tempfile is opened in the directory returned by #tmpdir.
+      def draw(*argv) #:doc:
+        open_tempfile do |file|
+          instrument :preview, key: blob.key do
+            capture(*argv, to: file)
+          end
+
+          yield file
+        end
+      end
+
+      def open_tempfile
+        tempfile = Tempfile.open("ActiveStorage-", tmpdir)
+
+        begin
+          yield tempfile
+        ensure
+          tempfile.close!
+        end
+      end
+
+      def instrument(operation, payload = {}, &block)
+        ActiveSupport::Notifications.instrument "#{operation}.active_storage", payload, &block
+      end
+
+      def capture(*argv, to:)
+        to.binmode
+        IO.popen(argv, err: File::NULL) { |out| IO.copy_stream(out, to) }
+        to.rewind
+      end
+
+      def logger #:doc:
+        ActiveStorage.logger
+      end
+
+      def tmpdir #:doc:
+        Dir.tmpdir
+      end
+  end
+end

data/lib/active_storage/previewer/mupdf_previewer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::MuPDFPreviewer < Previewer
+    class << self
+      def accept?(blob)
+        blob.content_type == "application/pdf" && mutool_exists?
+      end
+
+      def mutool_path
+        ActiveStorage.paths[:mutool] || "mutool"
+      end
+
+      def mutool_exists?
+        return @mutool_exists unless @mutool_exists.nil?
+
+        system mutool_path, out: File::NULL, err: File::NULL
+
+        @mutool_exists = $?.exitstatus == 1
+      end
+    end
+
+    def preview
+      download_blob_to_tempfile do |input|
+        draw_first_page_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+        end
+      end
+    end
+
+    private
+      def draw_first_page_from(file, &block)
+        draw self.class.mutool_path, "draw", "-F", "png", "-o", "-", file.path, "1", &block
+      end
+  end
+end