123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502
use std::env::current_dir;use std::error::Error;use std::fmt;use std::path::PathBuf;use url::ParseError;use url::Url;
/// Error indicating the reason resolving a module specifier failed.#[derive(Clone, Debug, Eq, PartialEq)]pub enum ModuleResolutionError {  InvalidUrl(ParseError),  InvalidBaseUrl(ParseError),  InvalidPath(PathBuf),  ImportPrefixMissing(String, Option<String>),}use ModuleResolutionError::*;
impl Error for ModuleResolutionError {  fn source(&self) -> Option<&(dyn Error + 'static)> {    match self {      InvalidUrl(ref err) | InvalidBaseUrl(ref err) => Some(err),      _ => None,    }  }}
impl fmt::Display for ModuleResolutionError {  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {    match self {      InvalidUrl(ref err) => write!(f, "invalid URL: {}", err),      InvalidBaseUrl(ref err) => {        write!(f, "invalid base URL for relative import: {}", err)      }      InvalidPath(ref path) => write!(f, "invalid module path: {:?}", path),      ImportPrefixMissing(ref specifier, ref maybe_referrer) => {        let msg = format!(          "relative import path \"{}\" not prefixed with / or ./ or ../",          specifier        );        let msg = if let Some(referrer) = maybe_referrer {          format!("{} Imported from \"{}\"", msg, referrer)        } else {          msg        };
        write!(f, "{}", msg)      }    }  }}
#[derive(Debug, Clone, Eq, Hash, PartialEq)]/// Resolved module specifierpub struct ModuleSpecifier(Url);
impl ModuleSpecifier {  fn is_dummy_specifier(specifier: &str) -> bool {    specifier == "<unknown>"  }
  pub fn as_url(&self) -> &Url {    &self.0  }
  pub fn as_str(&self) -> &str {    self.0.as_str()  }
  /// Resolves module using this algorithm:  /// https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-module-specifier  pub fn resolve_import(    specifier: &str,    base: &str,  ) -> Result<ModuleSpecifier, ModuleResolutionError> {    let url = match Url::parse(specifier) {      // 1. Apply the URL parser to specifier.      //    If the result is not failure, return he result.      Ok(url) => url,
      // 2. If specifier does not start with the character U+002F SOLIDUS (/),      //    the two-character sequence U+002E FULL STOP, U+002F SOLIDUS (./),      //    or the three-character sequence U+002E FULL STOP, U+002E FULL STOP,      //    U+002F SOLIDUS (../), return failure.      Err(ParseError::RelativeUrlWithoutBase)        if !(specifier.starts_with('/')          || specifier.starts_with("./")          || specifier.starts_with("../")) =>      {        let maybe_referrer = if base.is_empty() {          None        } else {          Some(base.to_string())        };        return Err(ImportPrefixMissing(specifier.to_string(), maybe_referrer));      }
      // 3. Return the result of applying the URL parser to specifier with base      //    URL as the base URL.      Err(ParseError::RelativeUrlWithoutBase) => {        let base = if ModuleSpecifier::is_dummy_specifier(base) {          // Handle <unknown> case, happening under e.g. repl.          // Use CWD for such case.
          // Forcefully join base to current dir.          // Otherwise, later joining in Url would be interpreted in          // the parent directory (appending trailing slash does not work)          let path = current_dir().unwrap().join(base);          Url::from_file_path(path).unwrap()        } else {          Url::parse(base).map_err(InvalidBaseUrl)?        };        base.join(&specifier).map_err(InvalidUrl)?      }
      // If parsing the specifier as a URL failed for a different reason than      // it being relative, always return the original error. We don't want to      // return `ImportPrefixMissing` or `InvalidBaseUrl` if the real      // problem lies somewhere else.      Err(err) => return Err(InvalidUrl(err)),    };
    Ok(ModuleSpecifier(url))  }
  /// Converts a string representing an absolute URL into a ModuleSpecifier.  pub fn resolve_url(    url_str: &str,  ) -> Result<ModuleSpecifier, ModuleResolutionError> {    Url::parse(url_str)      .map(ModuleSpecifier)      .map_err(ModuleResolutionError::InvalidUrl)  }
  /// Takes a string representing either an absolute URL or a file path,  /// as it may be passed to deno as a command line argument.  /// The string is interpreted as a URL if it starts with a valid URI scheme,  /// e.g. 'http:' or 'file:' or 'git+ssh:'. If not, it's interpreted as a  /// file path; if it is a relative path it's resolved relative to the current  /// working directory.  pub fn resolve_url_or_path(    specifier: &str,  ) -> Result<ModuleSpecifier, ModuleResolutionError> {    if Self::specifier_has_uri_scheme(specifier) {      Self::resolve_url(specifier)    } else {      Self::resolve_path(specifier)    }  }
  /// Converts a string representing a relative or absolute path into a  /// ModuleSpecifier. A relative path is considered relative to the current  /// working directory.  fn resolve_path(    path_str: &str,  ) -> Result<ModuleSpecifier, ModuleResolutionError> {    let path = current_dir().unwrap().join(path_str);    Url::from_file_path(path.clone())      .map(ModuleSpecifier)      .map_err(|()| ModuleResolutionError::InvalidPath(path))  }
  /// Returns true if the input string starts with a sequence of characters  /// that could be a valid URI scheme, like 'https:', 'git+ssh:' or 'data:'.  ///  /// According to RFC 3986 (https://tools.ietf.org/html/rfc3986#section-3.1),  /// a valid scheme has the following format:  ///   scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )  ///  /// We additionally require the scheme to be at least 2 characters long,  /// because otherwise a windows path like c:/foo would be treated as a URL,  /// while no schemes with a one-letter name actually exist.  fn specifier_has_uri_scheme(specifier: &str) -> bool {    let mut chars = specifier.chars();    let mut len = 0usize;    // THe first character must be a letter.    match chars.next() {      Some(c) if c.is_ascii_alphabetic() => len += 1,      _ => return false,    }    // Second and following characters must be either a letter, number,    // plus sign, minus sign, or dot.    loop {      match chars.next() {        Some(c) if c.is_ascii_alphanumeric() || "+-.".contains(c) => len += 1,        Some(':') if len >= 2 => return true,        _ => return false,      }    }  }}
impl fmt::Display for ModuleSpecifier {  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {    self.0.fmt(f)  }}
impl From<Url> for ModuleSpecifier {  fn from(url: Url) -> Self {    ModuleSpecifier(url)  }}
impl PartialEq<String> for ModuleSpecifier {  fn eq(&self, other: &String) -> bool {    &self.to_string() == other  }}
#[cfg(test)]mod tests {  use super::*;
  #[test]  fn test_resolve_import() {    let tests = vec![      (        "./005_more_imports.ts",        "http://deno.land/core/tests/006_url_imports.ts",        "http://deno.land/core/tests/005_more_imports.ts",      ),      (        "../005_more_imports.ts",        "http://deno.land/core/tests/006_url_imports.ts",        "http://deno.land/core/005_more_imports.ts",      ),      (        "http://deno.land/core/tests/005_more_imports.ts",        "http://deno.land/core/tests/006_url_imports.ts",        "http://deno.land/core/tests/005_more_imports.ts",      ),      (        "data:text/javascript,export default 'grapes';",        "http://deno.land/core/tests/006_url_imports.ts",        "data:text/javascript,export default 'grapes';",      ),      (        "blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f",        "http://deno.land/core/tests/006_url_imports.ts",        "blob:https://whatwg.org/d0360e2f-caee-469f-9a2f-87d5b0456f6f",      ),      (        "javascript:export default 'artichokes';",        "http://deno.land/core/tests/006_url_imports.ts",        "javascript:export default 'artichokes';",      ),      (        "data:text/plain,export default 'kale';",        "http://deno.land/core/tests/006_url_imports.ts",        "data:text/plain,export default 'kale';",      ),      (        "/dev/core/tests/005_more_imports.ts",        "file:///home/yeti",        "file:///dev/core/tests/005_more_imports.ts",      ),      (        "//zombo.com/1999.ts",        "https://cherry.dev/its/a/thing",        "https://zombo.com/1999.ts",      ),      (        "http://deno.land/this/url/is/valid",        "base is clearly not a valid url",        "http://deno.land/this/url/is/valid",      ),      (        "//server/some/dir/file",        "file:///home/yeti/deno",        "file://server/some/dir/file",      ),      // This test is disabled because the url crate does not follow the spec,      // dropping the server part from the final result.      // (      //   "/another/path/at/the/same/server",      //   "file://server/some/dir/file",      //   "file://server/another/path/at/the/same/server",      // ),    ];
    for (specifier, base, expected_url) in tests {      let url = ModuleSpecifier::resolve_import(specifier, base)        .unwrap()        .to_string();      assert_eq!(url, expected_url);    }  }
  #[test]  fn test_resolve_import_error() {    use url::ParseError::*;    use ModuleResolutionError::*;
    let tests = vec![      (        "005_more_imports.ts",        "http://deno.land/core/tests/006_url_imports.ts",        ImportPrefixMissing(          "005_more_imports.ts".to_string(),          Some("http://deno.land/core/tests/006_url_imports.ts".to_string()),        ),      ),      (        ".tomato",        "http://deno.land/core/tests/006_url_imports.ts",        ImportPrefixMissing(          ".tomato".to_string(),          Some("http://deno.land/core/tests/006_url_imports.ts".to_string()),        ),      ),      (        "..zucchini.mjs",        "http://deno.land/core/tests/006_url_imports.ts",        ImportPrefixMissing(          "..zucchini.mjs".to_string(),          Some("http://deno.land/core/tests/006_url_imports.ts".to_string()),        ),      ),      (        r".\yam.es",        "http://deno.land/core/tests/006_url_imports.ts",        ImportPrefixMissing(          r".\yam.es".to_string(),          Some("http://deno.land/core/tests/006_url_imports.ts".to_string()),        ),      ),      (        r"..\yam.es",        "http://deno.land/core/tests/006_url_imports.ts",        ImportPrefixMissing(          r"..\yam.es".to_string(),          Some("http://deno.land/core/tests/006_url_imports.ts".to_string()),        ),      ),      (        "https://eggplant:b/c",        "http://deno.land/core/tests/006_url_imports.ts",        InvalidUrl(InvalidPort),      ),      (        "https://eggplant@/c",        "http://deno.land/core/tests/006_url_imports.ts",        InvalidUrl(EmptyHost),      ),      (        "./foo.ts",        "/relative/base/url",        InvalidBaseUrl(RelativeUrlWithoutBase),      ),    ];
    for (specifier, base, expected_err) in tests {      let err = ModuleSpecifier::resolve_import(specifier, base).unwrap_err();      assert_eq!(err, expected_err);    }  }
  #[test]  fn test_resolve_url_or_path() {    // Absolute URL.    let mut tests: Vec<(&str, String)> = vec![      (        "http://deno.land/core/tests/006_url_imports.ts",        "http://deno.land/core/tests/006_url_imports.ts".to_string(),      ),      (        "https://deno.land/core/tests/006_url_imports.ts",        "https://deno.land/core/tests/006_url_imports.ts".to_string(),      ),    ];
    // The local path tests assume that the cwd is the deno repo root.    let cwd = current_dir().unwrap();    let cwd_str = cwd.to_str().unwrap();
    if cfg!(target_os = "windows") {      // Absolute local path.      let expected_url = "file:///C:/deno/tests/006_url_imports.ts";      tests.extend(vec![        (          r"C:/deno/tests/006_url_imports.ts",          expected_url.to_string(),        ),        (          r"C:\deno\tests\006_url_imports.ts",          expected_url.to_string(),        ),        (          r"\\?\C:\deno\tests\006_url_imports.ts",          expected_url.to_string(),        ),        // Not supported: `Url::from_file_path()` fails.        // (r"\\.\C:\deno\tests\006_url_imports.ts", expected_url.to_string()),        // Not supported: `Url::from_file_path()` performs the wrong conversion.        // (r"//./C:/deno/tests/006_url_imports.ts", expected_url.to_string()),      ]);
      // Rooted local path without drive letter.      let expected_url = format!(        "file:///{}:/deno/tests/006_url_imports.ts",        cwd_str.get(..1).unwrap(),      );      tests.extend(vec![        (r"/deno/tests/006_url_imports.ts", expected_url.to_string()),        (r"\deno\tests\006_url_imports.ts", expected_url),      ]);
      // Relative local path.      let expected_url = format!(        "file:///{}/tests/006_url_imports.ts",        cwd_str.replace("\\", "/")      );      tests.extend(vec![        (r"tests/006_url_imports.ts", expected_url.to_string()),        (r"tests\006_url_imports.ts", expected_url.to_string()),        (r"./tests/006_url_imports.ts", (*expected_url).to_string()),        (r".\tests\006_url_imports.ts", (*expected_url).to_string()),      ]);
      // UNC network path.      let expected_url = "file://server/share/deno/cool";      tests.extend(vec![        (r"\\server\share\deno\cool", expected_url.to_string()),        (r"\\server/share/deno/cool", expected_url.to_string()),        // Not supported: `Url::from_file_path()` performs the wrong conversion.        // (r"//server/share/deno/cool", expected_url.to_string()),      ]);    } else {      // Absolute local path.      let expected_url = "file:///deno/tests/006_url_imports.ts";      tests.extend(vec![        ("/deno/tests/006_url_imports.ts", expected_url.to_string()),        ("//deno/tests/006_url_imports.ts", expected_url.to_string()),      ]);
      // Relative local path.      let expected_url = format!("file://{}/tests/006_url_imports.ts", cwd_str);      tests.extend(vec![        ("tests/006_url_imports.ts", expected_url.to_string()),        ("./tests/006_url_imports.ts", expected_url),      ]);    }
    for (specifier, expected_url) in tests {      let url = ModuleSpecifier::resolve_url_or_path(specifier)        .unwrap()        .to_string();      assert_eq!(url, expected_url);    }  }
  #[test]  fn test_resolve_url_or_path_error() {    use url::ParseError::*;    use ModuleResolutionError::*;
    let mut tests = vec![      ("https://eggplant:b/c", InvalidUrl(InvalidPort)),      ("https://:8080/a/b/c", InvalidUrl(EmptyHost)),    ];    if cfg!(target_os = "windows") {      let p = r"\\.\c:/stuff/deno/script.ts";      tests.push((p, InvalidPath(PathBuf::from(p))));    }
    for (specifier, expected_err) in tests {      let err = ModuleSpecifier::resolve_url_or_path(specifier).unwrap_err();      assert_eq!(err, expected_err);    }  }
  #[test]  fn test_specifier_has_uri_scheme() {    let tests = vec![      ("http://foo.bar/etc", true),      ("HTTP://foo.bar/etc", true),      ("http:ftp:", true),      ("http:", true),      ("hTtP:", true),      ("ftp:", true),      ("mailto:spam@please.me", true),      ("git+ssh://git@github.com/denoland/deno", true),      ("blob:https://whatwg.org/mumbojumbo", true),      ("abc.123+DEF-ghi:", true),      ("abc.123+def-ghi:@", true),      ("", false),      (":not", false),      ("http", false),      ("c:dir", false),      ("X:", false),      ("./http://not", false),      ("1abc://kinda/but/no", false),      ("schluẞ://no/more", false),    ];
    for (specifier, expected) in tests {      let result = ModuleSpecifier::specifier_has_uri_scheme(specifier);      assert_eq!(result, expected);    }  }}