Start try extension attempt

Author: kevinkassimo

src/deno_dir.rs

@@ -133,18 +133,55 @@ impl DenoDir {
     self: &DenoDir,
     module_name: &str,
     filename: &str,
-  ) -> DenoResult<String> {
+  ) -> DenoResult<CodeFetchOutput> {
     if is_remote(module_name) {
-      self.fetch_remote_source(module_name, filename)
+      let try_extension = |ext| {
+        let module_name = format!("{}{}", module_name, ext);
+        let filename = format!("{}{}", filename, ext);
+        let source_code = self.fetch_remote_source(&module_name, &filename)?;
+        return Ok(CodeFetchOutput {
+          module_name: module_name.to_string(),
+          filename: filename.to_string(),
+          source_code,
+          maybe_output_code: None,
+        });
+      };
+      if module_name.ends_with(".ts") || module_name.ends_with(".js") {
+        return try_extension("");
+      }
+      println!("Trying {}.ts...", module_name);
+      if let Ok(v) = try_extension(".ts") {
+        return Ok(v);
+      }
+      println!("Trying {}.js...", module_name);
+      try_extension(".js")
     } else if module_name.starts_with(ASSET_PREFIX) {
       panic!("Asset resolution should be done in JS, not Rust.");
     } else {
       assert_eq!(
         module_name, filename,
         "if a module isn't remote, it should have the same filename"
       );
-      let src = fs::read_to_string(Path::new(filename))?;
-      Ok(src)
+      let try_extension = |ext| {
+        let module_name = format!("{}{}", module_name, ext);
+        let filename = format!("{}{}", filename, ext);
+        let source_code = fs::read_to_string(Path::new(&filename))?;
+        return Ok(CodeFetchOutput {
+          module_name: module_name.to_string(),
+          filename: filename.to_string(),
+          source_code,
+          maybe_output_code: None,
+        });
+      };
+      if module_name.ends_with(".ts") || module_name.ends_with(".js") {
+        return try_extension("");
+      }
+      println!("Trying {}.ts...", module_name);
+      if let Ok(v) = try_extension(".ts") {
+        return Ok(v);
+      }
+      println!("Trying {}.js...", module_name);
+      try_extension(".js")
     }
   }
 
@@ -161,16 +198,7 @@ impl DenoDir {
     let (module_name, filename) =
       self.resolve_module(module_specifier, containing_file)?;
 
-    let result = self
-      .get_source_code(module_name.as_str(), filename.as_str())
-      .and_then(|source_code| {
-        Ok(CodeFetchOutput {
-          module_name,
-          filename,
-          source_code,
-          maybe_output_code: None,
-        })
-      });
+    let result = self.get_source_code(module_name.as_str(), filename.as_str());
     let out = match result {
       Err(err) => {
         if err.kind() == ErrorKind::NotFound {

src/http.rs

@@ -3,13 +3,14 @@
 use errors::DenoResult;
 use tokio_util;
 
-use futures::Future;
+// use futures::Future;
 use futures::Stream;
 use hyper;
 use hyper::client::Client;
 use hyper::client::HttpConnector;
 use hyper::Uri;
 use hyper_rustls;
+use std::io;
 
 type Connector = hyper_rustls::HttpsConnector<HttpConnector>;
 
@@ -31,10 +32,15 @@ pub fn get_client() -> Client<Connector, hyper::Body> {
 pub fn fetch_sync_string(module_name: &str) -> DenoResult<String> {
   let url = module_name.parse::<Uri>().unwrap();
   let client = get_client();
-  let future = client
-    .get(url)
-    .and_then(|response| response.into_body().concat2());
-  let body = tokio_util::block_on(future)?;
+  let get_future = client.get(url);
+  let response = tokio_util::block_on(get_future)?;
+  if !response.status().is_success() {
+    Err(io::Error::new(
+      io::ErrorKind::NotFound,
+      format!("cannot load from '{}'", module_name),
+    ))?;
+  }
+  let body = tokio_util::block_on(response.into_body().concat2())?;
   Ok(String::from_utf8(body.to_vec()).unwrap())
 }