pesde-pkg/pesde
1
1
Fork 0
mirror of https://github.com/pesde-pkg/pesde.git synced 2025-04-05 11:20:55 +01:00
Code Issues Projects Releases Packages Wiki Activity

refactor: make specifier index not an option

Browse source 
Instead, we use the `default` serde attribute
to deserialize the index as `DEFAULT_INDEX_NAME`
if it is not present. This removes a lot of
redundancy around the codebase about getting
the index name.
This commit is contained in:
daimond113 2025-02-12 17:41:49 +01:00
parent b384dbe6a0
commit 04aaa40c69
No known key found for this signature in database
GPG key ID: 640DC95EC1190354
13 changed files with 284 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
registry/src/endpoints/publish_version.rs
View file

@ -289,32 +289,26 @@ pub async fn publish_package(
match specifier { match specifier {
DependencySpecifiers::Pesde(specifier) => { DependencySpecifiers::Pesde(specifier) => {
if specifier let allowed = match gix::Url::try_from(&*specifier.index) {
.index Ok(url) => config
.as_deref() .other_registries_allowed
.filter(|index| match gix::Url::try_from(*index) { .is_allowed_or_same(source.repo_url().clone(), url),
Ok(url) => config Err(_) => false,
.other_registries_allowed };
.is_allowed_or_same(source.repo_url().clone(), url),
Err(_) => false, if !allowed {
})
.is_none()
{
return Err(RegistryError::InvalidArchive(format!( return Err(RegistryError::InvalidArchive(format!(
"invalid index in pesde dependency {specifier}" "invalid index in pesde dependency {specifier}"
))); )));
} }
} }
DependencySpecifiers::Wally(specifier) => { DependencySpecifiers::Wally(specifier) => {
if specifier let allowed = match gix::Url::try_from(&*specifier.index) {
.index Ok(url) => config.wally_allowed.is_allowed(url),
.as_deref() Err(_) => false,
.filter(|index| match gix::Url::try_from(*index) { };
Ok(url) => config.wally_allowed.is_allowed(url),
Err(_) => false, if !allowed {
})
.is_none()
{
return Err(RegistryError::InvalidArchive(format!( return Err(RegistryError::InvalidArchive(format!(
"invalid index in wally dependency {specifier}" "invalid index in wally dependency {specifier}"
))); )));

12
src/cli/commands/add.rs
View file

@ -77,7 +77,7 @@ impl AddCommand {
let specifier = DependencySpecifiers::Pesde(PesdeDependencySpecifier { let specifier = DependencySpecifiers::Pesde(PesdeDependencySpecifier {
name: name.clone(), name: name.clone(),
version: version.clone().unwrap_or(VersionReq::STAR), version: version.clone().unwrap_or(VersionReq::STAR),
index: self.index, index: self.index.unwrap_or_else(|| DEFAULT_INDEX_NAME.to_string()),
target: self.target, target: self.target,
}); });
@ -102,7 +102,7 @@ impl AddCommand {
pesde::source::wally::specifier::WallyDependencySpecifier { pesde::source::wally::specifier::WallyDependencySpecifier {
name: name.clone(), name: name.clone(),
version: version.clone().unwrap_or(VersionReq::STAR), version: version.clone().unwrap_or(VersionReq::STAR),
index: self.index, index: self.index.unwrap_or_else(|| DEFAULT_INDEX_NAME.to_string()),
}, },
); );
@ -210,8 +210,8 @@ impl AddCommand {
field["target"] = toml_edit::value(version_id.target().to_string()); field["target"] = toml_edit::value(version_id.target().to_string());
} }
if let Some(index) = spec.index.filter(|i| i != DEFAULT_INDEX_NAME) { if spec.index != DEFAULT_INDEX_NAME {
field["index"] = toml_edit::value(index); field["index"] = toml_edit::value(spec.index);
} }
println!( println!(
@ -228,8 +228,8 @@ impl AddCommand {
field["wally"] = toml_edit::value(name_str); field["wally"] = toml_edit::value(name_str);
field["version"] = toml_edit::value(format!("^{}", version_id.version())); field["version"] = toml_edit::value(format!("^{}", version_id.version()));
if let Some(index) = spec.index.filter(|i| i != DEFAULT_INDEX_NAME) { if spec.index != DEFAULT_INDEX_NAME {
field["index"] = toml_edit::value(index); field["index"] = toml_edit::value(spec.index);
} }
println!( println!(

4
src/cli/commands/execute.rs
View file

@ -21,7 +21,7 @@ use pesde::{
}, },
PackageSources, PackageSources,
}, },
Project, RefreshedSources, Project, RefreshedSources, DEFAULT_INDEX_NAME,
}; };
use semver::VersionReq; use semver::VersionReq;
use std::{ use std::{
@ -86,7 +86,7 @@ impl ExecuteCommand {
let specifier = PesdeDependencySpecifier { let specifier = PesdeDependencySpecifier {
name: self.package.0.clone(), name: self.package.0.clone(),
version: version_req.clone(), version: version_req.clone(),
index: None, index: DEFAULT_INDEX_NAME.into(),
target: None, target: None,
}; };

2
src/cli/commands/init.rs
View file

@ -199,7 +199,7 @@ impl InitCommand {
&PesdeDependencySpecifier { &PesdeDependencySpecifier {
name: scripts_pkg_name.clone(), name: scripts_pkg_name.clone(),
version: VersionReq::STAR, version: VersionReq::STAR,
index: None, index: DEFAULT_INDEX_NAME.into(),
target: None, target: None,
}, },
&ResolveOptions { &ResolveOptions {

50
src/cli/commands/publish.rs
View file

@ -429,37 +429,23 @@ info: otherwise, the file was deemed unnecessary, if you don't understand why, p
{ {
match specifier { match specifier {
DependencySpecifiers::Pesde(specifier) => { DependencySpecifiers::Pesde(specifier) => {
let index_name = specifier specifier.index = manifest
.index .indices
.as_deref() .get(&specifier.index)
.unwrap_or(DEFAULT_INDEX_NAME) .with_context(|| {
format!("index {} not found in indices field", specifier.index)
})?
.to_string(); .to_string();
specifier.index = Some(
manifest
.indices
.get(&index_name)
.with_context(|| {
format!("index {index_name} not found in indices field")
})?
.to_string(),
);
} }
#[cfg(feature = "wally-compat")] #[cfg(feature = "wally-compat")]
DependencySpecifiers::Wally(specifier) => { DependencySpecifiers::Wally(specifier) => {
let index_name = specifier specifier.index = manifest
.index .wally_indices
.as_deref() .get(&specifier.index)
.unwrap_or(DEFAULT_INDEX_NAME) .with_context(|| {
format!("index {} not found in wally_indices field", specifier.index)
})?
.to_string(); .to_string();
specifier.index = Some(
manifest
.wally_indices
.get(&index_name)
.with_context(|| {
format!("index {index_name} not found in wally_indices field")
})?
.to_string(),
);
} }
DependencySpecifiers::Git(_) => {} DependencySpecifiers::Git(_) => {}
DependencySpecifiers::Workspace(spec) => { DependencySpecifiers::Workspace(spec) => {
@ -503,13 +489,11 @@ info: otherwise, the file was deemed unnecessary, if you don't understand why, p
v => VersionReq::parse(&format!("{v}{}", manifest.version)) v => VersionReq::parse(&format!("{v}{}", manifest.version))
.with_context(|| format!("failed to parse version for {v}"))?, .with_context(|| format!("failed to parse version for {v}"))?,
}, },
index: Some( index: manifest
manifest .indices
.indices .get(DEFAULT_INDEX_NAME)
.get(DEFAULT_INDEX_NAME) .context("missing default index in workspace package manifest")?
.context("missing default index in workspace package manifest")? .to_string(),
.to_string(),
),
target: Some(spec.target.unwrap_or(manifest.target.kind())), target: Some(spec.target.unwrap_or(manifest.target.kind())),
}); });
} }

4
src/lib.rs
View file

@ -66,6 +66,10 @@ pub(crate) const LINK_LIB_NO_FILE_FOUND: &str = "____pesde_no_export_file_found"
/// The folder in which scripts are linked /// The folder in which scripts are linked
pub const SCRIPTS_LINK_FOLDER: &str = ".pesde"; pub const SCRIPTS_LINK_FOLDER: &str = ".pesde";
pub(crate) fn default_index_name() -> String {
DEFAULT_INDEX_NAME.into()
}
#[derive(Debug, Default)] #[derive(Debug, Default)]
struct AuthConfigShared { struct AuthConfigShared {
tokens: HashMap<gix::Url, String>, tokens: HashMap<gix::Url, String>,

348
src/resolver.rs
View file

@ -8,7 +8,7 @@ use crate::{
traits::{PackageRef, PackageSource, RefreshOptions, ResolveOptions}, traits::{PackageRef, PackageSource, RefreshOptions, ResolveOptions},
PackageSources, PackageSources,
}, },
Project, RefreshedSources, DEFAULT_INDEX_NAME, Project, RefreshedSources,
}; };
use std::collections::{btree_map::Entry, HashMap, VecDeque}; use std::collections::{btree_map::Entry, HashMap, VecDeque};
use tracing::{instrument, Instrument}; use tracing::{instrument, Instrument};
@ -172,178 +172,176 @@ impl Project {
while let Some((specifier, ty, dependant, path, overridden, target)) = queue.pop_front() { while let Some((specifier, ty, dependant, path, overridden, target)) = queue.pop_front() {
async { async {
let alias = path.last().unwrap(); let alias = path.last().unwrap();
let depth = path.len() - 1; let depth = path.len() - 1;
tracing::debug!("resolving {specifier} ({ty:?})"); tracing::debug!("resolving {specifier} ({ty:?})");
let source = match &specifier { let source = match &specifier {
DependencySpecifiers::Pesde(specifier) => { DependencySpecifiers::Pesde(specifier) => {
let index_url = if !is_published_package && (depth == 0 || overridden) { let index_url = if !is_published_package && (depth == 0 || overridden) {
let index_name = specifier.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); manifest
.indices
.get(&specifier.index)
.ok_or(errors::DependencyGraphError::IndexNotFound(
specifier.index.to_string(),
))?
.clone()
} else {
specifier.index
.as_str()
.try_into()
// specifiers in indices store the index url in this field
.unwrap()
};
manifest PackageSources::Pesde(PesdePackageSource::new(index_url))
.indices }
.get(index_name) #[cfg(feature = "wally-compat")]
.ok_or(errors::DependencyGraphError::IndexNotFound( DependencySpecifiers::Wally(specifier) => {
index_name.to_string(), let index_url = if !is_published_package && (depth == 0 || overridden) {
))? manifest
.clone() .wally_indices
} else { .get(&specifier.index)
specifier.index.as_deref().unwrap() .ok_or(errors::DependencyGraphError::WallyIndexNotFound(
.try_into() specifier.index.to_string(),
// specifiers in indices store the index url in this field ))?
.unwrap() .clone()
}; } else {
specifier.index
.as_str()
.try_into()
// specifiers in indices store the index url in this field
.unwrap()
};
PackageSources::Pesde(PesdePackageSource::new(index_url)) PackageSources::Wally(crate::source::wally::WallyPackageSource::new(index_url))
} }
#[cfg(feature = "wally-compat")] DependencySpecifiers::Git(specifier) => PackageSources::Git(
DependencySpecifiers::Wally(specifier) => { crate::source::git::GitPackageSource::new(specifier.repo.clone()),
let index_url = if !is_published_package && (depth == 0 || overridden) { ),
let index_name = specifier.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); DependencySpecifiers::Workspace(_) => {
PackageSources::Workspace(crate::source::workspace::WorkspacePackageSource)
}
DependencySpecifiers::Path(_) => {
PackageSources::Path(crate::source::path::PathPackageSource)
}
};
manifest refreshed_sources.refresh(
.wally_indices &source,
.get(index_name) &refresh_options,
.ok_or(errors::DependencyGraphError::WallyIndexNotFound( )
index_name.to_string(), .await
))? .map_err(|e| Box::new(e.into()))?;
.clone()
} else {
specifier.index.as_deref().unwrap()
.try_into()
// specifiers in indices store the index url in this field
.unwrap()
};
PackageSources::Wally(crate::source::wally::WallyPackageSource::new(index_url)) let (name, resolved) = source
} .resolve(&specifier, &ResolveOptions {
DependencySpecifiers::Git(specifier) => PackageSources::Git( project: self.clone(),
crate::source::git::GitPackageSource::new(specifier.repo.clone()), target,
), refreshed_sources: refreshed_sources.clone(),
DependencySpecifiers::Workspace(_) => { })
PackageSources::Workspace(crate::source::workspace::WorkspacePackageSource) .await
} .map_err(|e| Box::new(e.into()))?;
DependencySpecifiers::Path(_) => {
PackageSources::Path(crate::source::path::PathPackageSource)
}
};
refreshed_sources.refresh( let Some(package_id) = graph
&source, .keys()
&refresh_options, .filter(|id| *id.name() == name && resolved.contains_key(id.version_id()))
) .max()
.await .cloned()
.map_err(|e| Box::new(e.into()))?; .or_else(|| resolved.last_key_value().map(|(ver, _)| PackageId::new(name, ver.clone())))
else {
return Err(Box::new(errors::DependencyGraphError::NoMatchingVersion(
format!("{specifier} ({target})"),
)));
};
let (name, resolved) = source let resolved_ty = if (is_published_package || depth == 0) && ty == DependencyType::Peer
.resolve(&specifier, &ResolveOptions { {
project: self.clone(), DependencyType::Standard
target, } else {
refreshed_sources: refreshed_sources.clone(), ty
}) };
.await
.map_err(|e| Box::new(e.into()))?;
let Some(package_id) = graph if let Some(dependant_id) = dependant {
.keys() graph
.filter(|id| *id.name() == name && resolved.contains_key(id.version_id())) .get_mut(&dependant_id)
.max() .expect("dependant package not found in graph")
.cloned() .dependencies
.or_else(|| resolved.last_key_value().map(|(ver, _)| PackageId::new(name, ver.clone()))) .insert(package_id.clone(), alias.clone());
else { }
return Err(Box::new(errors::DependencyGraphError::NoMatchingVersion(
format!("{specifier} ({target})"),
)));
};
let resolved_ty = if (is_published_package || depth == 0) && ty == DependencyType::Peer let pkg_ref = &resolved[package_id.version_id()];
{
DependencyType::Standard
} else {
ty
};
if let Some(dependant_id) = dependant { if let Some(already_resolved) = graph.get_mut(&package_id) {
graph tracing::debug!("{package_id} already resolved");
.get_mut(&dependant_id)
.expect("dependant package not found in graph")
.dependencies
.insert(package_id.clone(), alias.clone());
}
let pkg_ref = &resolved[package_id.version_id()]; if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) {
tracing::warn!(
if let Some(already_resolved) = graph.get_mut(&package_id) {
tracing::debug!("{package_id} already resolved");
if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) {
tracing::warn!(
"resolved package {package_id} has a different source than previously resolved one, this may cause issues", "resolved package {package_id} has a different source than previously resolved one, this may cause issues",
); );
} }
if already_resolved.resolved_ty == DependencyType::Peer { if already_resolved.resolved_ty == DependencyType::Peer {
already_resolved.resolved_ty = resolved_ty; already_resolved.resolved_ty = resolved_ty;
} }
if ty == DependencyType::Peer && depth == 0 { if ty == DependencyType::Peer && depth == 0 {
already_resolved.is_peer = true; already_resolved.is_peer = true;
} }
if already_resolved.direct.is_none() && depth == 0 { if already_resolved.direct.is_none() && depth == 0 {
already_resolved.direct = Some((alias.clone(), specifier.clone(), ty)); already_resolved.direct = Some((alias.clone(), specifier.clone(), ty));
} }
return Ok(()); return Ok(());
} }
let node = DependencyGraphNode { let node = DependencyGraphNode {
direct: if depth == 0 { direct: if depth == 0 {
Some((alias.clone(), specifier.clone(), ty)) Some((alias.clone(), specifier.clone(), ty))
} else { } else {
None None
}, },
pkg_ref: pkg_ref.clone(), pkg_ref: pkg_ref.clone(),
dependencies: Default::default(), dependencies: Default::default(),
resolved_ty, resolved_ty,
is_peer: if depth == 0 { is_peer: if depth == 0 {
false false
} else { } else {
ty == DependencyType::Peer ty == DependencyType::Peer
}, },
}; };
insert_node( insert_node(
&mut graph, &mut graph,
&package_id, &package_id,
node, node,
depth == 0, depth == 0,
); );
tracing::debug!("resolved {package_id} from new dependency graph"); tracing::debug!("resolved {package_id} from new dependency graph");
for (dependency_alias, (dependency_spec, dependency_ty)) in for (dependency_alias, (dependency_spec, dependency_ty)) in
pkg_ref.dependencies().clone() pkg_ref.dependencies().clone()
{ {
if dependency_ty == DependencyType::Dev { if dependency_ty == DependencyType::Dev {
// dev dependencies of dependencies are to be ignored // dev dependencies of dependencies are to be ignored
continue; continue;
} }
let overridden = manifest.overrides.iter().find_map(|(key, spec)| { let overridden = manifest.overrides.iter().find_map(|(key, spec)| {
key.0.iter().find_map(|override_path| { key.0.iter().find_map(|override_path| {
// if the path up until the last element is the same as the current path, // if the path up until the last element is the same as the current path,
// and the last element in the path is the dependency alias, // and the last element in the path is the dependency alias,
// then the specifier is to be overridden // then the specifier is to be overridden
(path.len() == override_path.len() - 1 (path.len() == override_path.len() - 1
&& path == override_path[..override_path.len() - 1] && path == override_path[..override_path.len() - 1]
&& override_path.last() == Some(&dependency_alias)) && override_path.last() == Some(&dependency_alias))
.then_some(spec) .then_some(spec)
}) })
}); });
if overridden.is_some() { if overridden.is_some() {
tracing::debug!( tracing::debug!(
"overridden specifier found for {} ({dependency_spec})", "overridden specifier found for {} ({dependency_spec})",
path.iter() path.iter()
.map(Alias::as_str) .map(Alias::as_str)
@ -351,32 +349,32 @@ impl Project {
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(">"), .join(">"),
); );
} }
queue.push_back(( queue.push_back((
match overridden { match overridden {
Some(OverrideSpecifier::Specifier(spec)) => spec.clone(), Some(OverrideSpecifier::Specifier(spec)) => spec.clone(),
Some(OverrideSpecifier::Alias(alias)) => all_current_dependencies.get(alias) Some(OverrideSpecifier::Alias(alias)) => all_current_dependencies.get(alias)
.map(|(spec, _)| spec) .map(|(spec, _)| spec)
.ok_or_else(|| errors::DependencyGraphError::AliasNotFound(alias.clone()))? .ok_or_else(|| errors::DependencyGraphError::AliasNotFound(alias.clone()))?
.clone(), .clone(),
None => dependency_spec, None => dependency_spec,
}, },
dependency_ty, dependency_ty,
Some(package_id.clone()), Some(package_id.clone()),
path.iter() path.iter()
.cloned() .cloned()
.chain(std::iter::once(dependency_alias)) .chain(std::iter::once(dependency_alias))
.collect(), .collect(),
overridden.is_some(), overridden.is_some(),
package_id.version_id().target(), package_id.version_id().target(),
)); ));
} }
Ok(()) Ok(())
} }
.instrument(tracing::info_span!("resolve new/changed", path = path.iter().map(Alias::as_str).collect::<Vec<_>>().join(">"))) .instrument(tracing::info_span!("resolve new/changed", path = path.iter().map(Alias::as_str).collect::<Vec<_>>().join(">")))
.await?; .await?;
} }
for (id, node) in &mut graph { for (id, node) in &mut graph {

52
src/source/git/mod.rs
View file

@ -13,7 +13,7 @@ use crate::{
IGNORED_FILES, IGNORED_FILES,
}, },
util::hash, util::hash,
Project, DEFAULT_INDEX_NAME, LOCKFILE_FILE_NAME, MANIFEST_FILE_NAME, Project, LOCKFILE_FILE_NAME, MANIFEST_FILE_NAME,
}; };
use fs_err::tokio as fs; use fs_err::tokio as fs;
use gix::{bstr::BStr, traverse::tree::Recorder, ObjectId, Url}; use gix::{bstr::BStr, traverse::tree::Recorder, ObjectId, Url};
@ -72,43 +72,29 @@ fn transform_pesde_dependencies(
.map(|(alias, (mut spec, ty))| { .map(|(alias, (mut spec, ty))| {
match &mut spec { match &mut spec {
DependencySpecifiers::Pesde(specifier) => { DependencySpecifiers::Pesde(specifier) => {
let index_name = specifier specifier.index = manifest
.index .indices
.as_deref() .get(&specifier.index)
.unwrap_or(DEFAULT_INDEX_NAME) .ok_or_else(|| {
errors::ResolveError::PesdeIndexNotFound(
specifier.index.to_string(),
Box::new(repo_url.clone()),
)
})?
.to_string(); .to_string();
specifier.index = Some(
manifest
.indices
.get(&index_name)
.ok_or_else(|| {
errors::ResolveError::PesdeIndexNotFound(
index_name.clone(),
Box::new(repo_url.clone()),
)
})?
.to_string(),
);
} }
#[cfg(feature = "wally-compat")] #[cfg(feature = "wally-compat")]
DependencySpecifiers::Wally(specifier) => { DependencySpecifiers::Wally(specifier) => {
let index_name = specifier specifier.index = manifest
.index .wally_indices
.as_deref() .get(&specifier.index)
.unwrap_or(DEFAULT_INDEX_NAME) .ok_or_else(|| {
errors::ResolveError::WallyIndexNotFound(
specifier.index.to_string(),
Box::new(repo_url.clone()),
)
})?
.to_string(); .to_string();
specifier.index = Some(
manifest
.wally_indices
.get(&index_name)
.ok_or_else(|| {
errors::ResolveError::WallyIndexNotFound(
index_name.clone(),
Box::new(repo_url.clone()),
)
})?
.to_string(),
);
} }
DependencySpecifiers::Git(_) => {} DependencySpecifiers::Git(_) => {}
DependencySpecifiers::Workspace(specifier) => { DependencySpecifiers::Workspace(specifier) => {

49
src/source/path/mod.rs
View file

@ -11,7 +11,6 @@ use crate::{
traits::{DownloadOptions, GetTargetOptions, PackageSource, ResolveOptions}, traits::{DownloadOptions, GetTargetOptions, PackageSource, ResolveOptions},
ResolveResult, ResolveResult,
}, },
DEFAULT_INDEX_NAME,
}; };
use std::collections::BTreeMap; use std::collections::BTreeMap;
use tracing::instrument; use tracing::instrument;
@ -49,37 +48,29 @@ impl PackageSource for PathPackageSource {
.map(|(alias, (mut spec, ty))| { .map(|(alias, (mut spec, ty))| {
match &mut spec { match &mut spec {
DependencySpecifiers::Pesde(spec) => { DependencySpecifiers::Pesde(spec) => {
let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); spec.index = manifest
.indices
spec.index = Some( .get(&spec.index)
manifest .ok_or_else(|| {
.indices errors::ResolveError::IndexNotFound(
.get(index_name) spec.index.to_string(),
.ok_or_else(|| { specifier.path.clone(),
errors::ResolveError::IndexNotFound( )
index_name.to_string(), })?
specifier.path.clone(), .to_string();
)
})?
.to_string(),
)
} }
#[cfg(feature = "wally-compat")] #[cfg(feature = "wally-compat")]
DependencySpecifiers::Wally(spec) => { DependencySpecifiers::Wally(spec) => {
let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); spec.index = manifest
.wally_indices
spec.index = Some( .get(&spec.index)
manifest .ok_or_else(|| {
.wally_indices errors::ResolveError::IndexNotFound(
.get(index_name) spec.index.to_string(),
.ok_or_else(|| { specifier.path.clone(),
errors::ResolveError::IndexNotFound( )
index_name.to_string(), })?
specifier.path.clone(), .to_string();
)
})?
.to_string(),
)
} }
DependencySpecifiers::Git(_) => {} DependencySpecifiers::Git(_) => {}
DependencySpecifiers::Workspace(_) => {} DependencySpecifiers::Workspace(_) => {}

4
src/source/pesde/specifier.rs
View file

@ -13,8 +13,8 @@ pub struct PesdeDependencySpecifier {
#[cfg_attr(test, schemars(with = "String"))] #[cfg_attr(test, schemars(with = "String"))]
pub version: VersionReq, pub version: VersionReq,
/// The index to use for the package /// The index to use for the package
#[serde(default, skip_serializing_if = "Option::is_none")] #[serde(default = "crate::default_index_name")]
pub index: Option<String>, pub index: String,
/// The target to use for the package /// The target to use for the package
#[serde(default, skip_serializing_if = "Option::is_none")] #[serde(default, skip_serializing_if = "Option::is_none")]
pub target: Option<TargetKind>, pub target: Option<TargetKind>,

11
src/source/wally/manifest.rs
View file

@ -42,7 +42,8 @@ pub fn deserialize_specifiers<'de, D: Deserializer<'de>>(
WallyDependencySpecifier { WallyDependencySpecifier {
name: name.parse().map_err(serde::de::Error::custom)?, name: name.parse().map_err(serde::de::Error::custom)?,
version: VersionReq::parse(version).map_err(serde::de::Error::custom)?, version: VersionReq::parse(version).map_err(serde::de::Error::custom)?,
index: None, // doesn't matter, will be replaced later
index: "".to_string(),
}, },
)) ))
}) })
@ -54,11 +55,11 @@ pub fn deserialize_specifiers<'de, D: Deserializer<'de>>(
pub struct WallyManifest { pub struct WallyManifest {
pub package: WallyPackage, pub package: WallyPackage,
#[serde(default, deserialize_with = "deserialize_specifiers")] #[serde(default, deserialize_with = "deserialize_specifiers")]
pub dependencies: BTreeMap<Alias, WallyDependencySpecifier>, dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
#[serde(default, deserialize_with = "deserialize_specifiers")] #[serde(default, deserialize_with = "deserialize_specifiers")]
pub server_dependencies: BTreeMap<Alias, WallyDependencySpecifier>, server_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
#[serde(default, deserialize_with = "deserialize_specifiers")] #[serde(default, deserialize_with = "deserialize_specifiers")]
pub dev_dependencies: BTreeMap<Alias, WallyDependencySpecifier>, dev_dependencies: BTreeMap<Alias, WallyDependencySpecifier>,
} }
impl WallyManifest { impl WallyManifest {
@ -77,7 +78,7 @@ impl WallyManifest {
] { ] {
for (alias, spec) in deps { for (alias, spec) in deps {
let mut spec = spec.clone(); let mut spec = spec.clone();
spec.index = Some(self.package.registry.to_string()); spec.index = self.package.registry.to_string();
if all_deps if all_deps
.insert(alias.clone(), (DependencySpecifiers::Wally(spec), ty)) .insert(alias.clone(), (DependencySpecifiers::Wally(spec), ty))

4
src/source/wally/specifier.rs
View file

@ -16,8 +16,8 @@ pub struct WallyDependencySpecifier {
#[cfg_attr(test, schemars(with = "String"))] #[cfg_attr(test, schemars(with = "String"))]
pub version: VersionReq, pub version: VersionReq,
/// The index to use for the package /// The index to use for the package
#[serde(default, skip_serializing_if = "Option::is_none")] #[serde(default = "crate::default_index_name")]
pub index: Option<String>, pub index: String,
} }
impl DependencySpecifier for WallyDependencySpecifier {} impl DependencySpecifier for WallyDependencySpecifier {}

41
src/source/workspace/mod.rs
View file

@ -11,7 +11,6 @@ use crate::{
workspace::pkg_ref::WorkspacePackageRef, workspace::pkg_ref::WorkspacePackageRef,
ResolveResult, ResolveResult,
}, },
DEFAULT_INDEX_NAME,
}; };
use futures::StreamExt; use futures::StreamExt;
use relative_path::RelativePathBuf; use relative_path::RelativePathBuf;
@ -82,33 +81,29 @@ impl PackageSource for WorkspacePackageSource {
.map(|(alias, (mut spec, ty))| { .map(|(alias, (mut spec, ty))| {
match &mut spec { match &mut spec {
DependencySpecifiers::Pesde(spec) => { DependencySpecifiers::Pesde(spec) => {
let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); spec.index = manifest
.indices
spec.index = Some( .get(&spec.index)
manifest .ok_or_else(|| {
.indices errors::ResolveError::IndexNotFound(
.get(index_name) spec.index.to_string(),
.ok_or(errors::ResolveError::IndexNotFound(
index_name.to_string(),
manifest.name.to_string(), manifest.name.to_string(),
))? )
.to_string(), })?
) .to_string();
} }
#[cfg(feature = "wally-compat")] #[cfg(feature = "wally-compat")]
DependencySpecifiers::Wally(spec) => { DependencySpecifiers::Wally(spec) => {
let index_name = spec.index.as_deref().unwrap_or(DEFAULT_INDEX_NAME); spec.index = manifest
.wally_indices
spec.index = Some( .get(&spec.index)
manifest .ok_or_else(|| {
.wally_indices errors::ResolveError::IndexNotFound(
.get(index_name) spec.index.to_string(),
.ok_or(errors::ResolveError::IndexNotFound(
index_name.to_string(),
manifest.name.to_string(), manifest.name.to_string(),
))? )
.to_string(), })?
) .to_string();
} }
DependencySpecifiers::Git(_) => {} DependencySpecifiers::Git(_) => {}
DependencySpecifiers::Workspace(_) => {} DependencySpecifiers::Workspace(_) => {}