Fix: Correct translation of leading slash in Linux/OS X paths to/from a URL.

This fixes rewrites of URL in Markdown to long relative paths.

Author: bjones1

server/src/webserver.rs

@@ -520,8 +520,16 @@ pub async fn filesystem_endpoint(
     // On Windows, backslashes in the `request_file_path` will be treated as
     // path separators; however, HTTP does not treat them as path separators.
     // Therefore, re-encode them to prevent inconsistency between the way HTTP
-    // and this program interpret file paths.
+    // and this program interpret file paths. On OS X/Linux, the path starts
+    // with a leading slash, which gets absorbed into the URL to prevent a URL
+    // such as "/fw/fsc/1//foo/bar/...". Restore it here.
+    #[cfg(target_os = "windows")]
     let fixed_file_path = request_file_path.replace("\\", "%5C");
+    // On OS X/Linux, the path starts with a leading slash, which gets absorbed
+    // into the URL to prevent a URL such as "/fw/fsc/1//foo/bar/...". Restore
+    // it here.
+    #[cfg(not(target_os = "windows"))]
+    let fixed_file_path = format!("/{request_file_path}");
     let file_path = match try_canonicalize(&fixed_file_path) {
         Ok(v) => v,
         Err(err) => {
@@ -658,9 +666,9 @@ async fn text_file_to_response(
 ) -> (
     // The response to send back to the HTTP endpoint.
     SimpleHttpResponse,
-    // If the response is a Client, also return the appropriate `Update`
-    // data to populate the Client with the parsed `file_contents`. In all other
-    // cases, return None.
+    // If the response is a Client, also return the appropriate `Update` data to
+    // populate the Client with the parsed `file_contents`. In all other cases,
+    // return None.
     Option<EditorMessageContents>,
 ) {
     // Use a lossy conversion, since this is UI display, not filesystem access.
@@ -1322,7 +1330,22 @@ fn path_to_url(prefix: &str, connection_id: &str, file_path: &Path) -> String {
         // Then put it all back together.
         .collect::<Vec<_>>()
         .join("/");
-    format!("{prefix}/{connection_id}/{pathname}")
+    // On Windows, path names start with a drive letter. On Linux/OS X, they
+    // start with a forward slash -- don't put a double forward slash in the
+    // resulting path.
+    format!("{prefix}/{connection_id}/{}", drop_leading_slash(&pathname))
+}
+
+// Given a string (which is probably a pathname), drop the leading slash if it's
+// present.
+fn drop_leading_slash(path_: &str) -> &str {
+    if path_.starts_with("/") {
+        let mut chars = path_.chars();
+        chars.next();
+        chars.as_str()
+    } else {
+        path_
+    }
 }
 
 // Given a `Path`, transform it into a displayable HTML string (with any

server/src/webserver/filewatcher.rs

@@ -744,7 +744,7 @@ mod tests {
             source_to_codechat_for_web,
         },
         test_utils::{check_logger_errors, configure_testing_logger},
-        webserver::{IdeType, ResultOkTypes, tests::IP_PORT},
+        webserver::{IdeType, ResultOkTypes, drop_leading_slash, tests::IP_PORT},
     };
 
     async fn get_websocket_queues(
@@ -822,15 +822,21 @@ mod tests {
             .unwrap()
             .map(|s| urlencoding::decode(s).unwrap())
             .collect();
-        let url_path = PathBuf::from_str(&url_segs[3..].join("/"))
-            .unwrap()
-            .canonicalize()
-            .unwrap();
+        let mut url_path = if cfg!(windows) {
+            PathBuf::new()
+        } else {
+            PathBuf::from_str("/").unwrap()
+        };
+        url_path.push(PathBuf::from_str(&url_segs[3..].join("/")).unwrap());
+        let url_path = url_path.canonicalize().unwrap();
         assert_eq!(url_path, test_path);
         send_response(&ide_tx_queue, id, Ok(ResultOkTypes::Void)).await;
 
         // 2.  After fetching the file, we should get an update.
-        let uri = format!("/fw/fsc/1/{}/test.py", test_dir.to_slash().unwrap());
+        let uri = format!(
+            "/fw/fsc/1/{}/test.py",
+            drop_leading_slash(&test_dir.to_slash().unwrap())
+        );
         let req = test::TestRequest::get().uri(&uri).to_request();
         let resp = test::call_service(&app, req).await;
         assert!(resp.status().is_success());
@@ -869,7 +875,10 @@ mod tests {
             .to_str()
             .unwrap()
             .to_string();
-        let uri = format!("/fw/fsc/1/{}/test.py", test_dir.to_slash().unwrap());
+        let uri = format!(
+            "/fw/fsc/1/{}/test.py",
+            drop_leading_slash(&test_dir.to_slash().unwrap())
+        );
         let req = test::TestRequest::get().uri(&uri).to_request();
         let resp = test::call_service(&app, req).await;
         assert!(resp.status().is_success());
@@ -1050,7 +1059,7 @@ mod tests {
         new_file_path.push("test1.py");
         let new_uri = format!(
             "http://localhost/fw/fsc/1/{}",
-            urlencoding::encode(&new_file_path.to_slash().unwrap())
+            drop_leading_slash(&urlencoding::encode(&new_file_path.to_slash().unwrap()))
         );
         ide_tx_queue
             .send(EditorMessage {

server/src/webserver/tests.rs

@@ -24,7 +24,7 @@ use std::{
 };
 
 use assert_cmd::Command;
-use assertables::{assert_ends_with, assert_starts_with};
+use assertables::{assert_ends_with, assert_not_contains, assert_starts_with};
 
 use super::{filewatcher::FILEWATCHER_PATH_PREFIX, path_to_url, url_to_path};
 use crate::prep_test_dir;
@@ -106,6 +106,8 @@ fn test_path_to_url() {
     let url = path_to_url("/a/b", "conn1", &file_path);
     assert_starts_with!(url, "/a/b/conn1/");
     assert_ends_with!(url, "test_path_to_url/test%20spaces.py");
+    // There shouldn't be a double forward slash in the name.
+    assert_not_contains!(url, "//");
     // Report any errors produced when removing the temporary directory.
     temp_dir.close().unwrap();
 }

server/src/webserver/vscode.rs

@@ -414,7 +414,8 @@ pub async fn vscode_ide_websocket(
                                                                 file_path: clean_file_path.to_str().expect("Since the path started as a string, assume it losslessly translates back to a string.").to_string(),
                                                                 contents: Some(CodeChatForWeb {
                                                                     metadata: SourceFileMetadata {
-                                                                        // Since this is raw data, `mode` doesn't matter.
+                                                                        // Since this is raw data, `mode` doesn't
+                                                                        // matter.
                                                                         mode: "".to_string()
                                                                     },
                                                                     source: CodeMirror {
@@ -739,7 +740,7 @@ mod test {
         cast,
         processing::{CodeChatForWeb, CodeMirror, SourceFileMetadata},
         test_utils::{_prep_test_dir, check_logger_errors, configure_testing_logger},
-        webserver::{ResultOkTypes, UpdateMessageContents},
+        webserver::{ResultOkTypes, UpdateMessageContents, drop_leading_slash},
     };
 
     lazy_static! {
@@ -972,7 +973,7 @@ mod test {
         open_client(&mut ws_ide).await;
 
         let file_path = test_dir.join("none.py");
-        let file_path_str = file_path.to_slash().unwrap().to_string();
+        let file_path_str = drop_leading_slash(&file_path.to_slash().unwrap()).to_string();
 
         // Do this is a thread, since the request generates a message that
         // requires a response in order to complete.
@@ -1128,7 +1129,7 @@ mod test {
             assert_eq!(
                 minreq::get(format!(
                     "http://localhost:8080/vsc/fs/{connection_id}/{}",
-                    file_path_thread.to_slash().unwrap()
+                    drop_leading_slash(&file_path_thread.to_slash().unwrap())
                 ))
                 .send()
                 .unwrap()