Add support for source trees

crates/pep508-rs/src/marker.rs

@@ -967,6 +967,87 @@ impl MarkerTree {
         }
     }
 
+    /// Remove the extras from a marker, returning `None` if the marker tree evaluates to `true`.
+    ///
+    /// Any `extra` markers that are always `true` given the provided extras will be removed.
+    /// Any `extra` markers that are always `false` given the provided extras will be left
+    /// unchanged.
+    ///
+    /// For example, if `dev` is a provided extra, given `sys_platform == 'linux' and extra == 'dev'`,
+    /// the marker will be simplified to `sys_platform == 'linux'`.
+    pub fn simplify_extras(self, extras: &[ExtraName]) -> Option<MarkerTree> {
+        /// Returns `true` if the given expression is always `true` given the set of extras.
+        pub fn is_true(expression: &MarkerExpression, extras: &[ExtraName]) -> bool {
+            // Ex) `extra == 'dev'`
+            if expression.l_value == MarkerValue::Extra {
+                if let MarkerValue::QuotedString(r_string) = &expression.r_value {
+                    if let Ok(r_extra) = ExtraName::from_str(r_string) {
+                        return extras.contains(&r_extra);
+                    }
+                }
+            }
+            // Ex) `'dev' == extra`
+            if expression.r_value == MarkerValue::Extra {
+                if let MarkerValue::QuotedString(l_string) = &expression.l_value {
+                    if let Ok(l_extra) = ExtraName::from_str(l_string) {
+                        return extras.contains(&l_extra);
+                    }
+                }
+            }
+            false
+        }
+
+        match self {
+            Self::Expression(expression) => {
+                // If the expression is true, we can remove the marker entirely.
+                if is_true(&expression, extras) {
+                    None
+                } else {
+                    // If not, return the original marker.
+                    Some(Self::Expression(expression))
+                }
+            }
+            Self::And(expressions) => {
+                // Remove any expressions that are _true_ due to the presence of an extra.
+                let simplified = expressions
+                    .into_iter()
+                    .filter_map(|marker| marker.simplify_extras(extras))
+                    .collect::<Vec<_>>();
+
+                // If there are no expressions left, return None.
+                if simplified.is_empty() {
+                    None
+                } else if simplified.len() == 1 {
+                    // If there is only one expression left, return the simplified marker.
+                    simplified.into_iter().next()
+                } else {
+                    // If there are still expressions left, return the simplified marker.
+                    Some(Self::And(simplified))
+                }
+            }
+            Self::Or(expressions) => {
+                let num_expressions = expressions.len();
+
+                // Remove any expressions that are _true_ due to the presence of an extra.
+                let simplified = expressions
+                    .into_iter()
+                    .filter_map(|marker| marker.simplify_extras(extras))
+                    .collect::<Vec<_>>();
+
+                // If any of the expressions are true, the entire marker is true.
+                if simplified.len() < num_expressions {
+                    None
+                } else if simplified.len() == 1 {
+                    // If there is only one expression left, return the simplified marker.
+                    simplified.into_iter().next()
+                } else {
+                    // If there are still expressions left, return the simplified marker.
+                    Some(Self::Or(simplified))
+                }
+            }
+        }
+    }
+
     /// Same as [`Self::evaluate`], but instead of using logging to warn, you can pass your own
     /// handler for warnings
     pub fn evaluate_reporter(
@@ -1368,9 +1449,13 @@ fn parse_markers(markers: &str) -> Result<MarkerTree, Pep508Error> {
 #[cfg(test)]
 mod test {
     use crate::marker::{MarkerEnvironment, StringVersion};
-    use crate::{MarkerExpression, MarkerOperator, MarkerTree, MarkerValue, MarkerValueString};
+    use crate::{
+        MarkerExpression, MarkerOperator, MarkerTree, MarkerValue, MarkerValueString,
+        MarkerValueVersion,
+    };
     use insta::assert_snapshot;
     use std::str::FromStr;
+    use uv_normalize::ExtraName;
 
     fn parse_err(input: &str) -> String {
         MarkerTree::from_str(input).unwrap_err().to_string()
@@ -1616,4 +1701,99 @@ mod test {
         )
         .unwrap();
     }
+
+    #[test]
+    fn test_simplify_extras() {
+        // Given `os_name == "nt" and extra == "dev"`, simplify to `os_name == "nt"`.
+        let markers = MarkerTree::from_str(r#"os_name == "nt" and extra == "dev""#).unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(
+            simplified,
+            Some(MarkerTree::Expression(MarkerExpression {
+                l_value: MarkerValue::MarkerEnvString(MarkerValueString::OsName),
+                operator: MarkerOperator::Equal,
+                r_value: MarkerValue::QuotedString("nt".to_string()),
+            }))
+        );
+
+        // Given `os_name == "nt" or extra == "dev"`, remove the marker entirely.
+        let markers = MarkerTree::from_str(r#"os_name == "nt" or extra == "dev""#).unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(simplified, None);
+
+        // Given `extra == "dev"`, remove the marker entirely.
+        let markers = MarkerTree::from_str(r#"extra == "dev""#).unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(simplified, None);
+
+        // Given `extra == "dev" and extra == "test"`, simplify to `extra == "test"`.
+        let markers = MarkerTree::from_str(r#"extra == "dev" and extra == "test""#).unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(
+            simplified,
+            Some(MarkerTree::Expression(MarkerExpression {
+                l_value: MarkerValue::Extra,
+                operator: MarkerOperator::Equal,
+                r_value: MarkerValue::QuotedString("test".to_string()),
+            }))
+        );
+
+        // Given `os_name == "nt" and extra == "test"`, don't simplify.
+        let markers = MarkerTree::from_str(r#"os_name == "nt" and extra == "test""#).unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(
+            simplified,
+            Some(MarkerTree::And(vec![
+                MarkerTree::Expression(MarkerExpression {
+                    l_value: MarkerValue::MarkerEnvString(MarkerValueString::OsName),
+                    operator: MarkerOperator::Equal,
+                    r_value: MarkerValue::QuotedString("nt".to_string()),
+                }),
+                MarkerTree::Expression(MarkerExpression {
+                    l_value: MarkerValue::Extra,
+                    operator: MarkerOperator::Equal,
+                    r_value: MarkerValue::QuotedString("test".to_string()),
+                }),
+            ]))
+        );
+
+        // Given `os_name == "nt" and (python_version == "3.7" or extra == "dev")`, simplify to
+        // `os_name == "nt".
+        let markers = MarkerTree::from_str(
+            r#"os_name == "nt" and (python_version == "3.7" or extra == "dev")"#,
+        )
+        .unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(
+            simplified,
+            Some(MarkerTree::Expression(MarkerExpression {
+                l_value: MarkerValue::MarkerEnvString(MarkerValueString::OsName),
+                operator: MarkerOperator::Equal,
+                r_value: MarkerValue::QuotedString("nt".to_string()),
+            }))
+        );
+
+        // Given `os_name == "nt" or (python_version == "3.7" and extra == "dev")`, simplify to
+        // `os_name == "nt" or python_version == "3.7"`.
+        let markers = MarkerTree::from_str(
+            r#"os_name == "nt" or (python_version == "3.7" and extra == "dev")"#,
+        )
+        .unwrap();
+        let simplified = markers.simplify_extras(&[ExtraName::from_str("dev").unwrap()]);
+        assert_eq!(
+            simplified,
+            Some(MarkerTree::Or(vec![
+                MarkerTree::Expression(MarkerExpression {
+                    l_value: MarkerValue::MarkerEnvString(MarkerValueString::OsName),
+                    operator: MarkerOperator::Equal,
+                    r_value: MarkerValue::QuotedString("nt".to_string()),
+                }),
+                MarkerTree::Expression(MarkerExpression {
+                    l_value: MarkerValue::MarkerEnvVersion(MarkerValueVersion::PythonVersion),
+                    operator: MarkerOperator::Equal,
+                    r_value: MarkerValue::QuotedString("3.7".to_string()),
+                }),
+            ]))
+        );
+    }
 }

crates/uv-requirements/Cargo.toml

@@ -36,6 +36,7 @@ rustc-hash = { workspace = true }
 serde = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
+url = { workspace = true }
 
 [lints]
 workspace = true

crates/uv-requirements/src/lib.rs

@@ -1,9 +1,11 @@
 pub use crate::resolver::*;
+pub use crate::source_tree::*;
 pub use crate::sources::*;
 pub use crate::specification::*;
 
 mod confirm;
 mod resolver;
+mod source_tree;
 mod sources;
 mod specification;
 pub mod upgrade;

crates/uv-requirements/src/source_tree.rs

@@ -0,0 +1,127 @@
+use std::borrow::Cow;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use anyhow::{Context, Result};
+use futures::{StreamExt, TryStreamExt};
+use url::Url;
+
+use distribution_types::{BuildableSource, PathSourceUrl, SourceUrl};
+use pep508_rs::Requirement;
+use uv_client::RegistryClient;
+use uv_distribution::{Reporter, SourceDistCachedBuilder};
+use uv_traits::BuildContext;
+
+use crate::ExtrasSpecification;
+
+/// A resolver for requirements specified via source trees.
+///
+/// Used, e.g., to determine the the input requirements when a user specifies a `pyproject.toml`
+/// file, which may require running PEP 517 build hooks to extract metadata.
+pub struct SourceTreeResolver<'a> {
+    /// The requirements for the project.
+    source_trees: Vec<PathBuf>,
+    /// The extras to include when resolving requirements.
+    extras: &'a ExtrasSpecification<'a>,
+    /// The reporter to use when building source distributions.
+    reporter: Option<Arc<dyn Reporter>>,
+}
+
+impl<'a> SourceTreeResolver<'a> {
+    /// Instantiate a new [`SourceTreeResolver`] for a given set of `source_trees`.
+    pub fn new(source_trees: Vec<PathBuf>, extras: &'a ExtrasSpecification<'a>) -> Self {
+        Self {
+            source_trees,
+            extras,
+            reporter: None,
+        }
+    }
+
+    /// Set the [`Reporter`] to use for this resolver.
+    #[must_use]
+    pub fn with_reporter(self, reporter: impl Reporter + 'static) -> Self {
+        let reporter: Arc<dyn Reporter> = Arc::new(reporter);
+        Self {
+            reporter: Some(reporter),
+            ..self
+        }
+    }
+
+    /// Resolve the requirements from the provided source trees.
+    pub async fn resolve<T: BuildContext>(
+        self,
+        context: &T,
+        client: &RegistryClient,
+    ) -> Result<Vec<Requirement>> {
+        let requirements: Vec<_> = futures::stream::iter(self.source_trees.iter())
+            .map(|source_tree| async {
+                self.resolve_source_tree(source_tree, context, client).await
+            })
+            .buffered(50)
+            .try_collect()
+            .await?;
+        Ok(requirements.into_iter().flatten().collect())
+    }
+
+    /// Infer the package name for a given "unnamed" requirement.
+    async fn resolve_source_tree<T: BuildContext>(
+        &self,
+        source_tree: &Path,
+        context: &T,
+        client: &RegistryClient,
+    ) -> Result<Vec<Requirement>> {
+        // Convert to a buildable source.
+        let path = fs_err::canonicalize(source_tree).with_context(|| {
+            format!(
+                "Failed to canonicalize path to source tree: {}",
+                source_tree.display()
+            )
+        })?;
+        let Ok(url) = Url::from_directory_path(&path) else {
+            return Err(anyhow::anyhow!("Failed to convert path to URL"));
+        };
+        let source = BuildableSource::Url(SourceUrl::Path(PathSourceUrl {
+            url: &url,
+            path: Cow::Owned(path),
+        }));
+
+        // Run the PEP 517 build process to extract metadata from the source distribution.
+        let builder = if let Some(reporter) = self.reporter.clone() {
+            SourceDistCachedBuilder::new(context, client).with_reporter(reporter)
+        } else {
+            SourceDistCachedBuilder::new(context, client)
+        };
+
+        let metadata = builder
+            .download_and_build_metadata(&source)
+            .await
+            .context("Failed to build source distribution")?;
+
+        // Determine the appropriate requirements to return based on the extras. This involves
+        // evaluating the `extras` expression in any markers, but preserving the remaining marker
+        // conditions.
+        match self.extras {
+            ExtrasSpecification::None => Ok(metadata.requires_dist),
+            ExtrasSpecification::All => Ok(metadata
+                .requires_dist
+                .into_iter()
+                .map(|requirement| Requirement {
+                    marker: requirement
+                        .marker
+                        .and_then(|marker| marker.simplify_extras(&metadata.provides_extras)),
+                    ..requirement
+                })
+                .collect()),
+            ExtrasSpecification::Some(extras) => Ok(metadata
+                .requires_dist
+                .into_iter()
+                .map(|requirement| Requirement {
+                    marker: requirement
+                        .marker
+                        .and_then(|marker| marker.simplify_extras(extras)),
+                    ..requirement
+                })
+                .collect()),
+        }
+    }
+}

crates/uv-requirements/src/sources.rs

@@ -105,4 +105,8 @@ impl ExtrasSpecification<'_> {
             ExtrasSpecification::Some(extras) => extras.contains(name),
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        matches!(self, ExtrasSpecification::None)
+    }
 }