Make the trait internal and rely on providing project name explicitely in resolve

Author: olivier-lacroix

src/has_recursion.rs

@@ -5,19 +5,10 @@ use thiserror::Error;
 
 /// A trait that resolves recursions for groups of requirements that can be mapped to `IndexMap<String, Vec<T>>`
 /// where T is a type that can be mapped to either a Requirement or a reference to other groups of requirements.
-pub trait HasRecursion<T>: Deref<Target = IndexMap<String, Vec<T>>>
+pub(crate) trait HasRecursion<T>: Deref<Target = IndexMap<String, Vec<T>>>
 where
     T: RecursionItem,
 {
-    /// Resolve the groups into lists of requirements.
-    ///
-    /// This function will recursively resolve all groups, including those that
-    /// reference other groups. It will return an error if there is a cycle in the
-    /// groups or if a group references another group that does not exist.
-    fn resolve(&self) -> Result<IndexMap<String, Vec<Requirement>>, RecursionResolutionError> {
-        self.resolve_all(None)
-    }
-
     /// Resolves the groups of requirements into flat lists of requirements.
     fn resolve_all(
         &self,
@@ -81,7 +72,7 @@ where
     }
 }
 /// A trait that defines how to parse a recursion item.
-pub trait RecursionItem {
+pub(crate) trait RecursionItem {
     /// Parse the item into a requirement or a reference to other groups.
     fn parse<'a>(&'a self, name: Option<&str>) -> Item<'a>;
     /// The name of the group in the TOML file.
@@ -90,7 +81,7 @@ pub trait RecursionItem {
     fn table_name() -> String;
 }
 
-pub enum Item<'a> {
+pub(crate) enum Item<'a> {
     Requirement(Requirement),
     Groups(Vec<&'a str>),
 }

src/lib.rs

@@ -120,17 +120,13 @@ impl Project {
 /// The `[project.optional-dependencies]` section of pyproject.toml
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 #[serde(transparent)]
-pub struct OptionalDependencies {
-    pub inner: IndexMap<String, Vec<Requirement>>,
-    #[serde(skip)]
-    pub self_reference_name: Option<String>,
-}
+pub struct OptionalDependencies(pub IndexMap<String, Vec<Requirement>>);
 
 impl Deref for OptionalDependencies {
     type Target = IndexMap<String, Vec<Requirement>>;
 
     fn deref(&self) -> &Self::Target {
-        &self.inner
+        &self.0
     }
 }
 
@@ -247,17 +243,7 @@ pub enum DependencyGroupSpecifier {
 impl PyProjectToml {
     /// Parse `pyproject.toml` content
     pub fn new(content: &str) -> Result<Self, toml::de::Error> {
-        let mut pyproject: PyProjectToml = toml::de::from_str(content)?;
-
-        // Set the project name as optional-dependencies self_reference_name
-        if let Some(project) = pyproject.project.as_mut() {
-            let name = project.name.clone();
-            if let Some(od) = project.optional_dependencies.as_mut() {
-                od.self_reference_name = Some(name);
-            }
-        }
-
-        Ok(pyproject)
+        toml::de::from_str(content)
     }
 }
 
@@ -366,14 +352,6 @@ tomatoes = "spam:main_tomatoes""#;
             project.gui_scripts.as_ref().unwrap()["spam-gui"],
             "spam:main_gui"
         );
-        assert_eq!(
-            project
-                .optional_dependencies
-                .as_ref()
-                .unwrap()
-                .self_reference_name,
-            Some("spam".to_string())
-        );
     }
 
     #[test]

src/optional_dependencies_resolve.rs

@@ -5,9 +5,22 @@ use crate::{
 use indexmap::IndexMap;
 use pep508_rs::Requirement;
 
-impl HasRecursion<Requirement> for OptionalDependencies {
-    fn resolve(&self) -> Result<IndexMap<String, Vec<Requirement>>, RecursionResolutionError> {
-        self.resolve_all(self.self_reference_name.as_deref())
+impl HasRecursion<Requirement> for OptionalDependencies {}
+
+impl OptionalDependencies {
+    /// Resolve the optional dependency groups into lists of requirements.
+    ///
+    /// This function will recursively resolve all optional dependency groups, including those that
+    /// reference other groups. It will return an error if there is a cycle in the
+    /// groups or if a group references another group that does not exist.
+    ///
+    /// `self_reference_name` is the name of the project itself, which is used to identify self-references
+    /// in the optional dependencies. If None, self-references will be treated as normal dependencies.
+    pub fn resolve(
+        &self,
+        self_reference_name: Option<&str>,
+    ) -> Result<IndexMap<String, Vec<Requirement>>, RecursionResolutionError> {
+        self.resolve_all(self_reference_name)
     }
 }
 
@@ -53,7 +66,7 @@ iota = ["spam[alpha]"]
             .unwrap();
 
         assert_eq!(
-            optional_dependencies.resolve().unwrap()["iota"],
+            optional_dependencies.resolve(Some("spam")).unwrap()["iota"],
             vec![
                 Requirement::from_str("beta").unwrap(),
                 Requirement::from_str("gamma").unwrap(),
@@ -80,7 +93,10 @@ iota = ["spam[alpha]"]
             .as_ref()
             .unwrap();
         assert_eq!(
-            optional_dependencies.resolve().unwrap_err().to_string(),
+            optional_dependencies
+                .resolve(Some("spam"))
+                .unwrap_err()
+                .to_string(),
             String::from(
                 "Detected a cycle in `project.optional-dependencies`: `alpha` -> `iota` -> `alpha`"
             )
@@ -104,7 +120,10 @@ iota = ["spam[alpha]"]
             .as_ref()
             .unwrap();
         assert_eq!(
-            optional_dependencies.resolve().unwrap_err().to_string(),
+            optional_dependencies
+                .resolve(Some("spam"))
+                .unwrap_err()
+                .to_string(),
             String::from("Failed to find optional dependency group `alpha` included by `iota`")
         )
     }

src/pep735_resolve.rs

@@ -1,9 +1,22 @@
-use crate::has_recursion::{HasRecursion, Item, RecursionItem};
+use indexmap::IndexMap;
+use pep508_rs::Requirement;
+
+use crate::has_recursion::{HasRecursion, Item, RecursionItem, RecursionResolutionError};
 
 use crate::{DependencyGroupSpecifier, DependencyGroups};
 
 impl HasRecursion<DependencyGroupSpecifier> for DependencyGroups {}
 
+impl DependencyGroups {
+    /// Resolve the dependency groups into lists of requirements.
+    ///
+    /// This function will recursively resolve all dependency groups, including those that
+    /// reference other groups. It will return an error if there is a cycle in the
+    /// groups or if a group references another group that does not exist.
+    pub fn resolve(&self) -> Result<IndexMap<String, Vec<Requirement>>, RecursionResolutionError> {
+        self.resolve_all(None)
+    }
+}
 impl RecursionItem for DependencyGroupSpecifier {
     fn parse(&self, _name: Option<&str>) -> Item {
         match self {