[make] fix tests

Author: Wandalen

make/src/main.rs

@@ -149,7 +149,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         print,
         precious: false,
         terminate,
-        rules: Default::default(),
+        ..Default::default()
     };
 
     if clear {

make/src/parser/parse.rs

@@ -36,7 +36,7 @@ impl From<std::io::Error> for Error {
 impl std::error::Error for Error {}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParseError(Vec<String>);
+pub struct ParseError(pub Vec<String>);
 
 impl std::fmt::Display for ParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -90,7 +90,20 @@ pub struct Parse {
     pub errors: Vec<String>,
 }
 
-pub fn parse(text: &str) -> Result<GreenNode, ParseError> {
+#[derive(Clone)]
+pub struct Parsed(GreenNode);
+
+impl Parsed {
+    pub fn syntax(&self) -> SyntaxNode {
+        SyntaxNode::new_root(self.0.clone())
+    }
+
+    pub fn root(&self) -> Makefile {
+        Makefile::cast(self.syntax()).unwrap()
+    }
+}
+
+pub fn parse(text: &str) -> Result<Parsed, ParseError> {
     struct Parser {
         /// input tokens, including whitespace,
         /// in *reverse* order.
@@ -274,7 +287,7 @@ pub fn parse(text: &str) -> Result<GreenNode, ParseError> {
     if !result.errors.is_empty() {
         Err(ParseError(result.errors))
     } else {
-        Ok(result.green_node)
+        Ok(Parsed(result.green_node))
     }
 }
 
@@ -383,7 +396,7 @@ impl Makefile {
         r.read_to_string(&mut buf)?;
 
         let parsed = parse(&buf)?;
-        Ok(Makefile::cast(SyntaxNode::new_root(parsed)).unwrap())
+        Ok(parsed.root())
     }
 
     pub fn rules(&self) -> impl Iterator<Item = Rule> {
@@ -518,6 +531,6 @@ impl FromStr for Makefile {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let processed = preprocess(s).map_err(|e| ParseError(vec![e.to_string()]))?;
-        parse(&processed).map(|node| Makefile::cast(SyntaxNode::new_root(node)).unwrap())
+        parse(&processed).map(|node| node.root())
     }
 }

make/src/rule.rs

@@ -147,9 +147,9 @@ impl Rule {
                     // -q flag
                     if quit {
                         if up_to_date {
-                            return Ok(());
+                            process::exit(0);
                         } else {
-                            return Err(NotUpToDateError { target: target.to_string() });
+                            process::exit(1);
                         }
                     }
                 }

make/tests/integration.rs

@@ -233,7 +233,7 @@ mod arguments {
         run_test_helper(
             &["-kf", "tests/makefiles/arguments/dash_k.mk"],
             "OK\necho 12\n12\n",
-            "make: ExecutionError { exit_code: Some(1) }\nmake: Target z not remade because of errors\n",
+            "make: execution error: 1\nmake: Target z not remade because of errors\n",
             2,
         );
     }
@@ -342,16 +342,16 @@ mod macros {
 mod target_behavior {
     use libc::{kill, SIGINT};
     use std::{thread, time::Duration};
-
+    use posixutils_make::parser::parse::ParseError;
     use super::*;
 
     #[test]
     fn no_targets() {
         run_test_helper(
             &["-f", "tests/makefiles/target_behavior/no_targets.mk"],
             "",
-            "make: no targets to execute\n",
-            ErrorCode::NoTarget { target: None }.into(),
+            "make: parse error:  *** No targets. Stop.\n\n",
+            ErrorCode::ParserError { constraint: ParseError(vec![]) }.into(),
         );
     }
 

make/tests/parser.rs

@@ -275,9 +275,9 @@ rule: dependency
             panic!("Must be preprocessed without an error")
         };
         let parsed = parse(&processed);
-        println!("{:#?}", parsed.syntax());
-        assert_eq!(parsed.errors, Vec::<String>::new());
-        let node = parsed.syntax();
+        println!("{:#?}", parsed.clone().unwrap().syntax());
+        assert_eq!(parsed.clone().err(), None);
+        let node = parsed.clone().unwrap().syntax();
         assert_eq!(
             format!("{:#?}", node),
             r#"ROOT@0..38
@@ -301,7 +301,7 @@ rule: dependency
 "#
         );
 
-        let root = parsed.root().clone_for_update();
+        let root = parsed.unwrap().root().clone_for_update();
 
         let mut rules = root.rules().collect::<Vec<_>>();
         assert_eq!(rules.len(), 1);
@@ -322,16 +322,16 @@ rule: dependency
             panic!("Must be preprocessed without an error")
         };
         let parsed = parse(&processed);
-        assert_eq!(parsed.errors, vec![" *** No targets. Stop."]);
-        let node = parsed.syntax();
+        assert!(parsed.clone().err().is_some());
+        let node = parsed.clone().unwrap().syntax();
         assert_eq!(
             format!("{:#?}", node),
             r#"ROOT@0..0
   ERROR@0..0
 "#
         );
 
-        let root = parsed.root().clone_for_update();
+        let root = parsed.unwrap().root().clone_for_update();
 
         let mut variables = root.variable_definitions().collect::<Vec<_>>();
         assert_eq!(variables.len(), 0);
@@ -375,8 +375,8 @@ rule: dependency
 
 "#;
         let parsed = parse(MULTIPLE_PREREQUISITES);
-        assert_eq!(parsed.errors, Vec::<String>::new());
-        let node = parsed.syntax();
+        assert_eq!(parsed.clone().err(), None);
+        let node = parsed.clone().unwrap().syntax();
         assert_eq!(
             format!("{:#?}", node),
             r#"ROOT@0..40
@@ -396,7 +396,7 @@ rule: dependency
     NEWLINE@39..40 "\n"
 "#
         );
-        let root = parsed.root().clone_for_update();
+        let root = parsed.unwrap().root().clone_for_update();
 
         let rule = root.rules().next().unwrap();
         assert_eq!(rule.targets().collect::<Vec<_>>(), vec!["rule"]);