Feature/registry alias

docs/src/guide/local-dependencies.md

@@ -64,7 +64,7 @@ mono
 Where `mono/mono-api/Proto.toml` has this content:
 
 ```
-edition = "0.9"
+edition = "0.10"
 
 [package]
 type = "api"
@@ -75,7 +75,7 @@ version = "0.1.0"
 And `mono/mono-server/Proto.toml` has this content:
 
 ```
-edition = "0.9"
+edition = "0.10"
 
 [dependencies]
 mono-api = { path = "../api" }

src/cli.rs

@@ -229,7 +229,7 @@ pub async fn run(args: &[String]) -> miette::Result<()> {
             .unwrap_or_else(|| name.to_string())
     };
 
-    let cert_validation_policy = if cli.disable_cert_validation {
+    let policy = if cli.disable_cert_validation {
         CertValidationPolicy::NoValidation
     } else {
         CertValidationPolicy::Validate
@@ -255,7 +255,7 @@ pub async fn run(args: &[String]) -> miette::Result<()> {
         }
         Command::Login { registry, token } => {
             let registry = config.parse_registry_arg(&registry)?;
-            command::login(&registry, token, cert_validation_policy, &config)
+            command::login(&registry, token, policy, &config)
                 .await
                 .wrap_err(miette!("failed to login to `{registry}`"))
         }
@@ -270,7 +270,7 @@ pub async fn run(args: &[String]) -> miette::Result<()> {
             dependency,
         } => {
             let registry = config.parse_registry_arg(&registry)?;
-            command::add(&registry, &dependency, &config, cert_validation_policy)
+            command::add(&registry, &dependency, &config, policy)
                 .await
                 .wrap_err(miette!(
                     "failed to add `{dependency}` from `{registry}` to `{MANIFEST_FILE}`"
@@ -307,7 +307,7 @@ pub async fn run(args: &[String]) -> miette::Result<()> {
                 dry_run,
                 set_version,
                 &config,
-                cert_validation_policy,
+                policy,
             )
             .await
             .wrap_err(miette!(
@@ -346,14 +346,9 @@ pub async fn run(args: &[String]) -> miette::Result<()> {
                 InstallMode::All
             };
 
-            command::install(
-                install_mode,
-                &generation_options,
-                &config,
-                cert_validation_policy,
-            )
-            .await
-            .wrap_err(miette!("failed to install dependencies for `{package}`"))
+            command::install(install_mode, &generation_options, &config, policy)
+                .await
+                .wrap_err(miette!("failed to install dependencies for `{package}`"))
         }
         Command::Uninstall => command::uninstall()
             .await

src/command.rs

@@ -20,7 +20,7 @@ use crate::{
     lock::{LockedPackage, Lockfile},
     manifest::{Dependency, Manifest, PackageManifest, MANIFEST_FILE},
     package::{Package, PackageName, PackageStore, PackageType},
-    registry::{Artifactory, CertValidationPolicy, RegistryUri},
+    registry::{Artifactory, CertValidationPolicy, RegistryRef, RegistryUri},
     resolver::{DependencyGraph, DependencyGraphBuilder, ResolvedDependency},
 };
 
@@ -180,10 +180,10 @@ impl FromStr for DependencyLocator {
 /// * `registry` - The registry URI
 /// * `dependency` - The dependency to add (e.g. `my-repo/my-package@1.0`)
 pub async fn add(
-    registry: &RegistryUri,
+    registry: &RegistryRef,
     dependency: &str,
     config: &Config,
-    cert_validation_policy: CertValidationPolicy,
+    policy: CertValidationPolicy,
 ) -> miette::Result<()> {
     let mut manifest = Manifest::read(config).await?;
     let registry = registry.with_alias_resolved(Some(config))?;
@@ -199,11 +199,7 @@ pub async fn add(
         DependencyLocatorVersion::Latest => {
             // query artifactory to retrieve the actual latest version
             let credentials = Credentials::load().await?;
-            let artifactory = Artifactory::new(
-                registry.clone().try_into()?,
-                &credentials,
-                cert_validation_policy,
-            )?;
+            let artifactory = Artifactory::new(registry.clone().try_into()?, &credentials, policy)?;
 
             let latest_version = artifactory
                 .get_latest_version(repository.clone(), package.clone())
@@ -301,13 +297,13 @@ pub async fn package(
 
 /// Publishes the api package to the registry
 pub async fn publish(
-    registry: &RegistryUri,
+    registry: &RegistryRef,
     repository: String,
     #[cfg(feature = "git")] allow_dirty: bool,
     dry_run: bool,
     version: Option<Version>,
     config: &Config,
-    cert_validation_policy: CertValidationPolicy,
+    policy: CertValidationPolicy,
 ) -> miette::Result<()> {
     let registry = registry.with_alias_resolved(Some(config))?;
 
@@ -365,7 +361,7 @@ pub async fn publish(
 
     let package = prepare_package(version, config).await?;
     let credentials = Credentials::load().await?;
-    let artifactory = Artifactory::new(registry.try_into()?, &credentials, cert_validation_policy)?;
+    let artifactory = Artifactory::new(registry.try_into()?, &credentials, policy)?;
 
     if dry_run {
         tracing::warn!(":: aborting upload due to dry run");
@@ -409,7 +405,7 @@ pub async fn install(
     mode: InstallMode,
     generation: &[GenerationOption],
     config: &Config,
-    cert_validation_policy: CertValidationPolicy,
+    policy: CertValidationPolicy,
 ) -> miette::Result<()> {
     let manifest = Manifest::read(config).await?;
     let lockfile = Lockfile::read_or_default().await?;
@@ -427,17 +423,11 @@ pub async fn install(
         }
     }
 
-    let dependency_graph = DependencyGraphBuilder::new(
-        &manifest,
-        &lockfile,
-        &credentials,
-        &cache,
-        config,
-        cert_validation_policy,
-    )
-    .build()
-    .await
-    .wrap_err(miette!("dependency resolution failed"))?;
+    let dependency_graph =
+        DependencyGraphBuilder::new(&manifest, &lockfile, &credentials, &cache, config, policy)
+            .build()
+            .await
+            .wrap_err(miette!("dependency resolution failed"))?;
 
     let mut locked = Vec::new();
 
@@ -606,13 +596,13 @@ pub async fn lint(config: &Config) -> miette::Result<()> {
 ///  * `registry` - The registry to log in to
 ///  * `token` - An optional token to use, if not provided, the user will be prompted for one
 pub async fn login(
-    registry: &RegistryUri,
+    registry: &RegistryRef,
     token: Option<String>,
-    cert_validation_policy: CertValidationPolicy,
+    policy: CertValidationPolicy,
     config: &Config,
 ) -> miette::Result<()> {
     let mut credentials = Credentials::load().await?;
-    let registry: url::Url = registry.with_alias_resolved(Some(config))?.try_into()?;
+    let registry: RegistryUri = registry.with_alias_resolved(Some(config))?.try_into()?;
 
     let token = match token {
         Some(token) => token,
@@ -635,7 +625,7 @@ pub async fn login(
     credentials.registry_tokens.insert(registry.clone(), token);
 
     if env::var(BUFFRS_TESTSUITE_VAR).is_err() {
-        Artifactory::new(registry, &credentials, cert_validation_policy)?
+        Artifactory::new(registry, &credentials, policy)?
             .ping()
             .await
             .wrap_err(miette!("failed to validate token"))?;
@@ -645,8 +635,8 @@ pub async fn login(
 }
 
 /// Logs you out from a registry
-pub async fn logout(registry: &RegistryUri, config: &Config) -> miette::Result<()> {
-    let registry: url::Url = registry.with_alias_resolved(Some(config))?.try_into()?;
+pub async fn logout(registry: &RegistryRef, config: &Config) -> miette::Result<()> {
+    let registry: RegistryUri = registry.with_alias_resolved(Some(config))?.try_into()?;
     let mut credentials = Credentials::load().await?;
     credentials.registry_tokens.remove(&registry);
     credentials.write().await

src/config.rs

@@ -20,7 +20,7 @@ use std::{
 
 use crate::{
     manifest::{Edition, CANARY_EDITION},
-    registry::{sanity_check_url, RegistryUri},
+    registry::{RegistryRef, RegistryUri},
 };
 
 /// Location of the configuration file
@@ -61,7 +61,7 @@ pub struct Config {
     default_registry: Option<String>,
 
     /// List of registries
-    registries: HashMap<String, url::Url>,
+    registries: HashMap<String, RegistryUri>,
 
     /// Default arguments for commands
     command_defaults: HashMap<String, Vec<String>>,
@@ -95,11 +95,11 @@ impl Config {
     /// - <alias> -> alias://<alias>
     /// - <uri> -> <uri>
     /// - None -> alias://<default>
-    pub fn parse_registry_arg(&self, registry: &Option<String>) -> miette::Result<RegistryUri> {
+    pub fn parse_registry_arg(&self, registry: &Option<String>) -> miette::Result<RegistryRef> {
         match registry {
-            Some(registry) => RegistryUri::from_str(registry),
+            Some(registry) => RegistryRef::from_str(registry),
             None => match &self.default_registry {
-                Some(default_registry) => RegistryUri::from_str(default_registry),
+                Some(default_registry) => RegistryRef::from_str(default_registry),
                 None => bail!("no registry provided and no default registry found"),
             },
         }
@@ -112,7 +112,7 @@ impl Config {
     ///
     /// # Returns
     /// The registry URI
-    pub fn lookup_registry(&self, name: &str) -> miette::Result<url::Url> {
+    pub fn lookup_registry(&self, name: &str) -> miette::Result<RegistryUri> {
         self.registries.get(name).cloned().ok_or_else(|| {
             miette!(
                 "registry '{}' not found in {}",
@@ -221,7 +221,7 @@ impl Config {
 
     fn get_default_registry(
         config: &toml::Value,
-        registries: &HashMap<String, url::Url>,
+        registries: &HashMap<String, RegistryUri>,
     ) -> miette::Result<Option<String>> {
         let default_registry = config
             .get("registry")
@@ -238,10 +238,18 @@ impl Config {
         Ok(default_registry)
     }
 
+    /// Load registries from the [registries] section of the config file
+    ///
+    /// # Arguments
+    /// * `config` - The parsed TOML configuration
+    /// * `config_path` - Path to the configuration file (for error messages)
+    ///
+    /// # Returns
+    /// A map of registry names to URIs
     fn get_registries(
         config: &toml::Value,
         config_path: &Path,
-    ) -> miette::Result<HashMap<String, url::Url>> {
+    ) -> miette::Result<HashMap<String, RegistryUri>> {
         let registries = config
             .get("registries")
             .and_then(|registries| registries.as_table())
@@ -253,12 +261,11 @@ impl Config {
                             .as_str()
                             .ok_or_else(|| miette!("registry URI must be a string"))
                             .wrap_err(miette!("invalid URI for registry '{}'", name))
-                            .wrap_err(miette!("in config file: {}", config_path.display()))?;
-                        let uri = url::Url::from_str(uri).into_diagnostic()?;
-                        sanity_check_url(&uri)?;
+                            .wrap_err(miette!("in config file: {}", config_path.display()))?
+                            .parse()?;
                         Ok((name.to_owned(), uri))
                     })
-                    .collect::<miette::Result<HashMap<String, url::Url>>>()
+                    .collect::<miette::Result<HashMap<String, RegistryUri>>>()
             })
             .unwrap_or_else(|| Ok(HashMap::new()))
             .wrap_err(miette!(

src/credentials.rs

@@ -19,6 +19,7 @@ use tokio::fs;
 
 use crate::{
     errors::{DeserializationError, FileExistsError, ReadError, SerializationError, WriteError},
+    registry::RegistryUri,
     ManagedFile,
 };
 
@@ -31,7 +32,7 @@ pub const CREDENTIALS_FILE: &str = "credentials.toml";
 #[derive(Debug, Default, Clone)]
 pub struct Credentials {
     /// A mapping from registry URIs to their corresponding tokens
-    pub registry_tokens: HashMap<url::Url, String>,
+    pub registry_tokens: HashMap<RegistryUri, String>,
 }
 
 impl Credentials {
@@ -107,7 +108,7 @@ struct RawCredentialCollection {
 /// Credentials for a single registry. Serialization type.
 #[derive(Serialize, Deserialize)]
 struct RawRegistryCredentials {
-    uri: url::Url,
+    uri: RegistryUri,
     token: String,
 }
 

src/integration/buf_yaml.rs

@@ -277,7 +277,8 @@ mod tests {
         // serialize to file
         let serialized = buf_yaml.to_string().unwrap();
 
-        let writer = std::fs::File::create("buf.yaml").unwrap();
+        let yaml_path = tmp_dir.join(BUF_YAML_FILE);
+        let writer = std::fs::File::create(yaml_path).unwrap();
         let mut writer = std::io::BufWriter::new(writer);
         writer.write_all(serialized.as_bytes()).unwrap();
     }

src/lock.rs

@@ -24,7 +24,7 @@ use url::Url;
 use crate::{
     errors::{DeserializationError, FileExistsError, FileNotFound, SerializationError, WriteError},
     package::{Package, PackageName},
-    registry::RegistryUri,
+    registry::{RegistryRef, RegistryUri},
     ManagedFile,
 };
 
@@ -44,8 +44,8 @@ pub struct LockedPackage {
     /// The cryptographic digest of the package contents
     pub digest: Digest,
     /// The URI of the registry that contains the package
-    #[serde(serialize_with = "RegistryUri::serialize_resolved")]
-    pub registry: RegistryUri,
+    #[serde(serialize_with = "RegistryRef::serialize_resolved")]
+    pub registry: RegistryRef,
     /// The identifier of the repository where the package was published
     pub repository: String,
     /// The exact version of the package
@@ -62,7 +62,7 @@ impl LockedPackage {
     /// Captures the source, version and checksum of a Package for use in reproducible installs
     pub fn lock(
         package: &Package,
-        registry: RegistryUri,
+        registry: RegistryRef,
         repository: String,
         dependants: usize,
     ) -> Self {
@@ -250,13 +250,14 @@ impl FileRequirement {
 
     /// Construct new file requirement.
     pub fn new(
-        url: &RegistryUri,
+        url: &RegistryRef,
         repository: &String,
         name: &PackageName,
         version: &Version,
         digest: &Digest,
     ) -> miette::Result<Self> {
-        let mut url: url::Url = url.try_into()?;
+        let url: RegistryUri = url.try_into()?;
+        let mut url: url::Url = url.into();
 
         let new_path = format!(
             "{}/{}/{}/{}-{}.tgz",