added support for comma separated points in R

Heliozoa · Heliozoa · commit 1ecb35fd03cc · 2021-05-04T17:19:55.000+03:00
diff --git a/plugins/csharp/src/plugin.rs b/plugins/csharp/src/plugin.rs
@@ -340,7 +340,7 @@ impl LanguagePlugin for CSharpPlugin {
         vec![PathBuf::from("test")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
         combinator::map(
             sequence::delimited(
                 sequence::tuple((
@@ -363,6 +363,7 @@ impl LanguagePlugin for CSharpPlugin {
             ),
             str::trim,
         )(i)
+        .map(|(a, b)| (a, vec![b]))
     }
 }
 
@@ -679,14 +680,13 @@ mod test {
         assert!(res.is_err());
 
         let res = CSharpPlugin::points_parser("@Points(\"1\")").unwrap();
-        assert_eq!(res.1, "1");
+        assert_eq!(res.1[0], "1");
 
         let res = CSharpPlugin::points_parser("@  pOiNtS  (  \"  1  \"  )  ").unwrap();
-        assert_eq!(res.1, "1");
+        assert_eq!(res.1[0], "1");
     }
 
     #[test]
-    // #[ignore = "requires newer version of C# runner that always includes all points in the tests"]
     fn doesnt_give_points_unless_all_relevant_exercises_pass() {
         init();
 
diff --git a/plugins/java/src/ant_plugin.rs b/plugins/java/src/ant_plugin.rs
@@ -116,8 +116,8 @@ impl LanguagePlugin for AntPlugin {
         Ok(())
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-        Self::java_points_parser(i)
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
     }
 
     fn get_default_student_file_paths() -> Vec<PathBuf> {
diff --git a/plugins/java/src/java_plugin.rs b/plugins/java/src/java_plugin.rs
@@ -360,8 +360,8 @@ mod test {
             unimplemented!()
         }
 
-        fn points_parser(i: &str) -> IResult<&str, &str, nom::error::VerboseError<&str>> {
-            Self::java_points_parser(i)
+        fn points_parser(i: &str) -> IResult<&str, Vec<&str>, nom::error::VerboseError<&str>> {
+            Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
         }
     }
 
diff --git a/plugins/java/src/maven_plugin.rs b/plugins/java/src/maven_plugin.rs
@@ -123,8 +123,8 @@ impl LanguagePlugin for MavenPlugin {
         vec![PathBuf::from("src/test")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-        Self::java_points_parser(i)
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
     }
 }
 
diff --git a/plugins/make/src/plugin.rs b/plugins/make/src/plugin.rs
@@ -337,8 +337,8 @@ impl LanguagePlugin for MakePlugin {
         vec![PathBuf::from("test")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-        fn tmc_register_test_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        fn tmc_register_test_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
             sequence::delimited(
                 sequence::tuple((
                     bytes::complete::tag("tmc_register_test"),
@@ -354,6 +354,7 @@ impl LanguagePlugin for MakePlugin {
                     character::complete::char(')'),
                 )),
             )(i)
+            .map(|(a, b)| (a, vec![b]))
         }
 
         // todo: currently cannot handle function calls with multiple parameters, probably not a problem
@@ -613,7 +614,7 @@ test [invalid] point6
                 "tmc_register_test(s, test_insertion_empty_list, \"dlink_insert\");",
             )
             .unwrap()
-            .1,
+            .1[0],
             "dlink_insert"
         );
     }
diff --git a/plugins/notests/src/plugin.rs b/plugins/notests/src/plugin.rs
@@ -95,9 +95,10 @@ impl LanguagePlugin for NoTestsPlugin {
         vec![PathBuf::from("test")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
         // does not match any characters
         nom::combinator::value("", nom::character::complete::one_of(""))(i)
+            .map(|(a, b)| (a, vec![b]))
     }
 }
 
diff --git a/plugins/python3/src/plugin.rs b/plugins/python3/src/plugin.rs
@@ -378,7 +378,7 @@ impl LanguagePlugin for Python3Plugin {
         vec![PathBuf::from("test"), PathBuf::from("tmc")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
         combinator::map(
             sequence::delimited(
                 sequence::tuple((
@@ -408,6 +408,7 @@ impl LanguagePlugin for Python3Plugin {
             ),
             str::trim,
         )(i)
+        .map(|(a, b)| (a, vec![b]))
     }
 }
 
@@ -722,17 +723,17 @@ class TestErroring(unittest.TestCase):
     #[test]
     fn parses_points() {
         assert_eq!(
-            Python3Plugin::points_parser("@points('p1')").unwrap().1,
+            Python3Plugin::points_parser("@points('p1')").unwrap().1[0],
             "p1"
         );
         assert_eq!(
             Python3Plugin::points_parser("@  pOiNtS  (  '  p2  '  )  ")
                 .unwrap()
-                .1,
+                .1[0],
             "p2"
         );
         assert_eq!(
-            Python3Plugin::points_parser(r#"@points("p3")"#).unwrap().1,
+            Python3Plugin::points_parser(r#"@points("p3")"#).unwrap().1[0],
             "p3"
         );
         assert!(Python3Plugin::points_parser(r#"@points("p3')"#).is_err());
diff --git a/plugins/r/src/plugin.rs b/plugins/r/src/plugin.rs
@@ -9,7 +9,7 @@ use std::io::{Read, Seek};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tmc_langs_framework::{
-    nom::{branch, bytes, character, combinator, error::VerboseError, sequence, IResult},
+    nom::{branch, bytes, character, combinator, error::VerboseError, multi, sequence, IResult},
     LanguagePlugin, TmcCommand, TmcError, {ExerciseDesc, RunResult, TestDesc},
 };
 use tmc_langs_util::file_util;
@@ -142,46 +142,73 @@ impl LanguagePlugin for RPlugin {
         vec![PathBuf::from("tests")]
     }
 
-    fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-        let test_parser = sequence::delimited(
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        let mut test_parser = sequence::preceded(
             sequence::tuple((
                 bytes::complete::tag("test"),
                 character::complete::multispace0,
                 character::complete::char('('),
-                bytes::complete::take_until(","),
-                bytes::complete::take_until("\""),
-            )),
-            sequence::delimited(
-                character::complete::char('"'),
-                bytes::complete::is_not("\""),
-                character::complete::char('"'),
-            ),
-            sequence::tuple((
                 character::complete::multispace0,
-                character::complete::char(')'),
+                arg_parser,
             )),
+            c_parser,
         );
-        let points_for_all_tests_parser = sequence::delimited(
+        let points_for_all_tests_parser = sequence::preceded(
             sequence::tuple((
                 bytes::complete::tag("points_for_all_tests"),
                 character::complete::multispace0,
                 character::complete::char('('),
-                bytes::complete::take_until("\""),
-            )),
-            sequence::delimited(
-                character::complete::char('"'),
-                bytes::complete::is_not("\""),
-                character::complete::char('"'),
-            ),
-            sequence::tuple((
                 character::complete::multispace0,
-                character::complete::char(')'),
             )),
+            c_parser,
         );
-        combinator::map(
-            branch::alt((test_parser, points_for_all_tests_parser)),
-            str::trim,
-        )(i)
+
+        // todo: currently cannot handle function calls with multiple parameters, probably not a problem
+        fn arg_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+            combinator::value(
+                "",
+                sequence::tuple((
+                    bytes::complete::take_till(|c: char| c == ','),
+                    character::complete::char(','),
+                    character::complete::multispace0,
+                )),
+            )(i)
+        }
+
+        fn c_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+            combinator::map(
+                sequence::tuple((
+                    character::complete::char('c'),
+                    character::complete::multispace0,
+                    character::complete::char('('),
+                    character::complete::multispace0,
+                    multi::separated_list1(
+                        sequence::tuple((
+                            character::complete::multispace0,
+                            character::complete::char(','),
+                            character::complete::multispace0,
+                        )),
+                        string_parser,
+                    ),
+                    character::complete::multispace0,
+                    character::complete::char(')'),
+                )),
+                |t| t.4,
+            )(i)
+        }
+
+        fn string_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+            combinator::map(
+                sequence::tuple((
+                    character::complete::char('"'),
+                    bytes::complete::is_not("\""),
+                    character::complete::char('"'),
+                )),
+                |r| str::trim(r.1),
+            )(i)
+        }
+
+        branch::alt((test_parser, points_for_all_tests_parser))(i)
     }
 }
 
@@ -466,14 +493,14 @@ test("sample", c("r1.1"), {
   expect_true(areEqual(res, res_correct))
 })
 "#;
-        assert_eq!(RPlugin::points_parser(target).unwrap().1, "W1A.1.2");
+        assert_eq!(RPlugin::points_parser(target).unwrap().1[0], "W1A.1.2");
 
         let target = r#"test  (  "1d and 1e are solved correctly", c  (  "  W1A.1.2  "  )  , {
   expect_equivalent(z, z_correct, tolerance=1e-5)
   expect_true(areEqual(res, res_correct))
 })
 "#;
-        assert_eq!(RPlugin::points_parser(target).unwrap().1, "W1A.1.2");
+        assert_eq!(RPlugin::points_parser(target).unwrap().1[0], "W1A.1.2");
     }
 
     #[test]
@@ -510,4 +537,23 @@ etc
         let points = RPlugin::get_available_points(temp.path()).unwrap();
         assert_eq!(points, &["r1"]);
     }
+
+    #[test]
+    fn parses_multiple_points() {
+        init();
+
+        let temp = tempfile::tempdir().unwrap();
+        file_to(
+            &temp,
+            "tests/testthat/testExercise.R",
+            r#"
+something
+test("some test", c("r1", "r2", "r3"))
+etc
+"#,
+        );
+
+        let points = RPlugin::get_available_points(temp.path()).unwrap();
+        assert_eq!(points, &["r1", "r2", "r3"]);
+    }
 }
diff --git a/tmc-langs-framework/src/plugin.rs b/tmc-langs-framework/src/plugin.rs
@@ -407,7 +407,7 @@ pub trait LanguagePlugin {
 
     fn get_default_exercise_file_paths() -> Vec<PathBuf>;
 
-    /// Parses exercise files using Self::LINE_COMMENT and Self::BLOCK_COMMENt to filter out comments and Self::points_parser to parse points from the actual code.
+    /// Parses exercise files using Self::LINE_COMMENT and Self::BLOCK_COMMENT to filter out comments and Self::points_parser to parse points from the actual code.
     fn get_available_points(exercise_path: &Path) -> Result<Vec<String>, TmcError> {
         let config = TmcProjectYml::load_or_default(exercise_path)?;
         let config = Self::get_exercise_packaging_configuration(config)?;
@@ -458,8 +458,9 @@ pub trait LanguagePlugin {
                         };
 
                     // reads a points annotation
-                    let points_parser =
-                        combinator::map(Self::points_parser, |p| Parse::Points(p.to_string()));
+                    let points_parser = combinator::map(Self::points_parser, |p| {
+                        Parse::Points(p.into_iter().map(|s| s.to_string()).collect())
+                    });
 
                     // try to apply the interesting parsers, else read a character with the etc parser. repeat until the input ends
                     let mut parser = multi::many0(branch::alt((
@@ -474,10 +475,12 @@ pub trait LanguagePlugin {
                         Ok((_, parsed)) => {
                             for parse in parsed {
                                 if let Parse::Points(parsed) = parse {
-                                    // a single points annotation can contain multiple whitespace separated points
-                                    let split_points =
-                                        parsed.split_whitespace().map(str::to_string);
-                                    points.extend(split_points);
+                                    for point in parsed {
+                                        // a single points annotation can contain multiple whitespace separated points
+                                        let split_points =
+                                            point.split_whitespace().map(str::to_string);
+                                        points.extend(split_points);
+                                    }
                                 }
                             }
                         }
@@ -501,17 +504,17 @@ pub trait LanguagePlugin {
         Ok(points)
     }
 
-    /// A nom parser that recognizes a points annotation and returns the inner points value.
+    /// A nom parser that recognizes a points annotation and returns the inner points value(s).
     ///
     /// For example implementations, see the existing language plugins.
-    fn points_parser(i: &str) -> IResult<&str, &str, nom::error::VerboseError<&str>>;
+    fn points_parser(i: &str) -> IResult<&str, Vec<&str>, nom::error::VerboseError<&str>>;
 }
 
 #[derive(Debug, Clone)]
 enum Parse {
     LineComment,
     BlockComment,
-    Points(String),
+    Points(Vec<String>),
     Other,
 }
 
@@ -634,7 +637,7 @@ mod test {
             Ok(())
         }
 
-        fn points_parser(i: &str) -> IResult<&str, &str, nom::error::VerboseError<&str>> {
+        fn points_parser(i: &str) -> IResult<&str, Vec<&str>, nom::error::VerboseError<&str>> {
             combinator::map(
                 sequence::delimited(
                     sequence::tuple((
@@ -662,7 +665,7 @@ mod test {
                         character::complete::char(')'),
                     )),
                 ),
-                str::trim,
+                |s: &str| vec![s.trim()],
             )(i)
         }
 

Original file line number	Diff line number	Diff line change
`@@ -116,8 +116,8 @@ impl LanguagePlugin for AntPlugin {`
`116`	`116`	`Ok(())`
`117`	`117`	`}`
`118`	`118`
`119`		`- fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {`
`120`		`- Self::java_points_parser(i)`
	`119`	`+ fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
	`120`	`+ Self::java_points_parser(i).map(\|(a, b)\| (a, vec![b]))`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`fn get_default_student_file_paths() -> Vec<PathBuf> {`
Original file line number	Diff line number	Diff line change
`@@ -360,8 +360,8 @@ mod test {`
`360`	`360`	`unimplemented!()`
`361`	`361`	`}`
`362`	`362`
`363`		`- fn points_parser(i: &str) -> IResult<&str, &str, nom::error::VerboseError<&str>> {`
`364`		`- Self::java_points_parser(i)`
	`363`	`+ fn points_parser(i: &str) -> IResult<&str, Vec<&str>, nom::error::VerboseError<&str>> {`
	`364`	`+ Self::java_points_parser(i).map(\|(a, b)\| (a, vec![b]))`
`365`	`365`	`}`
`366`	`366`	`}`
`367`	`367`
Original file line number	Diff line number	Diff line change
`@@ -123,8 +123,8 @@ impl LanguagePlugin for MavenPlugin {`
`123`	`123`	`vec![PathBuf::from("src/test")]`
`124`	`124`	`}`
`125`	`125`
`126`		`- fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {`
`127`		`- Self::java_points_parser(i)`
	`126`	`+ fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
	`127`	`+ Self::java_points_parser(i).map(\|(a, b)\| (a, vec![b]))`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -337,8 +337,8 @@ impl LanguagePlugin for MakePlugin {`
`337`	`337`	`vec![PathBuf::from("test")]`
`338`	`338`	`}`
`339`	`339`
`340`		`- fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {`
`341`		`- fn tmc_register_test_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {`
	`340`	`+ fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
	`341`	`+ fn tmc_register_test_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
`342`	`342`	`sequence::delimited(`
`343`	`343`	`sequence::tuple((`
`344`	`344`	`bytes::complete::tag("tmc_register_test"),`
`@@ -354,6 +354,7 @@ impl LanguagePlugin for MakePlugin {`
`354`	`354`	`character::complete::char(')'),`
`355`	`355`	`)),`
`356`	`356`	`)(i)`
	`357`	`+ .map(\|(a, b)\| (a, vec![b]))`
`357`	`358`	`}`
`358`	`359`
`359`	`360`	`// todo: currently cannot handle function calls with multiple parameters, probably not a problem`
`@@ -613,7 +614,7 @@ test [invalid] point6`
`613`	`614`	`"tmc_register_test(s, test_insertion_empty_list, \"dlink_insert\");",`
`614`	`615`	`)`
`615`	`616`	`.unwrap()`
`616`		`- .1,`
	`617`	`+ .1[0],`
`617`	`618`	`"dlink_insert"`
`618`	`619`	`);`
`619`	`620`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,9 +95,10 @@ impl LanguagePlugin for NoTestsPlugin {`
`95`	`95`	`vec![PathBuf::from("test")]`
`96`	`96`	`}`
`97`	`97`
`98`		`- fn points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {`
	`98`	`+ fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
`99`	`99`	`// does not match any characters`
`100`	`100`	`nom::combinator::value("", nom::character::complete::one_of(""))(i)`
	`101`	`+ .map(\|(a, b)\| (a, vec![b]))`
`101`	`102`	`}`
`102`	`103`	`}`
`103`	`104`