activestorage_legacy 0.1

data/lib/active_storage/attached/macros.rb

@@ -0,0 +1,86 @@
+# Provides the class-level DSL for declaring that an Active Record model has attached blobs.
+module ActiveStorage::Attached::Macros
+  # Specifies the relation between a single attachment and the model.
+  #
+  #   class User < ActiveRecord::Base
+  #     has_one_attached :avatar
+  #   end
+  #
+  # There is no column defined on the model side, Active Storage takes
+  # care of the mapping between your records and the attachment.
+  #
+  # Under the covers, this relationship is implemented as a `has_one` association to a
+  # `ActiveStorage::Attachment` record and a `has_one-through` association to a
+  # `ActiveStorage::Blob` record. These associations are available as `avatar_attachment`
+  # and `avatar_blob`. But you shouldn't need to work with these associations directly in
+  # most circumstances.
+  #
+  # The system has been designed to having you go through the `ActiveStorage::Attached::One`
+  # proxy that provides the dynamic proxy to the associations and factory methods, like `#attach`.
+  #
+  # If the +:dependent+ option isn't set, the attachment will be purged
+  # (i.e. destroyed) whenever the record is destroyed.
+  def has_one_attached(name, dependent: :purge_later)
+    define_method(name) do
+      instance_variable_get("@active_storage_attached_#{name}") ||
+        instance_variable_set("@active_storage_attached_#{name}", ActiveStorage::Attached::One.new(name, self))
+    end
+
+    if Rails.version < '4.0'
+      has_one :"#{name}_attachment", conditions: proc { "name = '#{name}'" }, class_name: "ActiveStorage::Attachment", as: :record
+    else
+      has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record
+    end
+
+    has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob
+
+    if dependent == :purge_later
+      before_destroy { public_send(name).purge_later }
+    end
+  end
+
+  # Specifies the relation between multiple attachments and the model.
+  #
+  #   class Gallery < ActiveRecord::Base
+  #     has_many_attached :photos
+  #   end
+  #
+  # There are no columns defined on the model side, Active Storage takes
+  # care of the mapping between your records and the attachments.
+  #
+  # To avoid N+1 queries, you can include the attached blobs in your query like so:
+  #
+  #   Gallery.where(user: Current.user).with_attached_photos
+  #
+  # Under the covers, this relationship is implemented as a `has_many` association to a
+  # `ActiveStorage::Attachment` record and a `has_many-through` association to a
+  # `ActiveStorage::Blob` record. These associations are available as `photos_attachments`
+  # and `photos_blobs`. But you shouldn't need to work with these associations directly in
+  # most circumstances.
+  #
+  # The system has been designed to having you go through the `ActiveStorage::Attached::Many`
+  # proxy that provides the dynamic proxy to the associations and factory methods, like `#attach`.
+  #
+  # If the +:dependent+ option isn't set, all the attachments will be purged
+  # (i.e. destroyed) whenever the record is destroyed.
+  def has_many_attached(name, dependent: :purge_later)
+    define_method(name) do
+      instance_variable_get("@active_storage_attached_#{name}") ||
+        instance_variable_set("@active_storage_attached_#{name}", ActiveStorage::Attached::Many.new(name, self))
+    end
+
+    if Rails.version < '4.0'
+      has_many :"#{name}_attachments", conditions: proc { "name = '#{name}'" }, as: :record, class_name: "ActiveStorage::Attachment"
+    else
+      has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment"
+    end
+
+    has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob
+
+    scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
+
+    if dependent == :purge_later
+      before_destroy { public_send(name).purge_later }
+    end
+  end
+end

data/lib/active_storage/attached/many.rb

@@ -0,0 +1,51 @@
+# Decorated proxy object representing of multiple attachments to a model.
+class ActiveStorage::Attached::Many < ActiveStorage::Attached
+  delegate_missing_to :attachments
+
+  # Returns all the associated attachment records.
+  #
+  # All methods called on this proxy object that aren't listed here will automatically be delegated to `attachments`.
+  def attachments
+    record.public_send("#{name}_attachments")
+  end
+
+  # Associates one or several attachments with the current record, saving them to the database.
+  # Examples:
+  #
+  #   document.images.attach(params[:images]) # Array of ActionDispatch::Http::UploadedFile objects
+  #   document.images.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+  #   document.images.attach(io: File.open("~/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpg")
+  #   document.images.attach([ first_blob, second_blob ])
+  def attach(*attachables)
+    attachables.flatten.collect do |attachable|
+      attachments.create!(name: name, blob: create_blob_from(attachable))
+    end
+  end
+
+  # Returns true if any attachments has been made.
+  #
+  #   class Gallery < ActiveRecord::Base
+  #     has_many_attached :photos
+  #   end
+  #
+  #   Gallery.new.photos.attached? # => false
+  def attached?
+    attachments.any?
+  end
+
+  # Directly purges each associated attachment (i.e. destroys the blobs and
+  # attachments and deletes the files on the service).
+  def purge
+    if attached?
+      attachments.each(&:purge)
+      attachments.reload
+    end
+  end
+
+  # Purges each associated attachment through the queuing system.
+  def purge_later
+    if attached?
+      attachments.each(&:purge_later)
+    end
+  end
+end

data/lib/active_storage/attached/one.rb

@@ -0,0 +1,56 @@
+# Representation of a single attachment to a model.
+class ActiveStorage::Attached::One < ActiveStorage::Attached
+  delegate_missing_to :attachment
+
+  # Returns the associated attachment record.
+  #
+  # You don't have to call this method to access the attachment's methods as
+  # they are all available at the model level.
+  def attachment
+    record.public_send("#{name}_attachment")
+  end
+
+  # Associates a given attachment with the current record, saving it to the database.
+  # Examples:
+  #
+  #   person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
+  #   person.avatar.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
+  #   person.avatar.attach(io: File.open("~/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
+  #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
+  def attach(attachable)
+    write_attachment \
+      ActiveStorage::Attachment.create!(record: record, name: name, blob: create_blob_from(attachable))
+  end
+
+  # Returns true if an attachment has been made.
+  #
+  #   class User < ActiveRecord::Base
+  #     has_one_attached :avatar
+  #   end
+  #
+  #   User.new.avatar.attached? # => false
+  def attached?
+    attachment.present?
+  end
+
+  # Directly purges the attachment (i.e. destroys the blob and
+  # attachment and deletes the file on the service).
+  def purge
+    if attached?
+      attachment.purge
+      write_attachment nil
+    end
+  end
+
+  # Purges the attachment through the queuing system.
+  def purge_later
+    if attached?
+      attachment.purge_later
+    end
+  end
+
+  private
+    def write_attachment(attachment)
+      record.public_send("#{name}_attachment=", attachment)
+    end
+end

data/lib/active_storage/attached.rb

@@ -0,0 +1,38 @@
+require "active_storage/blob"
+require "active_storage/attachment"
+
+require "action_dispatch/http/upload"
+require "active_storage/patches/delegation"
+
+# Abstract baseclass for the concrete `ActiveStorage::Attached::One` and `ActiveStorage::Attached::Many`
+# classes that both provide proxy access to the blob association for a record.
+class ActiveStorage::Attached
+  attr_reader :name, :record
+
+  def initialize(name, record)
+    @name, @record = name, record
+  end
+
+  private
+    def create_blob_from(attachable)
+      case attachable
+      when ActiveStorage::Blob
+        attachable
+      when ActionDispatch::Http::UploadedFile
+        ActiveStorage::Blob.create_after_upload! \
+          io: attachable.open,
+          filename: attachable.original_filename,
+          content_type: attachable.content_type
+      when Hash
+        ActiveStorage::Blob.create_after_upload!(attachable)
+      when String
+        ActiveStorage::Blob.find_signed(attachable)
+      else
+        nil
+      end
+    end
+end
+
+require "active_storage/attached/one"
+require "active_storage/attached/many"
+require "active_storage/attached/macros"

data/lib/active_storage/engine.rb

@@ -0,0 +1,81 @@
+require "rails/engine"
+
+module ActiveStorage
+  class Engine < Rails::Engine # :nodoc:
+    config.active_storage = ActiveSupport::OrderedOptions.new
+
+    # config.eager_load_namespaces << ActiveStorage
+
+    initializer "active_storage.logger" do
+      require "active_storage/service"
+
+      config.after_initialize do |app|
+        ActiveStorage::Service.logger = app.config.active_storage.logger || Rails.logger
+      end
+    end
+
+    initializer 'active_storage.extend_active_record' do
+      require "active_storage/patches"
+      require "active_storage/patches/active_record"
+
+      ActiveSupport.on_load :active_record do
+        extend ActiveStorage::Patches::ActiveRecord
+      end
+    end
+
+    initializer "active_storage.attached" do
+      require "active_storage/attached"
+
+      ActiveSupport.on_load(:active_record) do
+        extend ActiveStorage::Attached::Macros
+      end
+    end
+
+    # Port of Rails.application.key_generator.generate_key('ActiveStorage')
+    #   Used to sign ActiveStorage::Blob
+    # See: https://github.com/rails/activestorage/blob/archive/lib/active_storage/engine.rb#L27
+    # https://github.com/rails/rails/blob/7-0-stable/activesupport/lib/active_support/key_generator.rb#L40
+    initializer "active_storage.verifier" do
+      require 'active_storage/verifier'
+
+      config.after_initialize do |app|
+        key = OpenSSL::PKCS5.pbkdf2_hmac(
+          app.config.secret_token,
+          'ActiveStorage',
+          1000,
+          64,
+          OpenSSL::Digest::SHA256.new
+        )
+        ActiveStorage.verifier = ActiveStorage::Verifier.new(key)
+      end
+    end
+
+    initializer "active_storage.services" do
+      config.after_initialize do |app|
+        if config_choice = app.config.active_storage.service
+          config_file = Pathname.new(Rails.root.join("config/storage_services.yml"))
+          raise("Couldn't find Active Storage configuration in #{config_file}") unless config_file.exist?
+
+          require "yaml"
+          require "erb"
+
+          configs =
+            begin
+              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
+  end
+end

data/lib/active_storage/gem_version.rb

@@ -0,0 +1,15 @@
+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 = 0
+    MINOR = 1
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_storage/log_subscriber.rb

@@ -0,0 +1,48 @@
+require "active_support/log_subscriber"
+
+class ActiveStorage::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
+
+  def service_delete(event)
+    info event, color("Deleted file from key: #{key_in(event)}", RED)
+  end
+
+  def service_exist(event)
+    debug event, color("Checked if file exist 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::Service.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
+
+ActiveStorage::LogSubscriber.attach_to :active_storage

data/lib/active_storage/messages_metadata.rb

@@ -0,0 +1,64 @@
+class ActiveSupport::MessagesMetadata #:nodoc:
+  def initialize(message, expires_at = nil, purpose = nil)
+    @message, @expires_at, @purpose = message, expires_at, purpose
+  end
+
+  def as_json(options = {})
+    { _rails: { message: @message, exp: @expires_at, pur: @purpose } }
+  end
+
+  class << self
+    def wrap(message, expires_at: nil, expires_in: nil, purpose: nil)
+      if expires_at || expires_in || purpose
+        ActiveSupport::JSON.encode new(encode(message), pick_expiry(expires_at, expires_in), purpose)
+      else
+        message
+      end
+    end
+
+    def verify(message, purpose)
+      extract_metadata(message).verify(purpose)
+    end
+
+    private
+    def pick_expiry(expires_at, expires_in)
+      if expires_at
+        expires_at.utc.iso8601(3)
+      elsif expires_in
+        Time.now.utc.advance(seconds: expires_in).iso8601(3)
+      end
+    end
+
+    def extract_metadata(message)
+      data = ActiveSupport::JSON.decode(message) rescue nil
+
+      if data.is_a?(Hash) && data.key?("_rails")
+        new(decode(data["_rails"]["message"]), data["_rails"]["exp"], data["_rails"]["pur"])
+      else
+        new(message)
+      end
+    end
+
+    def encode(message)
+      ::Base64.strict_encode64(message)
+    end
+
+    def decode(message)
+      ::Base64.strict_decode64(message)
+    end
+  end
+
+  def verify(purpose)
+    @message if match?(purpose) && fresh?
+  end
+
+  private
+  def match?(purpose)
+    @purpose.to_s == purpose.to_s
+  end
+
+  def fresh?
+    @expires_at.nil? || Time.now.utc < Time.iso8601(@expires_at)
+  end
+end
+

data/lib/active_storage/migration.rb

@@ -0,0 +1,27 @@
+class ActiveStorageCreateTables < ActiveRecord::Migration
+  def change
+    create_table :active_storage_blobs do |t|
+      t.string   :key
+      t.string   :filename
+      t.string   :content_type
+      t.text     :metadata
+      t.integer  :byte_size
+      t.string   :checksum
+      t.datetime :created_at
+    end
+
+    add_index :active_storage_blobs, :key, unique: true
+
+    create_table :active_storage_attachments do |t|
+      t.string  :name
+      t.string  :record_type
+      t.integer :record_id
+      t.integer :blob_id
+
+      t.datetime :created_at
+    end
+
+    add_index :active_storage_attachments, :blob_id
+    add_index :active_storage_attachments, [ :record_type, :record_id, :name, :blob_id ], name: "index_active_storage_attachments_uniqueness", unique: true
+  end
+end

data/lib/active_storage/patches/active_record.rb

@@ -0,0 +1,19 @@
+# Provides the class-level DSL for declaring that an Active Record model has attached blobs.
+
+module ActiveStorage::Patches::ActiveRecord
+  class MinimumLengthError < StandardError; end
+  MINIMUM_TOKEN_LENGTH = 24
+
+  def has_secure_token(attribute = :token, length: MINIMUM_TOKEN_LENGTH)
+    if length < MINIMUM_TOKEN_LENGTH
+      raise MinimumLengthError, "Token requires a minimum length of #{MINIMUM_TOKEN_LENGTH} characters."
+    end
+
+    define_method("regenerate_#{attribute}") { update_attributes! attribute => self.class.generate_unique_secure_token(length: length) }
+    before_create { send("#{attribute}=", self.class.generate_unique_secure_token(length: length)) unless send("#{attribute}?") }
+  end
+
+  def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
+    SecureRandom.base58(length)
+  end
+end

data/lib/active_storage/patches/delegation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "set"
+
+class Module
+  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
+  # option is not used.
+  class DelegationError < NoMethodError; end
+
+  RUBY_RESERVED_KEYWORDS = %w(__ENCODING__ __LINE__ __FILE__ alias and BEGIN begin break
+  case class def defined? do else elsif END end ensure false for if in module next nil
+  not or redo rescue retry return self super then true undef unless until when while yield)
+  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
+  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
+    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
+  ).freeze
+
+  # When building decorators, a common pattern may emerge:
+  #
+  #   class Partition
+  #     def initialize(event)
+  #       @event = event
+  #     end
+  #
+  #     def person
+  #       detail.person || creator
+  #     end
+  #
+  #     private
+  #       def respond_to_missing?(name, include_private = false)
+  #         @event.respond_to?(name, include_private)
+  #       end
+  #
+  #       def method_missing(method, *args, &block)
+  #         @event.send(method, *args, &block)
+  #       end
+  #   end
+  #
+  # With <tt>Module#delegate_missing_to</tt>, the above is condensed to:
+  #
+  #   class Partition
+  #     delegate_missing_to :@event
+  #
+  #     def initialize(event)
+  #       @event = event
+  #     end
+  #
+  #     def person
+  #       detail.person || creator
+  #     end
+  #   end
+  #
+  # The target can be anything callable within the object, e.g. instance
+  # variables, methods, constants, etc.
+  #
+  # The delegated method must be public on the target, otherwise it will
+  # raise +DelegationError+. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
+  #
+  # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
+  # delegation due to possible interference when calling
+  # <tt>Marshal.dump(object)</tt>, should the delegation target method
+  # of <tt>object</tt> add or remove instance variables.
+  def delegate_missing_to(target, allow_nil: nil)
+    target = target.to_s
+    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
+
+    module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def respond_to_missing?(name, include_private = false)
+        # It may look like an oversight, but we deliberately do not pass
+        # +include_private+, because they do not get delegated.
+
+        return false if name == :marshal_dump || name == :_dump
+        #{target}.respond_to?(name) || super
+      end
+
+      def method_missing(method, *args, &block)
+        if #{target}.respond_to?(method)
+          #{target}.public_send(method, *args, &block)
+        else
+          begin
+            super
+          rescue NoMethodError
+            if #{target}.nil?
+              if #{allow_nil == true}
+                nil
+              else
+                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              end
+            else
+              raise
+            end
+          end
+        end
+      end
+    RUBY
+  end
+end

data/lib/active_storage/patches/secure_random.rb

@@ -0,0 +1,26 @@
+require "securerandom"
+
+module SecureRandom
+  BASE58_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a - ["0", "O", "I", "l"] unless defined?(BASE58_ALPHABET)
+  BASE36_ALPHABET = ("0".."9").to_a + ("a".."z").to_a unless defined?(BASE36_ALPHABET)
+
+  unless SecureRandom.methods.include?(:base58)
+    def self.base58(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(58) if idx >= 58
+        BASE58_ALPHABET[idx]
+      end.join
+    end
+  end
+
+  unless SecureRandom.methods.include?(:base36)
+    def self.base36(n = 16)
+      SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+        idx = byte % 64
+        idx = SecureRandom.random_number(36) if idx >= 36
+        BASE36_ALPHABET[idx]
+      end.join
+    end
+  end
+end

data/lib/active_storage/patches.rb

@@ -0,0 +1,4 @@
+module ActiveStorage::Patches
+end
+
+require "active_storage/patches/secure_random"