Extract metadata from images and videos

2 files changed, 63 insertions, 1 deletions

diff --git a/activestorage/app/models/active_storage/attachment.rb b/activestorage/app/models/active_storage/attachment.rb
index 29226e8ee9..9f61a5dbf3 100644
--- a/activestorage/app/models/active_storage/attachment.rb
+++ b/activestorage/app/models/active_storage/attachment.rb
@@ -14,6 +14,8 @@ class ActiveStorage::Attachment < ActiveRecord::Base
 
   delegate_missing_to :blob
 
+  after_create_commit :analyze_blob_later
+
   # Synchronously purges the blob (deletes it from the configured service) and destroys the attachment.
   def purge
     blob.purge
@@ -25,4 +27,9 @@ class ActiveStorage::Attachment < ActiveRecord::Base
     blob.purge_later
     destroy
   end
+
+  private
+    def analyze_blob_later
+      blob.analyze_later unless blob.analyzed?
+    end
 end
diff --git a/activestorage/app/models/active_storage/blob.rb b/activestorage/app/models/active_storage/blob.rb
index 84b8f3827b..99823e14c6 100644
--- a/activestorage/app/models/active_storage/blob.rb
+++ b/activestorage/app/models/active_storage/blob.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_storage/analyzer/null_analyzer"
+
 # A blob is a record that contains the metadata about a file and a key for where that file resides on the service.
 # Blobs can be created in two ways:
 #
@@ -20,7 +22,7 @@ class ActiveStorage::Blob < ActiveRecord::Base
   self.table_name = "active_storage_blobs"
 
   has_secure_token :key
-  store :metadata, coder: JSON
+  store :metadata, accessors: [ :analyzed ], coder: JSON
 
   class_attribute :service
 
@@ -224,6 +226,46 @@ class ActiveStorage::Blob < ActiveRecord::Base
   end
 
 
+  # Extracts and stores metadata from the file associated with this blob using a relevant analyzer. Active Storage comes
+  # with built-in analyzers for images and videos. See ActiveStorage::Analyzer::ImageAnalyzer and
+  # ActiveStorage::Analyzer::VideoAnalyzer for information about the specific attributes they extract and the third-party
+  # libraries they require.
+  #
+  # To choose the analyzer for a blob, Active Storage calls +accept?+ on each registered analyzer in order. It uses the
+  # first analyzer for which +accept?+ returns true when given the blob. If no registered analyzer accepts the blob, no
+  # metadata is extracted from it.
+  #
+  # In a Rails application, add or remove analyzers by manipulating +Rails.application.config.active_storage.analyzers+
+  # in an initializer:
+  #
+  #   # Add a custom analyzer for Microsoft Office documents:
+  #   Rails.application.config.active_storage.analyzers.append DOCXAnalyzer
+  #
+  #   # Remove the built-in video analyzer:
+  #   Rails.application.config.active_storage.analyzers.delete ActiveStorage::Analyzer::VideoAnalyzer
+  #
+  # Outside of a Rails application, manipulate +ActiveStorage.analyzers+ instead.
+  #
+  # You won't ordinarily need to call this method from a Rails application. New blobs are automatically and asynchronously
+  # analyzed via #analyze_later when they're attached for the first time.
+  def analyze
+    update! metadata: extract_metadata_via_analyzer
+  end
+
+  # Enqueues an ActiveStorage::AnalyzeJob which calls #analyze.
+  #
+  # This method is automatically called for a blob when it's attached for the first time. You can call it to analyze a blob
+  # again (e.g. if you add a new analyzer or modify an existing one).
+  def analyze_later
+    ActiveStorage::AnalyzeJob.perform_later(self)
+  end
+
+  # Returns true if the blob has been analyzed.
+  def analyzed?
+    analyzed
+  end
+
+
   # Deletes the file on the service that's associated with this blob. This should only be done if the blob is going to be
   # deleted as well or you will essentially have a dead reference. It's recommended to use the +#purge+ and +#purge_later+
   # methods in most circumstances.
@@ -255,4 +297,17 @@ class ActiveStorage::Blob < ActiveRecord::Base
         io.rewind
       end.base64digest
     end
+
+
+    def extract_metadata_via_analyzer
+      analyzer.metadata.merge(analyzed: true)
+    end
+
+    def analyzer
+      analyzer_class.new(self)
+    end
+
+    def analyzer_class
+      ActiveStorage.analyzers.detect { |klass| klass.accept?(self) } || ActiveStorage::Analyzer::NullAnalyzer
+    end
 end