rust: implement `From<SparseConfigWarning>` for `HgError`

This will be useful in a future patch to avoid a lot of boilerplate.

rust/hg-core/src/narrow.rs

@@ -1,115 +1,115
 use std::path::Path;
 
 use crate::{
     errors::HgError,
     exit_codes,
     filepatterns::parse_pattern_file_contents,
     matchers::{
         AlwaysMatcher, DifferenceMatcher, IncludeMatcher, Matcher,
         NeverMatcher,
     },
     repo::Repo,
     requirements::NARROW_REQUIREMENT,
     sparse::{self, SparseConfigError, SparseWarning},
 };
 
 /// The file in .hg/store/ that indicates which paths exit in the store
 const FILENAME: &str = "narrowspec";
 /// The file in .hg/ that indicates which paths exit in the dirstate
 const DIRSTATE_FILENAME: &str = "narrowspec.dirstate";
 
 /// Pattern prefixes that are allowed in narrow patterns. This list MUST
 /// only contain patterns that are fast and safe to evaluate. Keep in mind
 /// that patterns are supplied by clients and executed on remote servers
 /// as part of wire protocol commands. That means that changes to this
 /// data structure influence the wire protocol and should not be taken
 /// lightly - especially removals.
-const VALID_PREFIXES: [&str; 2] = ["path:", "rootfilesin:"];
+pub const VALID_PREFIXES: [&str; 2] = ["path:", "rootfilesin:"];
 
 /// Return the matcher for the current narrow spec, and all configuration
 /// warnings to display.
 pub fn matcher(
     repo: &Repo,
 ) -> Result<(Box<dyn Matcher + Sync>, Vec<SparseWarning>), SparseConfigError> {
     let mut warnings = vec![];
     if !repo.requirements().contains(NARROW_REQUIREMENT) {
         return Ok((Box::new(AlwaysMatcher), warnings));
     }
     // Treat "narrowspec does not exist" the same as "narrowspec file exists
     // and is empty".
     let store_spec = repo.store_vfs().try_read(FILENAME)?.unwrap_or_default();
     let working_copy_spec = repo
         .hg_vfs()
         .try_read(DIRSTATE_FILENAME)?
         .unwrap_or_default();
     if store_spec != working_copy_spec {
         return Err(HgError::abort(
             "abort: working copy's narrowspec is stale",
             exit_codes::STATE_ERROR,
             Some("run 'hg tracked --update-working-copy'".into()),
         )
         .into());
     }
 
     let config = sparse::parse_config(
         &store_spec,
         sparse::SparseConfigContext::Narrow,
     )?;
 
     warnings.extend(config.warnings);
 
     if !config.profiles.is_empty() {
         // TODO (from Python impl) maybe do something with profiles?
         return Err(SparseConfigError::IncludesInNarrow);
     }
     validate_patterns(&config.includes)?;
     validate_patterns(&config.excludes)?;
 
     if config.includes.is_empty() {
         return Ok((Box::new(NeverMatcher), warnings));
     }
 
     let (patterns, subwarnings) = parse_pattern_file_contents(
         &config.includes,
         Path::new(""),
         None,
         false,
         true,
     )?;
     warnings.extend(subwarnings.into_iter().map(From::from));
 
     let mut m: Box<dyn Matcher + Sync> =
         Box::new(IncludeMatcher::new(patterns)?);
 
     let (patterns, subwarnings) = parse_pattern_file_contents(
         &config.excludes,
         Path::new(""),
         None,
         false,
         true,
     )?;
     if !patterns.is_empty() {
         warnings.extend(subwarnings.into_iter().map(From::from));
         let exclude_matcher = Box::new(IncludeMatcher::new(patterns)?);
         m = Box::new(DifferenceMatcher::new(m, exclude_matcher));
     }
 
     Ok((m, warnings))
 }
 
 fn validate_patterns(patterns: &[u8]) -> Result<(), SparseConfigError> {
     for pattern in patterns.split(|c| *c == b'\n') {
         if pattern.is_empty() {
             continue;
         }
         for prefix in VALID_PREFIXES.iter() {
             if pattern.starts_with(prefix.as_bytes()) {
                 return Ok(());
             }
         }
         return Err(SparseConfigError::InvalidNarrowPrefix(
             pattern.to_owned(),
         ));
     }
     Ok(())
 }

rust/hg-core/src/sparse.rs

@@ -1,341 +1,405
-use std::{collections::HashSet, path::Path};
+use std::{collections::HashSet, fmt::Display, path::Path};
 
-use format_bytes::{write_bytes, DisplayBytes};
+use format_bytes::{format_bytes, write_bytes, DisplayBytes};
 
 use crate::{
     errors::HgError,
+    exit_codes::STATE_ERROR,
     filepatterns::parse_pattern_file_contents,
     matchers::{
         AlwaysMatcher, DifferenceMatcher, IncludeMatcher, Matcher,
         UnionMatcher,
     },
+    narrow::VALID_PREFIXES,
     operations::cat,
     repo::Repo,
     requirements::SPARSE_REQUIREMENT,
     utils::{hg_path::HgPath, SliceExt},
     IgnorePattern, PatternError, PatternFileWarning, PatternSyntax, Revision,
     NULL_REVISION,
 };
 
 /// Command which is triggering the config read
 #[derive(Copy, Clone, Debug)]
 pub enum SparseConfigContext {
     Sparse,
     Narrow,
 }
 
 impl DisplayBytes for SparseConfigContext {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         match self {
             SparseConfigContext::Sparse => write_bytes!(output, b"sparse"),
             SparseConfigContext::Narrow => write_bytes!(output, b"narrow"),
         }
     }
 }
 
+impl Display for SparseConfigContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SparseConfigContext::Sparse => write!(f, "sparse"),
+            SparseConfigContext::Narrow => write!(f, "narrow"),
+        }
+    }
+}
+
 /// Possible warnings when reading sparse configuration
 #[derive(Debug, derive_more::From)]
 pub enum SparseWarning {
     /// Warns about improper paths that start with "/"
     RootWarning {
         context: SparseConfigContext,
         line: Vec<u8>,
     },
     /// Warns about a profile missing from the given changelog revision
     ProfileNotFound { profile: Vec<u8>, rev: Revision },
     #[from]
     Pattern(PatternFileWarning),
 }
 
 /// Parsed sparse config
 #[derive(Debug, Default)]
 pub struct SparseConfig {
     // Line-separated
     pub(crate) includes: Vec<u8>,
     // Line-separated
     pub(crate) excludes: Vec<u8>,
     pub(crate) profiles: HashSet<Vec<u8>>,
     pub(crate) warnings: Vec<SparseWarning>,
 }
 
 /// All possible errors when reading sparse/narrow config
 #[derive(Debug, derive_more::From)]
 pub enum SparseConfigError {
     IncludesAfterExcludes {
         context: SparseConfigContext,
     },
     EntryOutsideSection {
         context: SparseConfigContext,
         line: Vec<u8>,
     },
     /// Narrow config does not support '%include' directives
     IncludesInNarrow,
     /// An invalid pattern prefix was given to the narrow spec. Includes the
     /// entire pattern for context.
     InvalidNarrowPrefix(Vec<u8>),
     #[from]
     HgError(HgError),
     #[from]
     PatternError(PatternError),
 }
 
+impl From<SparseConfigError> for HgError {
+    fn from(value: SparseConfigError) -> Self {
+        match value {
+            SparseConfigError::IncludesAfterExcludes { context } => {
+                HgError::Abort {
+                    message: format!(
+                        "{} config cannot have includes after excludes",
+                        context,
+                    ),
+                    detailed_exit_code: STATE_ERROR,
+                    hint: None,
+                }
+            }
+            SparseConfigError::EntryOutsideSection { context, line } => {
+                HgError::Abort {
+                    message: format!(
+                        "{} config entry outside of section: {}",
+                        context,
+                        String::from_utf8_lossy(&line)
+                    ),
+                    detailed_exit_code: STATE_ERROR,
+                    hint: None,
+                }
+            }
+            SparseConfigError::IncludesInNarrow => HgError::Abort {
+                message: "including other spec files using '%include' is not \
+                supported in narrowspec"
+                    .to_string(),
+                detailed_exit_code: STATE_ERROR,
+                hint: None,
+            },
+            SparseConfigError::InvalidNarrowPrefix(vec) => HgError::Abort {
+                message: String::from_utf8_lossy(&format_bytes!(
+                    b"invalid prefix on narrow pattern: {}",
+                    vec
+                ))
+                .to_string(),
+                detailed_exit_code: STATE_ERROR,
+                hint: Some(format!(
+                    "narrow patterns must begin with one of the following: {}",
+                    VALID_PREFIXES.join(", ")
+                )),
+            },
+            SparseConfigError::HgError(hg_error) => hg_error,
+            SparseConfigError::PatternError(pattern_error) => HgError::Abort {
+                message: pattern_error.to_string(),
+                detailed_exit_code: STATE_ERROR,
+                hint: None,
+            },
+        }
+    }
+}
+
 /// Parse sparse config file content.
 pub(crate) fn parse_config(
     raw: &[u8],
     context: SparseConfigContext,
 ) -> Result<SparseConfig, SparseConfigError> {
     let mut includes = vec![];
     let mut excludes = vec![];
     let mut profiles = HashSet::new();
     let mut warnings = vec![];
 
     #[derive(PartialEq, Eq)]
     enum Current {
         Includes,
         Excludes,
         None,
     }
 
     let mut current = Current::None;
     let mut in_section = false;
 
     for line in raw.split(|c| *c == b'\n') {
         let line = line.trim();
         if line.is_empty() || line[0] == b'#' {
             // empty or comment line, skip
             continue;
         }
         if line.starts_with(b"%include ") {
             let profile = line[b"%include ".len()..].trim();
             if !profile.is_empty() {
                 profiles.insert(profile.into());
             }
         } else if line == b"[include]" {
             if in_section && current == Current::Includes {
                 return Err(SparseConfigError::IncludesAfterExcludes {
                     context,
                 });
             }
             in_section = true;
             current = Current::Includes;
             continue;
         } else if line == b"[exclude]" {
             in_section = true;
             current = Current::Excludes;
         } else {
             if current == Current::None {
                 return Err(SparseConfigError::EntryOutsideSection {
                     context,
                     line: line.into(),
                 });
             }
             if line.trim().starts_with(b"/") {
                 warnings.push(SparseWarning::RootWarning {
                     context,
                     line: line.into(),
                 });
                 continue;
             }
             match current {
                 Current::Includes => {
                     includes.push(b'\n');
                     includes.extend(line.iter());
                 }
                 Current::Excludes => {
                     excludes.push(b'\n');
                     excludes.extend(line.iter());
                 }
                 Current::None => unreachable!(),
             }
         }
     }
 
     Ok(SparseConfig {
         includes,
         excludes,
         profiles,
         warnings,
     })
 }
 
 fn read_temporary_includes(
     repo: &Repo,
 ) -> Result<Vec<Vec<u8>>, SparseConfigError> {
     let raw = repo.hg_vfs().try_read("tempsparse")?.unwrap_or_default();
     if raw.is_empty() {
         return Ok(vec![]);
     }
     Ok(raw.split(|c| *c == b'\n').map(ToOwned::to_owned).collect())
 }
 
 /// Obtain sparse checkout patterns for the given revision
 fn patterns_for_rev(
     repo: &Repo,
     rev: Revision,
 ) -> Result<Option<SparseConfig>, SparseConfigError> {
     if !repo.has_sparse() {
         return Ok(None);
     }
     let raw = repo.hg_vfs().try_read("sparse")?.unwrap_or_default();
 
     if raw.is_empty() {
         return Ok(None);
     }
 
     let mut config = parse_config(&raw, SparseConfigContext::Sparse)?;
 
     if !config.profiles.is_empty() {
         let mut profiles: Vec<Vec<u8>> = config.profiles.into_iter().collect();
         let mut visited = HashSet::new();
 
         while let Some(profile) = profiles.pop() {
             if visited.contains(&profile) {
                 continue;
             }
             visited.insert(profile.to_owned());
 
             let output =
                 cat(repo, &rev.to_string(), vec![HgPath::new(&profile)])
                     .map_err(|_| {
                         HgError::corrupted(
                             "dirstate points to non-existent parent node"
                                 .to_string(),
                         )
                     })?;
             if output.results.is_empty() {
                 config.warnings.push(SparseWarning::ProfileNotFound {
                     profile: profile.to_owned(),
                     rev,
                 })
             }
 
             let subconfig = parse_config(
                 &output.results[0].1,
                 SparseConfigContext::Sparse,
             )?;
             if !subconfig.includes.is_empty() {
                 config.includes.push(b'\n');
                 config.includes.extend(&subconfig.includes);
             }
             if !subconfig.includes.is_empty() {
                 config.includes.push(b'\n');
                 config.excludes.extend(&subconfig.excludes);
             }
             config.warnings.extend(subconfig.warnings.into_iter());
             profiles.extend(subconfig.profiles.into_iter());
         }
 
         config.profiles = visited;
     }
 
     if !config.includes.is_empty() {
         config.includes.extend(b"\n.hg*");
     }
 
     Ok(Some(config))
 }
 
 /// Obtain a matcher for sparse working directories.
 pub fn matcher(
     repo: &Repo,
 ) -> Result<(Box<dyn Matcher + Sync>, Vec<SparseWarning>), SparseConfigError> {
     let mut warnings = vec![];
     if !repo.requirements().contains(SPARSE_REQUIREMENT) {
         return Ok((Box::new(AlwaysMatcher), warnings));
     }
 
     let parents = repo.dirstate_parents()?;
     let mut revs = vec![];
     let p1_rev =
         repo.changelog()?
             .rev_from_node(parents.p1.into())
             .map_err(|_| {
                 HgError::corrupted(
                     "dirstate points to non-existent parent node".to_string(),
                 )
             })?;
     if p1_rev != NULL_REVISION {
         revs.push(p1_rev)
     }
     let p2_rev =
         repo.changelog()?
             .rev_from_node(parents.p2.into())
             .map_err(|_| {
                 HgError::corrupted(
                     "dirstate points to non-existent parent node".to_string(),
                 )
             })?;
     if p2_rev != NULL_REVISION {
         revs.push(p2_rev)
     }
     let mut matchers = vec![];
 
     for rev in revs.iter() {
         let config = patterns_for_rev(repo, *rev);
         if let Ok(Some(config)) = config {
             warnings.extend(config.warnings);
             let mut m: Box<dyn Matcher + Sync> = Box::new(AlwaysMatcher);
             if !config.includes.is_empty() {
                 let (patterns, subwarnings) = parse_pattern_file_contents(
                     &config.includes,
                     Path::new(""),
                     Some(PatternSyntax::Glob),
                     false,
                     false,
                 )?;
                 warnings.extend(subwarnings.into_iter().map(From::from));
                 m = Box::new(IncludeMatcher::new(patterns)?);
             }
             if !config.excludes.is_empty() {
                 let (patterns, subwarnings) = parse_pattern_file_contents(
                     &config.excludes,
                     Path::new(""),
                     Some(PatternSyntax::Glob),
                     false,
                     false,
                 )?;
                 warnings.extend(subwarnings.into_iter().map(From::from));
                 m = Box::new(DifferenceMatcher::new(
                     m,
                     Box::new(IncludeMatcher::new(patterns)?),
                 ));
             }
             matchers.push(m);
         }
     }
     let result: Box<dyn Matcher + Sync> = match matchers.len() {
         0 => Box::new(AlwaysMatcher),
         1 => matchers.pop().expect("1 is equal to 0"),
         _ => Box::new(UnionMatcher::new(matchers)),
     };
 
     let matcher =
         force_include_matcher(result, &read_temporary_includes(repo)?)?;
     Ok((matcher, warnings))
 }
 
 /// Returns a matcher that returns true for any of the forced includes before
 /// testing against the actual matcher
 fn force_include_matcher(
     result: Box<dyn Matcher + Sync>,
     temp_includes: &[Vec<u8>],
 ) -> Result<Box<dyn Matcher + Sync>, PatternError> {
     if temp_includes.is_empty() {
         return Ok(result);
     }
     let forced_include_matcher = IncludeMatcher::new(
         temp_includes
             .iter()
             .map(|include| {
                 IgnorePattern::new(PatternSyntax::Path, include, Path::new(""))
             })
             .collect(),
     )?;
     Ok(Box::new(UnionMatcher::new(vec![
         Box::new(forced_include_matcher),
         result,
     ])))
 }