fix write scratch buffer to file

helix-term/src/commands/typed.rs

@@ -273,10 +273,6 @@ fn write_impl(
     let doc = doc_mut!(cx.editor);
     let path = path.map(AsRef::as_ref);
 
-    if doc.path().is_none() {
-        bail!("cannot write a buffer without a filename");
-    }
-
     let fmt = if editor_auto_fmt {
         doc.auto_format().map(|fmt| {
             let callback = make_format_callback(

helix-term/tests/test/write.rs

@@ -128,6 +128,52 @@ async fn test_write_fail_mod_flag() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn test_write_scratch_to_new_path() -> anyhow::Result<()> {
+    let mut file = tempfile::NamedTempFile::new()?;
+
+    test_key_sequence(
+        &mut Application::new(Args::default(), Config::default())?,
+        Some(format!("ihello<esc>:w {}<ret>", file.path().to_string_lossy()).as_ref()),
+        Some(&|app| {
+            assert!(!app.editor.is_err());
+
+            let mut docs: Vec<_> = app.editor.documents().collect();
+            assert_eq!(1, docs.len());
+
+            let doc = docs.pop().unwrap();
+            assert_eq!(Some(&file.path().to_path_buf()), doc.path());
+        }),
+        false,
+    )
+    .await?;
+
+    helpers::assert_file_has_content(file.as_file_mut(), &helpers::platform_line("hello"))?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_write_scratch_no_path_fails() -> anyhow::Result<()> {
+    helpers::test_key_sequence_with_input_text(
+        None,
+        ("#[\n|]#", "ihello<esc>:w<ret>", "hello#[\n|]#"),
+        &|app| {
+            assert!(app.editor.is_err());
+
+            let mut docs: Vec<_> = app.editor.documents().collect();
+            assert_eq!(1, docs.len());
+
+            let doc = docs.pop().unwrap();
+            assert_eq!(None, doc.path());
+        },
+        false,
+    )
+    .await?;
+
+    Ok(())
+}
+
 #[tokio::test]
 async fn test_write_new_path() -> anyhow::Result<()> {
     let mut file1 = tempfile::NamedTempFile::new().unwrap();
@@ -164,24 +210,15 @@ async fn test_write_new_path() -> anyhow::Result<()> {
     )
     .await?;
 
-    file1.as_file_mut().flush()?;
+    helpers::assert_file_has_content(
-    file1.as_file_mut().sync_all()?;
+        file1.as_file_mut(),
-    file2.as_file_mut().flush()?;
+        &helpers::platform_line("i can eat glass, it will not hurt me\n"),
-    file2.as_file_mut().sync_all()?;
+    )?;
 
-    let mut file1_content = String::new();
+    helpers::assert_file_has_content(
-    file1.as_file_mut().read_to_string(&mut file1_content)?;
+        file2.as_file_mut(),
-    assert_eq!(
+        &helpers::platform_line("i can eat glass, it will not hurt me\n"),
-        helpers::platform_line("i can eat glass, it will not hurt me\n"),
+    )?;
-        file1_content
-    );
-
-    let mut file2_content = String::new();
-    file2.as_file_mut().read_to_string(&mut file2_content)?;
-    assert_eq!(
-        helpers::platform_line("i can eat glass, it will not hurt me\n"),
-        file2_content
-    );
 
     Ok(())
 }

helix-view/src/document.rs

@@ -574,7 +574,12 @@ impl Document {
             }
         };
 
-        let identifier = self.identifier();
+        let identifier = if self.path().is_some() {
+            Some(self.identifier())
+        } else {
+            None
+        };
+
         let language_server = self.language_server.clone();
 
         // mark changes up to now as saved
@@ -628,10 +633,13 @@ impl Document {
                 if !language_server.is_initialized() {
                     return Ok(event);
                 }
-                if let Some(notification) =
+
-                    language_server.text_document_did_save(identifier, &text)
+                if let Some(identifier) = identifier {
-                {
+                    if let Some(notification) =
-                    notification.await?;
+                        language_server.text_document_did_save(identifier, &text)
+                    {
+                        notification.await?;
+                    }
                 }
             }