activestorage-memory 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 225cd38418cfa2b7318059599b306cecb07a0a14f16673ab13468a261ca7c87d
-  data.tar.gz: c96879c4425e6df7c435b52be5718187f8b5bf6cfba92131da1f6d5632cb3a01
+  metadata.gz: 1b5979d939220916998f7502ffce56be3fbf14328601cdcfae7d3aeaaa181ce2
+  data.tar.gz: 615c9f1c2472e74058a353f1c17c79a80eee114a6fb97a770973f68dd0c1fde9
 SHA512:
-  metadata.gz: 0a69efcb428a4a2b9fead9ee4d1c78427fcd6823e4314cb4a550c98ab05bf8fd88ebb476f9c90761f09b3b581cd5f7ed91d294112a897a8f94a81c4bf96cbeee
-  data.tar.gz: bd0a3463ec6ad8d08b93c318a9f299610be8452d09f5b0ed862cd5417c0ffe33ee1210f4124997d7a049853b50d4821b2f66f007469a15b7bb5cb9481f5c7245
+  metadata.gz: 0161b44194c712db207d028801bb57174ed2ba05322ae056b6989a690e870df5d4769316313bae0f0c1df4e9bb9ccf0d434f6e0cffdc6f02147f41b95534bc5b
+  data.tar.gz: 2698dd5ca0974dcdc6443dbcde2065822e2b32f91a13da1d22c6f7b07f5f423b2d0c9e0ee50b70401cd38e904500c58de7206a4cac41582a9504af4f0a77eb0e

data/README.md

@@ -1,8 +1,7 @@
-# ActiveStorage::Memory
+# ActiveStorage-Memory
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/active_storage/memory`. To experiment with that code, run `bin/console` for an interactive prompt.
+Provides an in-memory ActiveStorage service.
 
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 
@@ -22,13 +21,35 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Declare a Memory service in config/storage.yml
+
+```
+memory:
+  service: Memory
+```
+
+To use the Memory service in test, you add the following to config/environments/test.rb:
+
+``` 
+config.active_storage.service = :memory
+```
+
+In Active Storage's analyzer feature, asynchronous jobs are executed. So you should set the queue adapter to inline at config/environments/test.
+```
+  config.active_job.queue_adapter = :inline
+```
+
+If you are conducting file downloads and uploads during system testing or integration testing, please add the following to the routing.
+
+``` config/routes.rb
+
+  mount ActiveStorage::Memory::Engine => "/" if Rails.env.test?
+
+```
 
-## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+You can read more about Active Storage in the Active Storage Overview guide.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/app/controllers/activestorage/memory/memory_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Activestorage::Memory
+  class MemoryController < ActiveStorage::BaseController
+    skip_forgery_protection
+
+    def show
+      key = decode_verified_key
+
+      unless key
+        head :not_found
+        return
+      end
+
+      service = named_memory_service(key[:service_name])
+      if service.exist?(key[:key])
+        send_data(service.store[key[:key]], content_type: key[:content_type], disposition: key[:disposition])
+      else
+        head :not_found
+      end
+    end
+
+    def update
+      token = decode_verified_token
+
+      unless token
+        head :not_found
+        return
+      end
+
+      unless acceptable_content?(token)
+        head :unprocessable_entity
+        return
+      end
+
+      named_memory_service(token[:service_name]).upload token[:key], request.body, checksum: token[:checksum]
+      head :no_content
+    end
+
+    private
+
+    def named_memory_service(name)
+      ActiveStorage::Blob.services.fetch(name) do
+        ActiveStorage::Blob.service
+      end
+    end
+
+    def decode_verified_key
+      ActiveStorage.verifier.verified(params[:encoded_key], purpose: :blob_key)&.deep_symbolize_keys
+    end
+
+    def decode_verified_token
+      ActiveStorage.verifier.verified(params[:encoded_token], purpose: :blob_token)&.deep_symbolize_keys
+    end
+
+    def acceptable_content?(token)
+      token[:content_type] == request.content_mime_type.to_s && token[:content_length] == request.content_length
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,6 @@
+Activestorage::Memory::Engine.routes.draw do
+  scope ActiveStorage.routes_prefix do
+    get '/memory/:encoded_key/*filename' => 'memory#show', as: :rails_memory_service
+    put '/memory/:encoded_token' => 'memory#update', as: :update_rails_memory_service
+  end
+end

data/lib/active_storage/service/memory_service.rb

@@ -11,19 +11,26 @@ module ActiveStorage
       @config = config
     end
 
-    def upload(key, io, **)
+    def upload(key, io, checksum: nil, **)
       instrument(:upload, key: key) do
         store[key] = io.read
+        ensure_integrity_of(key, checksum) if checksum
       end
     end
 
-    def download(key)
-      instrument(:streaming_download, key: key) do
-        io = StringIO.new(store.fetch(key))
-        io.set_encoding(io.string.encoding)
-        io
-      rescue KeyError
-        raise ActiveStorage::FileNotFoundError
+    def download(key, &block)
+      if block_given?
+        instrument(:streaming_download, key: key) do
+          stream key, &block
+        end
+      else
+        instrument(:download, key: key) do
+          io = StringIO.new(store.fetch(key))
+          io.set_encoding(io.string.encoding)
+          io
+        rescue KeyError
+          raise ActiveStorage::FileNotFoundError
+        end
       end
     end
 
@@ -43,11 +50,94 @@ module ActiveStorage
       end
     end
 
-    def url(key)
-      instrument(:url, key: key) do
-        # FIXME: - this should be a URL that can be used to directly download the file
-        "memory://#{key}"
+    def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:, **)
+      instrument :url, key: key do |payload|
+        verified_token_with_expiration = generate_verified_token(
+          key,
+          expires_in: expires_in,
+          content_type: content_type,
+          content_length: content_length,
+          checksum: checksum
+        )
+        url_helpers.update_rails_memory_service_url(
+          verified_token_with_expiration,
+          url_options
+        ).tap do |generated_url|
+          payload[:url] = generated_url
+        end
+      end
+    end
+
+    def headers_for_direct_upload(_key, content_type:, **)
+      { 'Content-Type' => content_type }
+    end
+
+    private
+
+    def stream(key)
+      io = StringIO.new(store.fetch(key))
+      while data = io.read(5.megabytes)
+        yield data
       end
+    rescue KeyError
+      raise ActiveStorage::FileNotFoundError
+    end
+
+    def url_helpers
+      @url_helpers ||= Activestorage::Memory::Engine.routes.url_helpers
+    end
+
+    def generate_verified_token(key, expires_in:, content_type:, content_length:, checksum:)
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          content_type: content_type,
+          content_length: content_length,
+          checksum: checksum,
+          service_name: name
+        },
+        expires_in: expires_in,
+        purpose: :blob_token
+      )
+    end
+
+    def private_url(key, expires_in:, filename:, content_type:, disposition: :inline, **)
+      generate_url(key, expires_in: expires_in, filename: filename, content_type: content_type, disposition: disposition)
+    end
+
+    def public_url(key, filename:, content_type: nil, disposition: :attachment, **)
+      generate_url(key, expires_in: nil, filename: filename, content_type: content_type, disposition: disposition)
+    end
+
+    def generate_url(key, expires_in:, filename:, content_type:, disposition:)
+      content_disposition = content_disposition_with(type: disposition, filename: ActiveStorage::Filename.wrap(filename))
+      verified_key_with_expiration = ActiveStorage.verifier.generate(
+        {
+          key: key,
+          disposition: content_disposition,
+          content_type: content_type,
+          service_name: name
+        },
+        expires_in: expires_in,
+        purpose: :blob_key
+      )
+
+      if url_options.blank?
+        raise ArgumentError, "Cannot generate URL for #{filename} using Memory service, please set ActiveStorage::Current.url_options."
+      end
+
+      url_helpers.rails_memory_service_url(verified_key_with_expiration, filename: filename, **url_options)
+    end
+
+    def url_options
+      ActiveStorage::Current.url_options || Rails.application.default_url_options
+    end
+
+    def ensure_integrity_of(key, checksum)
+      return if OpenSSL::Digest.new('md5', store[key]).base64digest == checksum
+
+      delete key
+      raise ActiveStorage::IntegrityError
     end
   end
 end

data/lib/activestorage/memory/engine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Activestorage::Memory
+  class Engine < ::Rails::Engine
+    isolate_namespace Activestorage::Memory
+  end
+end

data/lib/{active_storage → activestorage}/memory/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module ActiveStorage
+module Activestorage
   module Memory
-    VERSION = "0.1.0"
+    VERSION = '0.2.0'
   end
 end

data/lib/{active_storage → activestorage}/memory.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "memory/version"
+require_relative 'memory/version'
+require_relative 'memory/engine'
 
 module Activestorage
   module Memory

data/spec/active_storage/service/memory_service_spec.rb

@@ -0,0 +1,99 @@
+require 'rails_helper'
+
+RSpec.describe ActiveStorage::Service::MemoryService do
+  let(:service) { ActiveStorage::Service::MemoryService.new }
+  let(:content) { 'content' }
+  let(:io) { StringIO.new(content) }
+  let(:key) { 'key' }
+  let(:host) { 'example.com' }
+
+  before do
+    ActiveStorage::Current.url_options = { host: host }
+  end
+
+  describe '#upload' do
+    it 'stores by key' do
+      service.upload(key, io)
+      expect(service.store[key]).to eq(content)
+    end
+  end
+
+  describe '#download' do
+    context 'when key does not exist' do
+      it 'raises ActiveStorage::FileNotFoundError' do
+        expect { service.download(key) }.to raise_error(ActiveStorage::FileNotFoundError)
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+      it 'retrieves by key' do
+        expect(service.download(key).read).to eq(content)
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when key does not exist' do
+      it 'ignores key errors' do
+        expect { service.delete(key) }.not_to raise_error
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+
+      it 'deletes by key' do
+        service.delete(key)
+        expect(service.store).not_to have_key(key)
+      end
+    end
+  end
+
+  describe '#exist?' do
+    context 'when key does not exist' do
+      it 'returns false' do
+        expect(service.exist?(key)).to be false
+      end
+    end
+
+    context 'when key exists' do
+      before do
+        service.upload(key, io)
+      end
+
+      it 'checks by key' do
+        expect(service.exist?(key)).to be true
+      end
+    end
+  end
+
+  describe '#url_for_direct_upload' do
+    let(:filename) { 'filename' }
+    let(:content_type) { 'image/jpeg' }
+    let(:content_length) { content.size }
+    let(:checksum) { OpenSSL::Digest.new('md5', content).base64digest }
+    let(:service_name) { 'memory' }
+    let(:expires_in) { 5.minutes }
+
+    before do
+      service.upload(key, io)
+    end
+
+    it 'returns a memory url' do
+      expect(service.url(key, expires_in: expires_in, filename: filename, content_type: content_type)).to start_with("http://#{host}/")
+    end
+  end
+
+  describe '#headers_for_direct_upload' do
+    let(:content_type) { 'image/jpeg' }
+
+    it 'returns content type' do
+      expect(service.headers_for_direct_upload(key, content_type: content_type)).to eq('Content-Type' => content_type)
+    end
+  end
+end

data/spec/activestorage/memory_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Activestorage::Memory do
+  it "has a version number" do
+    expect(Activestorage::Memory::VERSION).not_to be nil
+  end
+end

data/spec/controllers/activestorage/memory/memory_controller_spec.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Activestorage::Memory::MemoryController, type: :request do
+  let(:key) { 'file_key' }
+  let(:content) { 'content' }
+  let(:filename) { 'file.jpg' }
+  let(:content_type) { 'image/jpeg' }
+  let(:service_name) { :memory }
+  let(:disposition) { "inline; filename=\"file.jpg\"; filename*=UTF-8''file.jpg" }
+  let(:expires_in) { ActiveStorage.service_urls_expire_in }
+  let(:checksum) { OpenSSL::Digest.new('md5', content).base64digest }
+  let!(:blob) do
+    ActiveStorage::Blob.create_and_upload!(
+      key: key,
+      io: StringIO.new(content),
+      filename: filename,
+      content_type: content_type,
+      service_name: service_name
+    )
+  end
+
+  before do
+    ActiveStorage::Current.url_options = { only_path: true }
+  end
+
+  describe "GET #show" do
+    let(:valid_key) do
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          service_name: service_name,
+          content_type: content_type,
+          disposition: disposition
+        },
+        expires_in: expires_in,
+        purpose: :blob_key
+      )
+    end
+    let(:invalid_key) { 'invalid_key' }
+
+    subject { get "/rails/active_storage/memory/#{valid_key}/#{filename}" }
+
+    context "when key is valid" do
+      it "returns http success if key is valid and file exists" do
+        subject
+        expect(response).to have_http_status(:success)
+        expect(response.body).to eq(content)
+      end
+
+      context "when file does not exist" do
+        before do
+          ActiveStorage::Blob.services.fetch(service_name).delete(key)
+        end
+
+        it "returns http not_found" do
+          subject
+          expect(response).to have_http_status(:not_found)
+        end
+      end
+    end
+
+    context "when key is invalid" do
+      subject { get "/rails/active_storage/memory/#{invalid_key}/#{filename}" }
+
+      it "returns http not_found" do
+        subject
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+
+  describe "PATCH #update" do
+    let(:valid_token) do
+      ActiveStorage.verifier.generate(
+        {
+          key: key,
+          service_name: service_name,
+          checksum: checksum,
+          content_type: content_type,
+          content_length: content.length
+        },
+        purpose: :blob_token
+      )
+    end
+    let(:invalid_token) { 'invalid_token' }
+
+    context "when token is valid" do
+      context "when content is acceptable" do
+        subject do
+          put(
+            "/rails/active_storage/memory/#{valid_token}",
+            params: content,
+            headers: { 'Content-Type' => content_type, 'Content-Length' => content.size }
+          )
+        end
+
+        it "returns http no_content if token is valid and content is acceptable" do
+          subject
+          expect(response).to have_http_status(:no_content)
+        end
+      end
+
+      context "when content is not acceptable" do
+        subject do
+          put(
+            "/rails/active_storage/memory/#{valid_token}",
+            params: content,
+            headers: { 'Content-Type' => "image/png", 'Content-Length' => content.size }
+          )
+        end
+
+        it "returns http unprocessable_entity" do
+          subject
+          expect(response).to have_http_status(:unprocessable_entity)
+        end
+      end
+    end
+
+    context "when token is invalid" do
+      subject do
+        put(
+          "/rails/active_storage/memory/#{invalid_token}",
+          params: content,
+          headers: { 'Content-Type' => content_type, 'Content-Length' => content.size }
+        )
+      end
+
+      it "returns http not_found" do
+        subject
+        expect(response).to have_http_status(:not_found)
+      end
+    end
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css
+//= link my_engine_manifest.js

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/spec/dummy/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/spec/dummy/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dummy</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+
+    <%= stylesheet_link_tag "application" %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.html.erb

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/app/views/layouts/mailer.text.erb

@@ -0,0 +1 @@
+<%= yield %>

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run