1 use std::{collections::HashSet, path::Path};

     2 

     3 use format_bytes::{write_bytes, DisplayBytes};

     4 

     5 use crate::{

     6     errors::HgError,

     7     filepatterns::parse_pattern_file_contents,

     8     matchers::{

     9         AlwaysMatcher, DifferenceMatcher, IncludeMatcher, Matcher,

    10         UnionMatcher,

    11     },

    12     operations::cat,

    13     repo::Repo,

    14     requirements::SPARSE_REQUIREMENT,

    15     utils::{hg_path::HgPath, SliceExt},

    16     IgnorePattern, PatternError, PatternFileWarning, PatternSyntax, Revision,

    17     NULL_REVISION,

    18 };

    19 

    20 /// Command which is triggering the config read

    21 #[derive(Copy, Clone, Debug)]

    22 pub enum SparseConfigContext {

    23     Sparse,

    24     Narrow,

    25 }

    26 

    27 impl DisplayBytes for SparseConfigContext {

    28     fn display_bytes(

    29         &self,

    30         output: &mut dyn std::io::Write,

    31     ) -> std::io::Result<()> {

    32         match self {

    33             SparseConfigContext::Sparse => write_bytes!(output, b"sparse"),

    34             SparseConfigContext::Narrow => write_bytes!(output, b"narrow"),

    35         }

    36     }

    37 }

    38 

    39 /// Possible warnings when reading sparse configuration

    40 #[derive(Debug, derive_more::From)]

    41 pub enum SparseWarning {

    42     /// Warns about improper paths that start with "/"

    43     RootWarning {

    44         context: SparseConfigContext,

    45         line: Vec<u8>,

    46     },

    47     /// Warns about a profile missing from the given changelog revision

    48     ProfileNotFound { profile: Vec<u8>, rev: Revision },

    49     #[from]

    50     Pattern(PatternFileWarning),

    51 }

    52 

    53 /// Parsed sparse config

    54 #[derive(Debug, Default)]

    55 pub struct SparseConfig {

    56     // Line-separated

    57     includes: Vec<u8>,

    58     // Line-separated

    59     excludes: Vec<u8>,

    60     profiles: HashSet<Vec<u8>>,

    61     warnings: Vec<SparseWarning>,

    62 }

    63 

    64 /// All possible errors when reading sparse config

    65 #[derive(Debug, derive_more::From)]

    66 pub enum SparseConfigError {

    67     IncludesAfterExcludes {

    68         context: SparseConfigContext,

    69     },

    70     EntryOutsideSection {

    71         context: SparseConfigContext,

    72         line: Vec<u8>,

    73     },

    74     #[from]

    75     HgError(HgError),

    76     #[from]

    77     PatternError(PatternError),

    78 }

    79 

    80 /// Parse sparse config file content.

    81 fn parse_config(

    82     raw: &[u8],

    83     context: SparseConfigContext,

    84 ) -> Result<SparseConfig, SparseConfigError> {

    85     let mut includes = vec![];

    86     let mut excludes = vec![];

    87     let mut profiles = HashSet::new();

    88     let mut warnings = vec![];

    89 

    90     #[derive(PartialEq, Eq)]

    91     enum Current {

    92         Includes,

    93         Excludes,

    94         None,

    95     };

    96 

    97     let mut current = Current::None;

    98     let mut in_section = false;

    99 

   100     for line in raw.split(|c| *c == b'\n') {

   101         let line = line.trim();

   102         if line.is_empty() || line[0] == b'#' {

   103             // empty or comment line, skip

   104             continue;

   105         }

   106         if line.starts_with(b"%include ") {

   107             let profile = line[b"%include ".len()..].trim();

   108             if !profile.is_empty() {

   109                 profiles.insert(profile.into());

   110             }

   111         } else if line == b"[include]" {

   112             if in_section && current == Current::Includes {

   113                 return Err(SparseConfigError::IncludesAfterExcludes {

   114                     context,

   115                 });

   116             }

   117             in_section = true;

   118             current = Current::Includes;

   119             continue;

   120         } else if line == b"[exclude]" {

   121             in_section = true;

   122             current = Current::Excludes;

   123         } else {

   124             if current == Current::None {

   125                 return Err(SparseConfigError::EntryOutsideSection {

   126                     context,

   127                     line: line.into(),

   128                 });

   129             }

   130             if line.trim().starts_with(b"/") {

   131                 warnings.push(SparseWarning::RootWarning {

   132                     context,

   133                     line: line.into(),

   134                 });

   135                 continue;

   136             }

   137             match current {

   138                 Current::Includes => {

   139                     includes.push(b'\n');

   140                     includes.extend(line.iter());

   141                 }

   142                 Current::Excludes => {

   143                     excludes.push(b'\n');

   144                     excludes.extend(line.iter());

   145                 }

   146                 Current::None => unreachable!(),

   147             }

   148         }

   149     }

   150 

   151     Ok(SparseConfig {

   152         includes,

   153         excludes,

   154         profiles,

   155         warnings,

   156     })

   157 }

   158 

   159 fn read_temporary_includes(

   160     repo: &Repo,

   161 ) -> Result<Vec<Vec<u8>>, SparseConfigError> {

   162     let raw = repo.hg_vfs().try_read("tempsparse")?.unwrap_or(vec![]);

   163     if raw.is_empty() {

   164         return Ok(vec![]);

   165     }

   166     Ok(raw.split(|c| *c == b'\n').map(ToOwned::to_owned).collect())

   167 }

   168 

   169 /// Obtain sparse checkout patterns for the given revision

   170 fn patterns_for_rev(

   171     repo: &Repo,

   172     rev: Revision,

   173 ) -> Result<Option<SparseConfig>, SparseConfigError> {

   174     if !repo.has_sparse() {

   175         return Ok(None);

   176     }

   177     let raw = repo.hg_vfs().try_read("sparse")?.unwrap_or(vec![]);

   178 

   179     if raw.is_empty() {

   180         return Ok(None);

   181     }

   182 

   183     let mut config = parse_config(&raw, SparseConfigContext::Sparse)?;

   184 

   185     if !config.profiles.is_empty() {

   186         let mut profiles: Vec<Vec<u8>> = config.profiles.into_iter().collect();

   187         let mut visited = HashSet::new();

   188 

   189         while let Some(profile) = profiles.pop() {

   190             if visited.contains(&profile) {

   191                 continue;

   192             }

   193             visited.insert(profile.to_owned());

   194 

   195             let output =

   196                 cat(repo, &rev.to_string(), vec![HgPath::new(&profile)])

   197                     .map_err(|_| {

   198                         HgError::corrupted(format!(

   199                             "dirstate points to non-existent parent node"

   200                         ))

   201                     })?;

   202             if output.results.is_empty() {

   203                 config.warnings.push(SparseWarning::ProfileNotFound {

   204                     profile: profile.to_owned(),

   205                     rev,

   206                 })

   207             }

   208 

   209             let subconfig = parse_config(

   210                 &output.results[0].1,

   211                 SparseConfigContext::Sparse,

   212             )?;

   213             if !subconfig.includes.is_empty() {

   214                 config.includes.push(b'\n');

   215                 config.includes.extend(&subconfig.includes);

   216             }

   217             if !subconfig.includes.is_empty() {

   218                 config.includes.push(b'\n');

   219                 config.excludes.extend(&subconfig.excludes);

   220             }

   221             config.warnings.extend(subconfig.warnings.into_iter());

   222             profiles.extend(subconfig.profiles.into_iter());

   223         }

   224 

   225         config.profiles = visited;

   226     }

   227 

   228     if !config.includes.is_empty() {

   229         config.includes.extend(b"\n.hg*");

   230     }

   231 

   232     Ok(Some(config))

   233 }

   234 

   235 /// Obtain a matcher for sparse working directories.

   236 pub fn matcher(

   237     repo: &Repo,

   238 ) -> Result<(Box<dyn Matcher + Sync>, Vec<SparseWarning>), SparseConfigError> {

   239     let mut warnings = vec![];

   240     if !repo.requirements().contains(SPARSE_REQUIREMENT) {

   241         return Ok((Box::new(AlwaysMatcher), warnings));

   242     }

   243 

   244     let parents = repo.dirstate_parents()?;

   245     let mut revs = vec![];

   246     let p1_rev =

   247         repo.changelog()?

   248             .rev_from_node(parents.p1.into())

   249             .map_err(|_| {

   250                 HgError::corrupted(format!(

   251                     "dirstate points to non-existent parent node"

   252                 ))

   253             })?;

   254     if p1_rev != NULL_REVISION {

   255         revs.push(p1_rev)

   256     }

   257     let p2_rev =

   258         repo.changelog()?

   259             .rev_from_node(parents.p2.into())

   260             .map_err(|_| {

   261                 HgError::corrupted(format!(

   262                     "dirstate points to non-existent parent node"

   263                 ))

   264             })?;

   265     if p2_rev != NULL_REVISION {

   266         revs.push(p2_rev)

   267     }

   268     let mut matchers = vec![];

   269 

   270     for rev in revs.iter() {

   271         let config = patterns_for_rev(repo, *rev);

   272         if let Ok(Some(config)) = config {

   273             warnings.extend(config.warnings);

   274             let mut m: Box<dyn Matcher + Sync> = Box::new(AlwaysMatcher);

   275             if !config.includes.is_empty() {

   276                 let (patterns, subwarnings) = parse_pattern_file_contents(

   277                     &config.includes,

   278                     Path::new(""),

   279                     Some(b"relglob:".as_ref()),

   280                     false,

   281                 )?;

   282                 warnings.extend(subwarnings.into_iter().map(From::from));

   283                 m = Box::new(IncludeMatcher::new(patterns)?);

   284             }

   285             if !config.excludes.is_empty() {

   286                 let (patterns, subwarnings) = parse_pattern_file_contents(

   287                     &config.excludes,

   288                     Path::new(""),

   289                     Some(b"relglob:".as_ref()),

   290                     false,

   291                 )?;

   292                 warnings.extend(subwarnings.into_iter().map(From::from));

   293                 m = Box::new(DifferenceMatcher::new(

   294                     m,

   295                     Box::new(IncludeMatcher::new(patterns)?),

   296                 ));

   297             }

   298             matchers.push(m);

   299         }

   300     }

   301     let result: Box<dyn Matcher + Sync> = match matchers.len() {

   302         0 => Box::new(AlwaysMatcher),

   303         1 => matchers.pop().expect("1 is equal to 0"),

   304         _ => Box::new(UnionMatcher::new(matchers)),

   305     };

   306 

   307     let matcher =

   308         force_include_matcher(result, &read_temporary_includes(repo)?)?;

   309     Ok((matcher, warnings))

   310 }

   311 

   312 /// Returns a matcher that returns true for any of the forced includes before

   313 /// testing against the actual matcher

   314 fn force_include_matcher(

   315     result: Box<dyn Matcher + Sync>,

   316     temp_includes: &[Vec<u8>],

   317 ) -> Result<Box<dyn Matcher + Sync>, PatternError> {

   318     if temp_includes.is_empty() {

   319         return Ok(result);

   320     }

   321     let forced_include_matcher = IncludeMatcher::new(

   322         temp_includes

   323             .into_iter()

   324             .map(|include| {

   325                 IgnorePattern::new(PatternSyntax::Path, include, Path::new(""))

   326             })

   327             .collect(),

   328     )?;

   329     Ok(Box::new(UnionMatcher::new(vec![

   330         Box::new(forced_include_matcher),

   331         result,

   332     ])))

   333 }