data-action="mouseup->coplan--text-selection#handleEditorMouseUp"<% end %>>
diff --git a/engine/config/importmap.rb b/engine/config/importmap.rb
index 96a920b9..0385da67 100644
--- a/engine/config/importmap.rb
+++ b/engine/config/importmap.rb
@@ -28,6 +28,7 @@
pin "prosemirror-schema-list", to: "https://esm.sh/prosemirror-schema-list@1.5.1?bundle&external=prosemirror-model,prosemirror-state,prosemirror-view,prosemirror-transform,prosemirror-commands,prosemirror-keymap,prosemirror-history,prosemirror-schema-list,prosemirror-markdown", preload: false
pin "prosemirror-markdown", to: "https://esm.sh/prosemirror-markdown@1.13.2?bundle&external=prosemirror-model,prosemirror-state,prosemirror-view,prosemirror-transform,prosemirror-commands,prosemirror-keymap,prosemirror-history,prosemirror-schema-list,prosemirror-markdown", preload: false
pin "coplan/rich_document", to: "coplan/rich_document.js", preload: false
+pin "coplan/rich_uploads", to: "coplan/rich_uploads.js", preload: false
pin "coplan/lettered_lists", to: "coplan/lettered_lists.js", preload: false
pin "coplan/citation_labels", to: "coplan/citation_labels.js", preload: false
pin "coplan/viewport_anchor", to: "coplan/viewport_anchor.js", preload: false
diff --git a/engine/db/demo/content/file-uploads.md b/engine/db/demo/content/file-uploads.md
new file mode 100644
index 00000000..f254f53e
--- /dev/null
+++ b/engine/db/demo/content/file-uploads.md
@@ -0,0 +1,13 @@
+Open **Edit** and drop an image and a text file into the document. Images appear inline; other supported files become download links. You can also paste an image file from your clipboard.
+
+## Drop files here
+
+Drop the same file twice. Each drop inserts an embed, but **Attachments** keeps one stored copy and the editor says the existing file was reused. Rename the local file and drop it again: identical contents keep the original filename, uploader, and URL.
+
+Different contents stay separate, even with the same filename. Reuse is limited to this document. Previously stored duplicates are preserved so their saved links keep working.
+
+## Keep writing
+
+Continue typing during an upload. Its marker stays at the drop location. **Done** waits for uploads and saves the embedded content. **Dual** shows the image or link in Markdown. **Undo** removes an embed while leaving the file in Attachments for reuse.
+
+Try images, PDF, text, Markdown, CSV, JSON, or ZIP files up to 25 MB each. Unsupported files show an error without discarding your writing or the accepted files. If a file fails while **Done** or navigation is waiting, the editor stays open. Retry the file as needed, then **Dismiss** the error before leaving. A later successful upload keeps earlier errors visible until dismissed.
diff --git a/engine/db/demo/content/image-resizing.md b/engine/db/demo/content/image-resizing.md
index 24922cc4..ce362b83 100644
--- a/engine/db/demo/content/image-resizing.md
+++ b/engine/db/demo/content/image-resizing.md
@@ -15,3 +15,11 @@ Both images keep their proportions. **Undo** reverses one resize at a time. Pres
## Pasting images
Paste an image copied from another app: it starts at its natural size within the document width, even if the other app displayed a thumbnail. Copy and paste the saved-width image within Coplan's rich editor to keep its intentional size. Existing saved widths stay as you set them.
+
+## Dropping files into the editor
+
+Open **Edit** and drop an image or file at a spot in the document. Images upload and appear inline at natural size; PDFs, text files, and other supported files become download links. You can also paste an image file from your clipboard. Try dropping an image and a text file together.
+
+An uploading marker stays at the drop point while you keep writing. **Done** waits for uploads and saves the embedded content. **Undo** removes the inserted content; the uploaded files remain in **Attachments** so you can reuse them. Files must be a supported type and no larger than 25 MB each. A rejected file shows an explanation without discarding the other files or your writing.
+
+Drop the same file twice. Each drop inserts an embed, but **Attachments** keeps one stored copy and the editor says the existing file was reused. Identical contents reuse the original filename and uploader even if you rename the local file. Different contents stay separate, including files with the same name. Reuse is limited to this document.
diff --git a/engine/lib/coplan/development_seed.rb b/engine/lib/coplan/development_seed.rb
index 53eb0526..12fa0593 100644
--- a/engine/lib/coplan/development_seed.rb
+++ b/engine/lib/coplan/development_seed.rb
@@ -121,7 +121,10 @@ module DevelopmentSeed
showcase: "A realistic agent-drafted design doc for judging reading: common Markdown elements, SQL, Ruby, YAML, and diff code, a long scrolling line, two Mermaid diagrams, and open, answered, resolved, diagram, table-cell, and general discussions" },
{ key: "image-resizing", author: "hampton", type: "General", title: "Images: resize and snap to full width",
tags: %w[demo images editor], visibility: "published", folder: "Demo content/Rich text", group: "Tables and rich text",
- showcase: "Editor corner resizing, text wrapping beside images, Enter to continue below, undo, and snap to natural full width" },
+ showcase: "Drop or paste files to upload and embed; duplicate drops reuse existing files; image resizing, wrapping, undo, and snap to full width" },
+ { key: "file-uploads", author: "hampton", type: "General", title: "Files: upload once, embed anywhere",
+ tags: %w[demo files editor], visibility: "published", folder: "Demo content/Rich text", group: "Tables and rich text",
+ showcase: "Drop images and files, repeat a drop to reuse storage, keep separate embeds, and undo without deleting attachments" },
{ key: "callout-gallery", author: "hampton", type: "Design Doc", title: "Callouts: notes, tips, and warnings",
tags: %w[demo markdown], visibility: "published", folder: "Demo content/Rich text", group: "Tables and rich text",
showcase: "All six callout types including Summary, a custom label, a list and code inside a callout, and plain quotes for comparison; comment on callout text or edit it in Editor" },
diff --git a/spec/lib/development_seed_spec.rb b/spec/lib/development_seed_spec.rb
index 7e005b1b..ade6aa2b 100644
--- a/spec/lib/development_seed_spec.rb
+++ b/spec/lib/development_seed_spec.rb
@@ -304,12 +304,35 @@ def seeded_plan(key)
expect(CoPlan::Plan.count).to eq(0)
end
+ it "seeds the file upload tryout and preserves uploaded files and embeds on reseeding" do
+ described_class.call
+ plan = seeded_plan("file-uploads")
+ expect(plan.current_content).to include("Drop the same file twice", "one stored copy", "**Done** waits for uploads")
+ expect(plan.current_content).to include("the editor stays open", "**Dismiss** the error", "earlier errors visible until dismissed")
+ expect(plan.attachments.count).to eq(0)
+ expect(seeded_plan("demo-library").current_content).to include("(/#{plan.url_path})")
+ file = Rack::Test::UploadedFile.new(Rails.root.join("spec/fixtures/files/sample.png"), "image/png")
+ uploaded = CoPlan::Plans::AddAttachment.call(plan: plan, file: file, user: plan.created_by_user)
+ expect(uploaded).to be_success
+ url = Rails.application.routes.url_helpers.rails_blob_path(uploaded.attachment.blob, only_path: true)
+ content = "#{plan.current_content}\n\n\n"
+ CoPlan::Plans::ReplaceContent.call(plan: plan, new_content: content,
+ base_revision: plan.current_revision, actor_type: "human", actor_id: plan.created_by_user_id)
+ revision = plan.current_revision
+ described_class.call
+ expect(plan.reload.current_revision).to eq(revision)
+ expect(plan.current_content).to eq(content)
+ expect(plan.attachments_attachments.pluck(:id)).to eq([ uploaded.attachment.id ])
+ end
+
it "seeds image resizing once and preserves a person's saved image width" do
described_class.call
plan = seeded_plan("image-resizing")
expect(plan.current_content).to include(described_class.demo_logo_url, 'width="320"', "![Coplan logo at natural width]")
expect(plan.current_content).to include("This text starts at the top beside", "This paragraph deliberately starts below", "**Shift+Enter**", "**Enter**")
expect(plan.current_content).to include("## Pasting images", "even if the other app displayed a thumbnail")
+ expect(plan.current_content).to include("## Dropping files into the editor", "download links", "**Done** waits for uploads", "remain in **Attachments**")
+ expect(plan.current_content).to include("Drop the same file twice", "one stored copy", "Different contents stay separate")
expect(seeded_plan("demo-library").current_content).to include("(/#{plan.url_path})")
revision = plan.current_revision
described_class.call
diff --git a/spec/requests/api/v1/attachments_spec.rb b/spec/requests/api/v1/attachments_spec.rb
index 14b1bc6a..a3c0fe41 100644
--- a/spec/requests/api/v1/attachments_spec.rb
+++ b/spec/requests/api/v1/attachments_spec.rb
@@ -19,6 +19,19 @@ def upload_file(fixture = "sample.png", content_type = "image/png", headers: sel
end
describe "POST /api/v1/plans/:plan_id/attachments" do
+ it "returns the existing attachment and URLs on an identical retry" do
+ upload_file
+ original = response.parsed_body
+ expect(original["reused"]).to be(false)
+ upload_file
+
+ expect(response).to have_http_status(:created)
+ expect(response.parsed_body).to include("reused" => true, "id" => original["id"], "url" => original["url"], "markdown" => original["markdown"])
+ expect(plan.attachments.count).to eq(1)
+ expect(ActiveStorage::Blob.count).to eq(1)
+ expect(plan.plan_events.where(event_type: "attachment_added").count).to eq(1)
+ end
+
it "uploads a file and returns attachment JSON with URLs and markdown snippet" do
expect { upload_file }.to change { plan.attachments_attachments.count }.by(1)
diff --git a/spec/requests/attachments_spec.rb b/spec/requests/attachments_spec.rb
index 378d4e09..9a5e50cc 100644
--- a/spec/requests/attachments_spec.rb
+++ b/spec/requests/attachments_spec.rb
@@ -6,6 +6,61 @@
let(:plan) { create(:plan, :considering, created_by_user: author) }
describe "POST /plans/:plan_id/attachments" do
+ it "returns one attachment for repeated files in the same editor upload" do
+ sign_in_as(author)
+ post plan_attachments_path(plan), params: {
+ files: [ fixture_file_upload("sample.png", "image/png"), fixture_file_upload("sample.png", "image/png") ]
+ }, headers: { "Accept" => "application/json" }
+
+ expect(response).to have_http_status(:created)
+ files = response.parsed_body["attachments"]
+ expect(files.map { |file| file["id"] }.uniq.size).to eq(1)
+ expect(files.map { |file| file["reused"] }).to eq([ false, true ])
+ expect(plan.attachments.count).to eq(1)
+ expect(ActiveStorage::Blob.count).to eq(1)
+ end
+
+ it "returns stable image and download URLs for editor uploads and refreshes attachment counts" do
+ sign_in_as(author)
+ post plan_attachments_path(plan), params: {
+ files: [ fixture_file_upload("sample.png", "image/png"), fixture_file_upload("sample.txt", "text/plain") ]
+ }, headers: { "Accept" => "application/json" }
+
+ expect(response).to have_http_status(:created)
+ data = response.parsed_body
+ expect(data["errors"]).to eq([])
+ expect(data["attachments"].map { |file| file["filename"] }).to eq(%w[sample.png sample.txt])
+ expect(data["attachments"].first).to include("content_type" => "image/png", "url" => a_string_starting_with("/rails/active_storage/"))
+ expect(data["attachments"].last["download_url"]).to include("disposition=attachment")
+ expect(data["streams"]).to include('target="plan-attachments"', 'target="attachments-count"', 'target="nav-attachments-count"')
+ expect(plan.current_revision).to eq(1) # Embedding is a separate, ordinary editor save.
+ end
+
+ it "returns successful files alongside per-file errors in a mixed editor upload" do
+ sign_in_as(author)
+ post plan_attachments_path(plan), params: {
+ files: [ fixture_file_upload("sample.html", "text/html"), fixture_file_upload("sample.png", "image/png") ]
+ }, headers: { "Accept" => "application/json" }
+
+ expect(response).to have_http_status(:created)
+ expect(response.parsed_body["attachments"].map { |file| file["filename"] }).to eq([ "sample.png" ])
+ expect(response.parsed_body["errors"]).to contain_exactly(a_string_including("sample.html", "not allowed"))
+ expect(plan.attachments.count).to eq(1)
+ end
+
+ it "returns JSON validation errors when no files can be uploaded" do
+ sign_in_as(author)
+ post plan_attachments_path(plan), params: { files: [ fixture_file_upload("sample.html", "text/html") ] },
+ headers: { "Accept" => "application/json" }
+ expect(response).to have_http_status(:unprocessable_content)
+ expect(response.parsed_body["attachments"]).to eq([])
+ expect(response.parsed_body["errors"]).to contain_exactly(a_string_including("not allowed"))
+
+ post plan_attachments_path(plan), headers: { "Accept" => "application/json" }
+ expect(response).to have_http_status(:unprocessable_content)
+ expect(response.parsed_body["errors"]).to eq([ "Choose at least one file to upload." ])
+ end
+
it "uploads files for the plan author and logs events" do
sign_in_as(author)
diff --git a/spec/services/plans/add_attachment_concurrency_spec.rb b/spec/services/plans/add_attachment_concurrency_spec.rb
new file mode 100644
index 00000000..460814c8
--- /dev/null
+++ b/spec/services/plans/add_attachment_concurrency_spec.rb
@@ -0,0 +1,47 @@
+require "rails_helper"
+
+RSpec.describe "Concurrent identical attachment uploads" do
+ self.use_transactional_tests = false
+
+ after do
+ truncate_tables(*(ActiveRecord::Base.connection.tables - %w[schema_migrations ar_internal_metadata]))
+ end
+
+ it "keeps one attachment, blob, stored file, and event when uploads finish together" do
+ user = create(:coplan_user)
+ plan = create(:plan, created_by_user: user)
+ ready, release = Queue.new, Queue.new
+ allow(ActiveStorage::Blob).to receive(:create_and_upload!).and_wrap_original do |method, **arguments|
+ blob = method.call(**arguments)
+ ready << blob
+ release.pop
+ blob
+ end
+ workers = 2.times.map do
+ Thread.new do
+ ActiveRecord::Base.connection_pool.with_connection do
+ file = Rack::Test::UploadedFile.new(Rails.root.join("spec/fixtures/files/sample.png"), "image/png")
+ CoPlan::Plans::AddAttachment.call(plan: CoPlan::Plan.find(plan.id), file: file, user: user)
+ end
+ end
+ end
+ blobs = Timeout.timeout(10) { 2.times.map { ready.pop } }
+ 2.times { release << true }
+ workers.each { |worker| expect(worker.join(20)).to be_present }
+ results = workers.map(&:value)
+
+ expect(results).to all(be_success)
+ expect(results.map { |result| result.attachment.id }.uniq.size).to eq(1)
+ expect(results.count(&:reused?)).to eq(1)
+ expect(plan.attachments.count).to eq(1)
+ expect(ActiveStorage::Blob.count).to eq(1)
+ expect(blobs.count { |blob| blob.service.exist?(blob.key) }).to eq(1)
+ expect(plan.plan_events.where(event_type: "attachment_added").count).to eq(1)
+ ensure
+ 2.times { release << true } if release
+ workers&.each do |worker|
+ worker.kill if worker.alive?
+ worker.join
+ end
+ end
+end
diff --git a/spec/services/plans/add_attachment_spec.rb b/spec/services/plans/add_attachment_spec.rb
index 8da7f77f..272062b1 100644
--- a/spec/services/plans/add_attachment_spec.rb
+++ b/spec/services/plans/add_attachment_spec.rb
@@ -36,6 +36,76 @@ def uploaded_file(fixture = "sample.png", content_type = "image/png")
expect(event.actor_id).to eq("token-123")
end
+ it "reuses identical content without another blob, storage upload, attachment, or event" do
+ original = described_class.call(plan: plan, file: uploaded_file, user: user)
+ expect(original).not_to be_reused
+ expect(ActiveStorage::Blob).not_to receive(:create_and_upload!)
+
+ expect {
+ repeated = described_class.call(plan: plan, file: uploaded_file, user: user)
+ expect(repeated).to be_success
+ expect(repeated).to be_reused
+ expect(repeated.attachment).to eq(original.attachment)
+ }.not_to change(ActiveStorage::Blob, :count)
+ expect(plan.attachments.count).to eq(1)
+ expect(plan.plan_events.where(event_type: "attachment_added").count).to eq(1)
+ end
+
+ it "reuses renamed content while keeping the original filename and uploader" do
+ original = described_class.call(plan: plan, file: uploaded_file, user: user)
+ renamed = Rack::Test::UploadedFile.new(Rails.root.join("spec/fixtures/files/sample.png"),
+ "image/png", original_filename: "renamed.png")
+ result = described_class.call(plan: plan, file: renamed, user: create(:coplan_user))
+
+ expect(result).to be_reused
+ expect(result.attachment).to eq(original.attachment)
+ expect(result.attachment.blob.filename.to_s).to eq("sample.png")
+ expect(result.attachment.blob.metadata["uploaded_by_id"]).to eq(user.id)
+ end
+
+ it "stores different contents separately even with the same filename" do
+ original = described_class.call(plan: plan, file: uploaded_file("sample.txt", "text/plain"), user: user)
+ changed = uploaded_file("sample.txt", "text/plain")
+ changed.tempfile.rewind
+ changed.tempfile.truncate(0)
+ changed.tempfile.write("x" * original.attachment.blob.byte_size)
+ changed.tempfile.rewind
+ result = described_class.call(plan: plan, file: changed, user: user)
+
+ expect(result).to be_success
+ expect(result).not_to be_reused
+ expect(result.attachment.blob_id).not_to eq(original.attachment.blob_id)
+ expect(plan.attachments.count).to eq(2)
+ end
+
+ it "keeps identical files on different plans independent" do
+ original = described_class.call(plan: plan, file: uploaded_file, user: user)
+ other_plan = create(:plan, created_by_user: user)
+ result = described_class.call(plan: other_plan, file: uploaded_file, user: user)
+
+ expect(result).not_to be_reused
+ expect(result.attachment.blob_id).not_to eq(original.attachment.blob_id)
+ expect(other_plan.attachments.count).to eq(1)
+ end
+
+ it "compares checksums case-sensitively even on a case-insensitive database" do
+ original = described_class.call(plan: plan, file: uploaded_file, user: user)
+ original.attachment.blob.update_columns(checksum: original.attachment.blob.checksum.swapcase)
+ result = described_class.call(plan: plan, file: uploaded_file, user: user)
+
+ expect(result).not_to be_reused
+ expect(plan.attachments.count).to eq(2)
+ end
+
+ it "does not save unrelated pending plan changes while attaching" do
+ plan.title = "An unsaved title"
+ expect {
+ result = described_class.call(plan: plan, file: uploaded_file, user: user)
+ expect(result.error).to include("Save plan changes")
+ }.not_to change(ActiveStorage::Blob, :count)
+ expect(plan.reload.title).not_to eq("An unsaved title")
+ end
+
it "rejects a missing file" do
result = described_class.call(plan: plan, file: nil, user: user)
expect(result.error).to include("file is required")
diff --git a/spec/system/editor_uploads_spec.rb b/spec/system/editor_uploads_spec.rb
new file mode 100644
index 00000000..d5e5b81f
--- /dev/null
+++ b/spec/system/editor_uploads_spec.rb
@@ -0,0 +1,281 @@
+require "rails_helper"
+require "base64"
+
+RSpec.describe "Uploading files in the rich editor", type: :system do
+ let(:author) { create(:coplan_user, email: "drop-editor@example.com") }
+ let(:source) { "# Drop uploads\n\nBefore upload.\n\nKeep writing here.\n" }
+ let(:plan) { CoPlan::Plans::Create.call(title: "Drop uploads", content: source, user: author, visibility: "draft", actor_type: "human") }
+
+ before do
+ visit sign_in_path
+ fill_in "Email address", with: author.email
+ click_button "Sign In"
+ expect(page).to have_current_path(root_path, wait: 15)
+ visit plan_edit_page_path(plan)
+ expect(page).to have_css(".ProseMirror p", text: "Before upload.", wait: 20)
+ end
+
+ def transfer_files(*names, paste: false)
+ files = names.map do |name|
+ path = name == "sample.png" ? Rails.root.join("engine/app/assets/images/coplan/coplan-logo-sm.png") : Rails.root.join("spec/fixtures/files", name)
+ { name: name, data: Base64.strict_encode64(File.binread(path)),
+ type: { "sample.png" => "image/png", "sample.txt" => "text/plain", "sample.html" => "text/html" }.fetch(name) }
+ end
+ page.execute_script(<<~JS, files, paste)
+ const transfer = new DataTransfer();
+ for (const file of arguments[0]) transfer.items.add(new File([Uint8Array.from(atob(file.data), c => c.charCodeAt(0))], file.name, { type: file.type }));
+ const editor = document.querySelector('.document-editor__body .ProseMirror');
+ const paragraph = editor.querySelector('p') || editor.querySelector('h1');
+ paragraph.scrollIntoView({ block: 'center' });
+ const rect = paragraph.getBoundingClientRect();
+ if (arguments[1]) {
+ editor.focus();
+ const range = document.createRange(); range.selectNodeContents(paragraph); range.collapse(false);
+ window.getSelection().removeAllRanges(); window.getSelection().addRange(range);
+ paragraph.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+ editor.dispatchEvent(new ClipboardEvent('paste', { clipboardData: transfer, bubbles: true, cancelable: true }));
+ } else {
+ paragraph.dispatchEvent(new DragEvent('dragover', { dataTransfer: transfer, bubbles: true, cancelable: true }));
+ window.dropWasHighlighted = editor.classList.contains('is-file-drop-target');
+ paragraph.dispatchEvent(new DragEvent('drop', { dataTransfer: transfer, clientX: rect.left + 4, clientY: rect.top + rect.height / 2, bubbles: true, cancelable: true }));
+ }
+ JS
+ end
+
+ def content
+ page.evaluate_script('document.querySelector("textarea[name=content]").value')
+ end
+
+ def hold_upload(network_failure: false)
+ page.execute_script(<<~JS, network_failure)
+ const original = window.fetch;
+ let failNextUpload = arguments[0];
+ window.uploadGate = new Promise(resolve => window.releaseUpload = resolve);
+ window.fetch = async function(url, options) {
+ if (String(url).endsWith('/attachments') && options?.method === 'POST') {
+ await window.uploadGate;
+ if (failNextUpload) { failNextUpload = false; throw new Error('Offline'); }
+ }
+ return original.apply(this, arguments);
+ };
+ JS
+ end
+
+ %w[light dark].product(%w[done navigation], %w[network partial]).each do |theme, exit_path, failure|
+ it "keeps upload failures visible while leaving through #{exit_path} after #{failure} rejection in #{theme}" do
+ page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+ hold_upload(network_failure: failure == "network")
+ paragraph = find(".ProseMirror p", text: "Keep writing here.")
+ paragraph.click
+ paragraph.send_keys(:end, " Draft survives.")
+ transfer_files(*(failure == "network" ? [ "sample.png" ] : [ "sample.html", "sample.txt" ]))
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ location = find('a[aria-label^="Up to "]')
+ destination = exit_path == "done" ? plan_page_path(plan) : URI.parse(location[:href]).request_uri
+ exit_editor = -> { exit_path == "done" ? click_link("Done") : find('a[aria-label^="Up to "]').click }
+ exit_editor.call
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ page.execute_script("window.releaseUpload()")
+ message = failure == "network" ? "Offline" : /sample.html.*not allowed/
+ expect(page).to have_css('[role="alert"].document-editor__upload-notice', text: message)
+ expect(page).to have_css(".document-editor")
+ expect(page).not_to have_css(".document-editor__upload-placeholder")
+ expect(content).to include("Draft survives.")
+ expect(content).not_to include("sample.html")
+ expect(page).to have_css('.ProseMirror a', text: "sample.txt") if failure == "partial"
+
+ # A later success must not erase an unacknowledged rejection.
+ transfer_files(failure == "network" ? "sample.txt" : "sample.png", paste: true)
+ expect(page).to have_css('.ProseMirror a', text: "sample.txt")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]') if failure == "partial"
+ expect(page).to have_css('[role="alert"].document-editor__upload-notice', text: message)
+ exit_editor.call
+ expect(page).to have_css(".document-editor")
+ page.save_screenshot(Rails.root.join("tmp/screenshots/editor-uploads/failed-#{exit_path}-#{failure}-#{theme}.png"))
+
+ click_button "Dismiss", exact: true
+ expect(page).not_to have_css(".document-editor__upload-notice")
+ exit_editor.call
+ expect(page).not_to have_css(".document-editor", wait: 20)
+ expect(page).to have_current_path(destination)
+ expect(plan.reload.current_content).to include("Draft survives.", "[sample.txt]")
+ expect(plan.current_content).to include("![sample.png]") if failure == "partial"
+ expect(plan.current_content).not_to include("sample.html")
+ expect(plan.attachments.count).to eq(failure == "network" ? 1 : 2)
+ end
+ end
+
+ def hold_save
+ page.execute_script(<<~JS)
+ const original = window.fetch;
+ let held = false;
+ window.saveGate = new Promise(resolve => window.releaseSave = resolve);
+ window.fetch = async function(url, options) {
+ if (options?.method === 'PATCH' && !held) { held = true; await window.saveGate; }
+ return original.apply(this, arguments);
+ };
+ JS
+ end
+
+ %w[light dark].product(%w[done navigation]).each do |theme, exit_path|
+ it "waits for files added after leaving starts through #{exit_path} in #{theme}" do
+ page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+ hold_save
+ hold_upload
+ paragraph = find(".ProseMirror p", text: "Before upload.")
+ paragraph.click
+ paragraph.send_keys(:end, " Saved before leaving.")
+ if exit_path == "done"
+ click_link "Done"
+ destination = plan_page_path(plan)
+ else
+ location = find('a[aria-label^="Up to "]')
+ destination = URI.parse(location[:href]).request_uri
+ location.click
+ end
+ expect(page).to have_css('.document-editor__close-inline[data-state="saving"]')
+ transfer_files("sample.png", paste: exit_path == "navigation")
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ page.execute_script("window.releaseSave()")
+ expect(page).not_to have_css('.document-editor__close-inline[data-state="saving"]')
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ expect(page).to have_css(".document-editor")
+ page.save_screenshot(Rails.root.join("tmp/screenshots/editor-uploads/late-#{exit_path}-#{theme}.png"))
+
+ page.execute_script("window.releaseUpload()")
+ expect(page).not_to have_css(".document-editor", wait: 20)
+ expect(page).to have_current_path(destination)
+ expect(plan.reload.current_content).to include("Saved before leaving.", "![sample.png]")
+ expect(plan.attachments.count).to eq(1)
+ end
+ end
+
+ %w[light dark].each do |theme|
+ it "reuses dropped files while inserting another embed in #{theme}" do
+ page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+ transfer_files("sample.png", "sample.txt")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]', count: 1)
+ original_url = find('.ProseMirror img[alt="sample.png"]')["src"]
+ transfer_files("sample.png", "sample.txt")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]', count: 2)
+ expect(page).to have_css('.ProseMirror a', text: "sample.txt", count: 2)
+ expect(page).to have_css(".document-editor__upload-notice", text: "2 existing files reused.")
+ expect(all('.ProseMirror img[alt="sample.png"]').map { |image| image["src"] }.uniq).to eq([ original_url ])
+ expect(plan.attachments.count).to eq(2)
+ expect(plan.plan_events.where(event_type: "attachment_added").count).to eq(2)
+ page.save_screenshot(Rails.root.join("tmp/screenshots/editor-uploads/reused-#{theme}.png"))
+ find(".document-editor__close-inline:not(:disabled)").click
+ expect(page).to have_current_path(plan_page_path(plan), wait: 15)
+ expect(plan.reload.current_content.scan("![sample.png]").size).to eq(2)
+ expect(page).to have_css('#plan-content-body img[alt="sample.png"]', count: 2)
+ end
+
+ it "embeds dropped images and files, supports undo, and persists in #{theme}" do
+ page.execute_script("document.documentElement.dataset.theme = arguments[0]", theme)
+ hold_upload
+ transfer_files("sample.png", "sample.txt")
+ expect(page.evaluate_script("window.dropWasHighlighted")).to be(true)
+ expect(page).not_to have_css(".ProseMirror.is-file-drop-target")
+ expect(page).to have_css(".document-editor__upload-placeholder", text: "sample.png, sample.txt")
+ expect(content).to eq(source)
+ page.save_screenshot(Rails.root.join("tmp/screenshots/editor-uploads/pending-#{theme}.png"))
+ page.execute_script("window.releaseUpload()")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ expect(page).to have_css('.ProseMirror a[href*="disposition=attachment"]', text: "sample.txt")
+ expect(page).not_to have_css(".document-editor__upload-placeholder")
+ click_button "Undo"
+ expect(page).not_to have_css('.ProseMirror img[alt="sample.png"]')
+ expect(page).not_to have_css('.ProseMirror a', text: "sample.txt")
+ click_button "Redo"
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ page.save_screenshot(Rails.root.join("tmp/screenshots/editor-uploads/embedded-#{theme}.png"))
+ find(".document-editor__close-inline:not(:disabled)").click
+ expect(page).to have_current_path(plan_page_path(plan), wait: 15)
+ expect(page).to have_css('#plan-content-body img[alt="sample.png"]')
+ expect(plan.reload.current_content).to include("![sample.png]", "[sample.txt]", "Before upload.")
+ expect(plan.attachments.count).to eq(2)
+ visit plan_edit_page_path(plan)
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]', wait: 20)
+ end
+ end
+
+ it "maps the drop point through continued typing and waits for uploads on Done" do
+ hold_upload
+ transfer_files("sample.png")
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ title = find(".ProseMirror h1")
+ title.click
+ title.send_keys(:end, " with edits")
+ expect(content).to include("# Drop uploads with edits")
+ paragraph = find(".ProseMirror p", text: "Keep writing here.")
+ paragraph.click
+ paragraph.send_keys(:end, " Still writing.")
+ expect(content).to include("Still writing.")
+ find(".document-editor__close-inline:not(:disabled)").click
+ expect(page).to have_css(".document-editor__upload-placeholder")
+ page.execute_script("window.releaseUpload()")
+ expect(page).not_to have_css(".document-editor", wait: 20)
+ expect(plan.reload.current_content).to include("![sample.png]", "Still writing.")
+ expect(plan.title).to eq("Drop uploads with edits")
+ expect(page).to have_current_path(plan_page_path(plan))
+ expect(plan.current_content.index("![sample.png]")).to be < plan.current_content.index("Keep writing here.")
+ end
+
+ it "keeps successful files from a mixed drop and lets rejected files be retried" do
+ transfer_files("sample.html", "sample.txt")
+ expect(page).to have_css('.ProseMirror a', text: "sample.txt")
+ expect(page).to have_css('[role="alert"].document-editor__upload-notice', text: /sample.html.*not allowed/)
+ expect(content).not_to include("sample.html")
+ expect(page).not_to have_css(".document-editor__upload-placeholder")
+ transfer_files("sample.png")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ end
+
+ it "retains the document on a network failure and accepts another drop" do
+ page.execute_script(<<~JS)
+ const original = window.fetch;
+ window.fetch = function(url, options) {
+ if (String(url).endsWith('/attachments')) { window.fetch = original; return Promise.reject(new Error('Offline')); }
+ return original.apply(this, arguments);
+ };
+ JS
+ transfer_files("sample.png")
+ expect(page).to have_css('[role="alert"].document-editor__upload-notice', text: "Offline")
+ expect(page).not_to have_css(".document-editor__upload-placeholder")
+ expect(content).to eq(source)
+ transfer_files("sample.png")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ end
+
+ it "uploads pasted image files" do
+ transfer_files("sample.png", paste: true)
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ expect(plan.attachments.count).to eq(1)
+ end
+
+ it "synchronizes dropped files into Markdown in Dual mode" do
+ click_button "Dual", exact: true
+ transfer_files("sample.png", "sample.txt")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ expect(find('[aria-label="Markdown source"]')).to have_text("![sample.png]")
+ expect(find('[aria-label="Markdown source"]')).to have_text("[sample.txt]")
+ click_button "Raw", exact: true
+ expect(find('[aria-label="Markdown source"]')).to have_text("![sample.png]")
+ click_button "Editor", exact: true
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]')
+ expect(plan.attachments.count).to eq(2)
+ end
+
+ it "creates an unsaved document before uploading its first file" do
+ visit new_plan_path
+ expect(page).to have_css(".ProseMirror", wait: 20)
+ transfer_files("sample.png")
+ expect(page).to have_css('.ProseMirror img[alt="sample.png"]', wait: 20)
+ find(".document-editor__close-inline:not(:disabled)").click
+ expect(page).not_to have_css(".document-editor")
+ created = CoPlan::Plan.where(created_by_user: author).order(created_at: :desc).first
+ expect(created).not_to eq(plan)
+ expect(created.current_content).to include("![sample.png]")
+ expect(created.attachments.count).to eq(1)
+ end
+end