Initial prototype of branch support.

Author: LawnGnome

Cargo.toml

@@ -12,6 +12,7 @@ tokio-test = "0.4.2"
 
 [dependencies]
 anyhow = "1.0.45"
+async-recursion = "0.3.2"
 comma-v = { path = "comma-v" }
 flexi_logger = { version = "0.19.6", features = ["async", "colors"] }
 flume = "0.10.9"

comma-v/Cargo.toml

@@ -10,6 +10,7 @@ license = "Apache-2.0"
 chrono = "0.4.19"
 derive_more = "0.99.16"
 eq-macro = { path = "../eq-macro" }
+itertools = "0.10.1"
 nom = "7.1.0"
 thiserror = "1.0.30"
 

comma-v/examples/extract-script.rs

@@ -2,6 +2,7 @@ use std::{
     fs,
     io::{self, Write},
     path::PathBuf,
+    str::FromStr,
 };
 
 use comma_v::Num;
@@ -19,9 +20,8 @@ struct Opt {
 fn main() -> anyhow::Result<()> {
     let opt = Opt::from_args();
 
-    let revision: Vec<u8> = opt.revision.as_bytes().to_vec();
     let file = comma_v::parse(&fs::read(&opt.file)?)?;
-    match file.delta_text.get(&Num::from(revision)) {
+    match file.delta_text.get(&Num::from_str(&opt.revision)?) {
         Some(dt) => {
             io::stdout().write_all(&dt.text.0)?;
         }

comma-v/src/error.rs

@@ -0,0 +1,19 @@
+use std::{num::ParseIntError, str::Utf8Error};
+
+use nom::error::ErrorKind;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("not a branch")]
+    NotBranch,
+
+    #[error("parse error of kind {kind:?} at location {location:?}")]
+    ParseError { location: Vec<u8>, kind: ErrorKind },
+
+    #[error(transparent)]
+    ParseInt(#[from] ParseIntError),
+
+    #[error(transparent)]
+    ParseUtf8(#[from] Utf8Error),
+}

comma-v/src/lib.rs

@@ -1,15 +1,13 @@
-use nom::{error::ErrorKind, Finish};
-use thiserror::Error;
+use nom::Finish;
 
+mod error;
+mod num;
 mod parser;
 mod types;
-pub use types::*;
 
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("parse error of kind {kind:?} at location {location:?}")]
-    ParseError { location: Vec<u8>, kind: ErrorKind },
-}
+pub use error::Error;
+pub use num::Num;
+pub use types::*;
 
 /// Parses a full RCS file.
 pub fn parse(input: &[u8]) -> Result<File, Error> {

comma-v/src/num.rs

@@ -0,0 +1,185 @@
+use std::{convert::TryFrom, fmt::Display, num::ParseIntError, str::FromStr};
+
+use itertools::Itertools;
+
+use crate::Error;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Num {
+    Branch(Vec<u64>),
+    Commit(Vec<u64>),
+}
+
+impl Num {
+    pub fn contains(&self, other: &Num) -> Result<bool, Error> {
+        if let Num::Branch(branch) = self {
+            if let Num::Commit(other) = other {
+                // for (prefix, max) in prefixes.iter() {
+                //     if other.len() < prefix.len() {
+                //         // This means that we're looking at a commit from before
+                //         // this branch was branched, but since we know the
+                //         // previous checks passed, that means the commit must be
+                //         // part of this branch.
+                //         return Ok(true);
+                //     }
+                //     if &other[0..prefix.len()] != prefix.as_slice() {
+                //         return Ok(false);
+                //     }
+                //     if let Some(max) = max {
+                //         if other[prefix.len()] > *max {
+                //             return Ok(false);
+                //         }
+                //     }
+                // }
+
+                // return Ok(true);
+
+                if other.len() > (branch.len() + 1) {
+                    // Commit is deeper, and therefore cannot be on this branch.
+                    return Ok(false);
+                }
+
+                // Check intermediate branches.
+                for i in (0..branch.len() - 1).step_by(2) {
+                    if let Some(other_branch) = other.get(i) {
+                        if *other_branch != branch[i] {
+                            // The branch number doesn't match.
+                            return Ok(false);
+                        }
+                        if let Some(rev) = other.get(i + 1) {
+                            if *rev > branch[i + 1] {
+                                // The revision on the commit branch is after
+                                // the branch we're comparing against.
+                                return Ok(false);
+                            }
+                        } else {
+                            // This would imply the commit isn't really a
+                            // commit, since it has an odd number of entries,
+                            // and there's nothing sensible to be done.
+                            return Err(Error::NotBranch);
+                        }
+                    } else {
+                        // We're done; previous branches matched, and the
+                        // revision isn't as deep.
+                        return Ok(true);
+                    }
+                }
+
+                // Check the leaf branch.
+                if let Some(other_branch) = other.get(branch.len() - 1) {
+                    if *other_branch != branch[branch.len() - 1] {
+                        return Ok(false);
+                    }
+                }
+
+                return Ok(true);
+            }
+        }
+
+        Err(Error::NotBranch)
+    }
+
+    pub fn to_branch(&self) -> Self {
+        match self {
+            Num::Branch(_) => self.clone(),
+            Num::Commit(parts) => Num::Branch(parts[0..parts.len() - 1].to_vec()),
+        }
+    }
+}
+
+impl TryFrom<&[u8]> for Num {
+    type Error = Error;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        Self::from_str(std::str::from_utf8(value)?)
+    }
+}
+
+impl FromStr for Num {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s
+            .split('.')
+            .filter_map(|part| match part.parse::<u64>() {
+                // We want to strip out 0 components, as they indicate magic
+                // revisions in CVS that we don't need direct knowledge of in
+                // the importer.
+                Ok(v) if v == 0 => None,
+                Ok(v) => Some(Ok(v)),
+                Err(e) => Some(Err(e)),
+            })
+            .collect::<Result<Vec<u64>, ParseIntError>>()
+        {
+            Ok(parts) if parts.len() % 2 == 0 => Ok(Self::Commit(parts)),
+            Ok(parts) => Ok(Self::Branch(parts)),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+impl Display for Num {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Branch(parts) => fmt_u64_slice(f, parts.as_slice()),
+            Self::Commit(parts) => fmt_u64_slice(f, parts.as_slice()),
+        }
+    }
+}
+
+#[allow(unstable_name_collisions)]
+fn fmt_u64_slice(f: &mut std::fmt::Formatter, input: &[u64]) -> std::fmt::Result {
+    write!(
+        f,
+        "{}",
+        input
+            .iter()
+            .map(|part| part.to_string())
+            .intersperse(String::from("."))
+            .collect::<String>()
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_num_contains() {
+        // Contained because it's on this specific branch.
+        assert!(num("1.1.2").contains(&num("1.1.2.1")).unwrap());
+        assert!(num("1.1.2").contains(&num("1.1.2.2")).unwrap());
+
+        // Contained because it's an ancestor of this branch.
+        assert!(num("1.1.2").contains(&num("1.1")).unwrap());
+
+        // Not contained because it's on a different branch.
+        assert!(!num("1.1.2").contains(&num("1.1.3.1")).unwrap());
+
+        // Not contained because it's only on a descendant branch.
+        assert!(!num("1.1.2").contains(&num("1.1.2.1.1.1")).unwrap());
+
+        // Not contained because it's after the branch was made.
+        assert!(!num("1.1.2").contains(&num("1.2")).unwrap());
+    }
+
+    #[test]
+    fn test_num_parse() {
+        assert_eq!(Num::from_str("1.1").unwrap(), Num::Commit(vec![1, 1]));
+        assert_eq!(
+            Num::from_str("1.2.3.4").unwrap(),
+            Num::Commit(vec![1, 2, 3, 4])
+        );
+
+        assert_eq!(Num::from_str("1.2.3").unwrap(), Num::Branch(vec![1, 2, 3]),);
+
+        assert_eq!(
+            Num::from_str("1.2.0.3").unwrap(),
+            Num::Branch(vec![1, 2, 3])
+        );
+    }
+
+    fn num(s: &str) -> Num {
+        Num::from_str(s).unwrap()
+    }
+}

comma-v/src/parser/mod.rs

@@ -10,7 +10,7 @@ use nom::{
     IResult,
 };
 
-use crate::types;
+use crate::{num, types};
 
 mod char;
 
@@ -121,7 +121,7 @@ fn admin(input: &[u8]) -> IResult<&[u8], types::Admin> {
     )(input)
 }
 
-fn delta(input: &[u8]) -> IResult<&[u8], (types::Num, types::Delta)> {
+fn delta(input: &[u8]) -> IResult<&[u8], (num::Num, types::Delta)> {
     map(
         tuple((
             terminated(num, multispace1),
@@ -174,7 +174,7 @@ fn delta(input: &[u8]) -> IResult<&[u8], (types::Num, types::Delta)> {
     )(input)
 }
 
-fn delta_text(input: &[u8]) -> IResult<&[u8], (types::Num, types::DeltaText)> {
+fn delta_text(input: &[u8]) -> IResult<&[u8], (num::Num, types::DeltaText)> {
     map(
         tuple((
             num,
@@ -193,16 +193,18 @@ fn desc(input: &[u8]) -> IResult<&[u8], types::Desc> {
 
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
     use chrono::DateTime;
 
-    use crate::types::Num;
+    use crate::num::Num;
 
     use super::*;
 
     #[test]
     fn test_admin() {
         let have = admin(include_bytes!("fixtures/admin/input")).unwrap().1;
-        assert_eq!(*have.head.unwrap(), b"1.1");
+        assert_eq!(have.head.unwrap().to_string(), "1.1");
         assert!(have.branch.is_none());
         assert_eq!(have.access.len(), 0);
         assert_eq!(have.symbols.len(), 0);
@@ -216,7 +218,7 @@ mod tests {
     #[test]
     fn test_delta() {
         let (num, have) = delta(include_bytes!("fixtures/delta/input")).unwrap().1;
-        assert_eq!(*num, b"1.2");
+        assert_eq!(num.to_string(), "1.2");
         assert_eq!(
             have.date,
             DateTime::parse_from_rfc3339("2021-08-20T17:34:26+00:00")
@@ -228,11 +230,11 @@ mod tests {
         assert_eq!(
             have.branches,
             vec![
-                Num::from(b"1.2.2.1".to_vec()),
-                Num::from(b"1.2.4.1".to_vec())
+                Num::from_str("1.2.2.1").unwrap(),
+                Num::from_str("1.2.4.1").unwrap()
             ]
         );
-        assert_eq!(*have.next.unwrap(), b"1.1");
+        assert_eq!(have.next.unwrap().to_string(), "1.1");
         assert!(have.commit_id.is_none());
     }
 
@@ -241,12 +243,12 @@ mod tests {
         let (num, have) = delta_text(include_bytes!("fixtures/delta_text/input"))
             .unwrap()
             .1;
-        assert_eq!(*num, b"1.1");
+        assert_eq!(num.to_string(), "1.1");
         assert_eq!(*have.log, include_bytes!("fixtures/delta_text/log"),);
         assert_eq!(*have.text, include_bytes!("fixtures/delta_text/text"),);
 
         let (num, have) = delta_text(b"1.2 log @@ text @@").unwrap().1;
-        assert_eq!(*num, b"1.2");
+        assert_eq!(num.to_string(), "1.2");
         assert_eq!(*have.log, b"");
         assert_eq!(*have.text, b"");
     }
@@ -263,11 +265,14 @@ mod tests {
         let have = file(include_bytes!("fixtures/file/input")).unwrap().1;
 
         // We'll just spot check.
-        assert_eq!(*have.admin.head.unwrap(), b"1.4");
+        assert_eq!(have.admin.head.unwrap().to_string(), "1.4");
 
         assert_eq!(have.delta.len(), 4);
         assert_eq!(
-            have.delta.get(&types::Num(b"1.4".to_vec())).unwrap().date,
+            have.delta
+                .get(&num::Num::from_str("1.4").unwrap())
+                .unwrap()
+                .date,
             DateTime::parse_from_rfc3339("2021-08-11T19:08:27+00:00")
                 .unwrap()
                 .into(),
@@ -279,7 +284,7 @@ mod tests {
         assert_eq!(
             *have
                 .delta_text
-                .get(&types::Num(b"1.1".to_vec()))
+                .get(&num::Num::from_str("1.1").unwrap())
                 .unwrap()
                 .text,
             b"d5 3\n"