Refactor link handling to support singlet links and update related tests

konard · konard · commit 4f14418b29a8 · 2025-08-31T13:56:11.000+05:30
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -2,7 +2,7 @@ pub mod parser;
 
 use std::fmt;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum LiNo<T> {
     Link { id: Option<T>, values: Vec<Self> },
     Ref(T),
diff --git a/rust/src/parser.rs b/rust/src/parser.rs
@@ -18,7 +18,7 @@ pub struct Link {
 }
 
 impl Link {
-    pub fn new_point(id: String) -> Self {
+    pub fn new_singlet(id: String) -> Self {
         Link {
             id: Some(id),
             values: vec![],
@@ -75,7 +75,7 @@ impl ParserState {
     }
 
     pub fn check_indentation(&self, indent: usize) -> bool {
-        indent == self.current_indentation()
+        indent >= self.current_indentation()
     }
 }
 
@@ -140,26 +140,12 @@ fn eol(input: &str) -> IResult<&str, &str> {
     )).parse(input)
 }
 
-fn point_link(input: &str) -> IResult<&str, Link> {
-    reference.map(Link::new_point).parse(input)
-}
 
-fn single_line_point_link(input: &str) -> IResult<&str, Link> {
-    preceded(horizontal_whitespace, point_link).parse(input)
-}
-
-fn multi_line_point_link(input: &str) -> IResult<&str, Link> {
-    delimited(
-        (char('('), whitespace),
-        point_link,
-        (whitespace, char(')'))
-    ).parse(input)
-}
 
 fn reference_or_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a str, Link> {
     alt((
         |i| multi_line_any_link(i, state),
-        reference.map(Link::new_point),
+        reference.map(Link::new_singlet),
     )).parse(input)
 }
 
@@ -215,7 +201,13 @@ fn multi_line_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a str,
 
 fn single_line_value_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a str, Link> {
     (|i| single_line_values(i, state))
-        .map(Link::new_value)
+        .map(|values| {
+            if values.len() == 1 && values[0].id.is_some() && values[0].values.is_empty() && values[0].children.is_empty() {
+                Link::new_singlet(values[0].id.clone().unwrap())
+            } else {
+                Link::new_value(values)
+            }
+        })
         .parse(input)
 }
 
@@ -225,13 +217,18 @@ fn multi_line_value_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a
         |i| multi_line_values(i, state),
         whitespace,
         char(')')
-    ).map(|(_, values, _, _)| Link::new_value(values))
+    ).map(|(_, values, _, _)| {
+        if values.len() == 1 && values[0].id.is_some() && values[0].values.is_empty() && values[0].children.is_empty() {
+            Link::new_singlet(values[0].id.clone().unwrap())
+        } else {
+            Link::new_value(values)
+        }
+    })
     .parse(input)
 }
 
 fn multi_line_any_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a str, Link> {
     alt((
-        multi_line_point_link,
         |i| multi_line_value_link(i, state),
         |i| multi_line_link(i, state),
     )).parse(input)
@@ -240,7 +237,6 @@ fn multi_line_any_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a s
 fn single_line_any_link<'a>(input: &'a str, state: &ParserState) -> IResult<&'a str, Link> {
     alt((
         terminated(|i| single_line_link(i, state), eol),
-        terminated(single_line_point_link, eol),
         terminated(|i| single_line_value_link(i, state), eol),
     )).parse(input)
 }
diff --git a/rust/tests/edge_case_parser_tests.rs b/rust/tests/edge_case_parser_tests.rs
@@ -49,10 +49,14 @@ fn test_all_features_test() {
     let result = parse_lino(input);
     assert!(result.is_err());
 
-    // Test point link
-    let input = "(point)";
+    // Test singlet link
+    let input = "(singlet)";
     let result = parse_lino(input);
     assert!(result.is_ok());
+    let parsed = result.unwrap();
+    if let LiNo::Ref(id) = parsed {
+        assert_eq!(id, "singlet");
+    }
 
     // Test value link
     let input = "(value1 value2 value3)";
@@ -119,6 +123,69 @@ fn test_empty_links_test() {
     assert!(result.is_ok());
 }
 
+#[test]
+fn test_singlet_links() {
+    // Test singlet (1)
+    let input = "(1)";
+    let result = parse_lino(input);
+    assert!(result.is_ok());
+    let parsed = result.unwrap();
+    if let LiNo::Ref(id) = parsed {
+        assert_eq!(id, "1");
+    }
+
+    // Test (1 2)
+    let input = "(1 2)";
+    let result = parse_lino(input);
+    assert!(result.is_ok());
+    let parsed = result.unwrap();
+    if let LiNo::Link { id, values } = parsed {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+        if let LiNo::Link { id, values } = &values[0] {
+            assert!(id.is_none());
+            assert_eq!(values.len(), 2);
+            assert_eq!(values[0], LiNo::Ref("1".to_string()));
+            assert_eq!(values[1], LiNo::Ref("2".to_string()));
+        }
+    }
+
+    // Test (1 2 3)
+    let input = "(1 2 3)";
+    let result = parse_lino(input);
+    assert!(result.is_ok());
+    let parsed = result.unwrap();
+    if let LiNo::Link { id, values } = parsed {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+        if let LiNo::Link { id, values } = &values[0] {
+            assert!(id.is_none());
+            assert_eq!(values.len(), 3);
+            assert_eq!(values[0], LiNo::Ref("1".to_string()));
+            assert_eq!(values[1], LiNo::Ref("2".to_string()));
+            assert_eq!(values[2], LiNo::Ref("3".to_string()));
+        }
+    }
+
+    // Test (1 2 3 4)
+    let input = "(1 2 3 4)";
+    let result = parse_lino(input);
+    assert!(result.is_ok());
+    let parsed = result.unwrap();
+    if let LiNo::Link { id, values } = parsed {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+        if let LiNo::Link { id, values } = &values[0] {
+            assert!(id.is_none());
+            assert_eq!(values.len(), 4);
+            assert_eq!(values[0], LiNo::Ref("1".to_string()));
+            assert_eq!(values[1], LiNo::Ref("2".to_string()));
+            assert_eq!(values[2], LiNo::Ref("3".to_string()));
+            assert_eq!(values[3], LiNo::Ref("4".to_string()));
+        }
+    }
+}
+
 #[test]
 fn test_invalid_input() {
     let input = "(invalid";
diff --git a/rust/tests/single_line_parser_tests.rs b/rust/tests/single_line_parser_tests.rs
@@ -118,7 +118,8 @@ fn parse_simple_reference() {
     let input = "test";
     let result = parse_lino(input).unwrap();
     assert!(result.is_link());
-    if let LiNo::Link { values, .. } = &result {
+    if let LiNo::Link { id, values } = &result {
+        assert!(id.is_none());
         assert_eq!(values.len(), 1);
         if let LiNo::Ref(id) = &values[0] {
             assert_eq!(id, "test");
@@ -201,10 +202,17 @@ fn test_link_without_id_multi_line() {
 }
 
 #[test]
-fn test_point_link() {
-    let input = "(point)";
-    let result = parse_lino(input);
-    assert!(result.is_ok());
+fn test_singlet_link() {
+    let input = "(singlet)";
+    let result = parse_lino(input).unwrap();
+    assert!(result.is_link());
+    if let LiNo::Link { id, values } = &result {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+        if let LiNo::Ref(ref_id) = &values[0] {
+            assert_eq!(ref_id, "singlet");
+        }
+    }
 }
 
 #[test]
@@ -284,10 +292,12 @@ fn test_quoted_reference() {
 }
 
 #[test]
-fn test_point_link_parser() {
-    let result = parse_document("(point)").unwrap();
+fn test_singlet_link_parser() {
+    let result = parse_document("(singlet)").unwrap();
     assert_eq!(result.1.len(), 1);
-    assert_eq!(result.1[0].id, Some("point".to_string()));
+    assert_eq!(result.1[0].id, Some("singlet".to_string()));
+    assert_eq!(result.1[0].values.len(), 0);
+    assert_eq!(result.1[0].children.len(), 0);
 }
 
 #[test]
