added support for comma-separated point annotations for other plugins

Heliozoa · Heliozoa · commit 0ba2cd57d01b · 2021-05-10T13:07:56.000+03:00
diff --git a/plugins/csharp/src/plugin.rs b/plugins/csharp/src/plugin.rs
@@ -13,7 +13,7 @@ use tmc_langs_framework::{
     CommandError, ExerciseDesc, Language, LanguagePlugin, RunResult, RunStatus,
     StyleValidationResult, StyleValidationStrategy, TestDesc, TestResult, TmcCommand, TmcError,
 };
-use tmc_langs_util::{file_util, FileError};
+use tmc_langs_util::{file_util, parse_util, FileError};
 use walkdir::WalkDir;
 use zip::ZipArchive;
 
@@ -344,26 +344,28 @@ impl LanguagePlugin for CSharpPlugin {
         combinator::map(
             sequence::delimited(
                 sequence::tuple((
-                    bytes::complete::tag("@"),
+                    character::complete::char('@'),
                     character::complete::multispace0,
                     bytes::complete::tag_no_case("points"),
                     character::complete::multispace0,
                     character::complete::char('('),
                     character::complete::multispace0,
                 )),
-                sequence::delimited(
-                    character::complete::char('"'),
-                    bytes::complete::is_not("\""),
-                    character::complete::char('"'),
-                ),
+                parse_util::comma_separated_strings,
                 sequence::tuple((
                     character::complete::multispace0,
                     character::complete::char(')'),
                 )),
             ),
-            str::trim,
+            // splits each point by whitespace
+            |points| {
+                points
+                    .into_iter()
+                    .map(|p| p.split_whitespace())
+                    .flatten()
+                    .collect()
+            },
         )(i)
-        .map(|(a, b)| (a, vec![b]))
     }
 }
 
@@ -680,10 +682,13 @@ mod test {
         assert!(res.is_err());
 
         let res = CSharpPlugin::points_parser("@Points(\"1\")").unwrap();
-        assert_eq!(res.1[0], "1");
+        assert_eq!(res.1, &["1"]);
 
         let res = CSharpPlugin::points_parser("@  pOiNtS  (  \"  1  \"  )  ").unwrap();
-        assert_eq!(res.1[0], "1");
+        assert_eq!(res.1, &["1"]);
+
+        let res = CSharpPlugin::points_parser("@Points(\"1\", \"2\"  ,  \"3\")").unwrap();
+        assert_eq!(res.1, &["1", "2", "3"]);
     }
 
     #[test]
diff --git a/plugins/java/src/ant_plugin.rs b/plugins/java/src/ant_plugin.rs
@@ -117,7 +117,7 @@ impl LanguagePlugin for AntPlugin {
     }
 
     fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
-        Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
+        Self::java_points_parser(i)
     }
 
     fn get_default_student_file_paths() -> Vec<PathBuf> {
diff --git a/plugins/java/src/java_plugin.rs b/plugins/java/src/java_plugin.rs
@@ -12,7 +12,7 @@ use tmc_langs_framework::{
     ExerciseDesc, Language, LanguagePlugin, RunResult, RunStatus, StyleValidationResult, TestDesc,
     TestResult, TmcCommand,
 };
-use tmc_langs_util::file_util;
+use tmc_langs_util::{file_util, parse_util};
 use walkdir::WalkDir;
 
 pub(crate) trait JavaPlugin: LanguagePlugin {
@@ -253,28 +253,31 @@ pub(crate) trait JavaPlugin: LanguagePlugin {
     }
 
     /// Parses @Points("1.1") point annotations.
-    fn java_points_parser(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    fn java_points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
         combinator::map(
             sequence::delimited(
                 sequence::tuple((
-                    bytes::complete::tag("@"),
+                    character::complete::char('@'),
                     character::complete::multispace0,
                     bytes::complete::tag_no_case("points"),
                     character::complete::multispace0,
                     character::complete::char('('),
                     character::complete::multispace0,
                 )),
-                sequence::delimited(
-                    character::complete::char('"'),
-                    bytes::complete::is_not("\""),
-                    character::complete::char('"'),
-                ),
+                parse_util::comma_separated_strings,
                 sequence::tuple((
                     character::complete::multispace0,
                     character::complete::char(')'),
                 )),
             ),
-            str::trim,
+            // splits each point by whitespace
+            |points| {
+                points
+                    .into_iter()
+                    .map(|p| p.split_whitespace())
+                    .flatten()
+                    .collect()
+            },
         )(i)
     }
 }
@@ -361,7 +364,7 @@ mod test {
         }
 
         fn points_parser(i: &str) -> IResult<&str, Vec<&str>, nom::error::VerboseError<&str>> {
-            Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
+            Self::java_points_parser(i)
         }
     }
 
@@ -569,13 +572,19 @@ openjdk version "1.8.0_252"S
 
         assert_eq!(
             Stub::java_points_parser(r#"@points("point")"#).unwrap().1,
-            "point"
+            &["point"]
         );
         assert_eq!(
             Stub::java_points_parser(r#"@  PoInTs  (  "  another point  "  )  "#)
                 .unwrap()
                 .1,
-            "another point"
+            &["another", "point"]
+        );
+        assert_eq!(
+            Stub::java_points_parser(r#"@points("point", "another point"  ,  "asd")"#)
+                .unwrap()
+                .1,
+            &["point", "another", "point", "asd"]
         );
     }
 }
diff --git a/plugins/java/src/maven_plugin.rs b/plugins/java/src/maven_plugin.rs
@@ -124,7 +124,7 @@ impl LanguagePlugin for MavenPlugin {
     }
 
     fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
-        Self::java_points_parser(i).map(|(a, b)| (a, vec![b]))
+        Self::java_points_parser(i)
     }
 }
 
diff --git a/plugins/notests/src/plugin.rs b/plugins/notests/src/plugin.rs
@@ -95,10 +95,9 @@ impl LanguagePlugin for NoTestsPlugin {
         vec![PathBuf::from("test")]
     }
 
-    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]))
+    fn points_parser(_: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        // never parses anything
+        Err(nom::Err::Error(VerboseError { errors: vec![] }))
     }
 }
 
diff --git a/plugins/python3/src/plugin.rs b/plugins/python3/src/plugin.rs
@@ -13,13 +13,14 @@ use std::io::BufReader;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tmc_langs_framework::{
-    nom::{branch, bytes, character, combinator, error::VerboseError, sequence, IResult},
+    nom::{bytes, character, combinator, error::VerboseError, sequence, IResult},
     CommandError, ExerciseDesc, LanguagePlugin, Output, RunResult, RunStatus, TestDesc, TestResult,
     TmcCommand, TmcError, TmcProjectYml,
 };
 use tmc_langs_util::{
     file_util,
     notification_reporter::{self, Notification},
+    parse_util,
 };
 use walkdir::WalkDir;
 
@@ -382,33 +383,28 @@ impl LanguagePlugin for Python3Plugin {
         combinator::map(
             sequence::delimited(
                 sequence::tuple((
-                    bytes::complete::tag("@"),
+                    character::complete::char('@'),
                     character::complete::multispace0,
                     bytes::complete::tag_no_case("points"),
                     character::complete::multispace0,
                     character::complete::char('('),
                     character::complete::multispace0,
                 )),
-                branch::alt((
-                    sequence::delimited(
-                        character::complete::char('"'),
-                        bytes::complete::is_not("\""),
-                        character::complete::char('"'),
-                    ),
-                    sequence::delimited(
-                        character::complete::char('\''),
-                        bytes::complete::is_not("'"),
-                        character::complete::char('\''),
-                    ),
-                )),
+                parse_util::comma_separated_strings_either,
                 sequence::tuple((
                     character::complete::multispace0,
                     character::complete::char(')'),
                 )),
             ),
-            str::trim,
+            // splits each point by whitespace
+            |points| {
+                points
+                    .into_iter()
+                    .map(|p| p.split_whitespace())
+                    .flatten()
+                    .collect()
+            },
         )(i)
-        .map(|(a, b)| (a, vec![b]))
     }
 }
 
@@ -723,18 +719,24 @@ class TestErroring(unittest.TestCase):
     #[test]
     fn parses_points() {
         assert_eq!(
-            Python3Plugin::points_parser("@points('p1')").unwrap().1[0],
-            "p1"
+            Python3Plugin::points_parser("@points('p1')").unwrap().1,
+            &["p1"]
         );
         assert_eq!(
             Python3Plugin::points_parser("@  pOiNtS  (  '  p2  '  )  ")
                 .unwrap()
-                .1[0],
-            "p2"
+                .1,
+            &["p2"]
+        );
+        assert_eq!(
+            Python3Plugin::points_parser(r#"@points("p3")"#).unwrap().1,
+            &["p3"]
         );
         assert_eq!(
-            Python3Plugin::points_parser(r#"@points("p3")"#).unwrap().1[0],
-            "p3"
+            Python3Plugin::points_parser(r#"@points("p3", 'p4', "p5", "p6 p7")"#)
+                .unwrap()
+                .1,
+            &["p3", "p4", "p5", "p6", "p7"]
         );
         assert!(Python3Plugin::points_parser(r#"@points("p3')"#).is_err());
     }
diff --git a/plugins/r/src/plugin.rs b/plugins/r/src/plugin.rs
@@ -154,7 +154,7 @@ impl LanguagePlugin for RPlugin {
                 character::complete::char(','),
                 character::complete::multispace0,
             )),
-            c_parser,
+            list_parser,
         );
         let points_for_all_tests_parser = sequence::preceded(
             sequence::tuple((
@@ -163,10 +163,10 @@ impl LanguagePlugin for RPlugin {
                 character::complete::char('('),
                 character::complete::multispace0,
             )),
-            c_parser,
+            list_parser,
         );
 
-        fn c_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+        fn list_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
             sequence::delimited(
                 sequence::tuple((
                     character::complete::char('c'),
@@ -522,13 +522,13 @@ etc
             "tests/testthat/testExercise.R",
             r#"
 something
-test("some test", c("r1", "r2", "r3"))
+test("some test", c("r1", "r2", "r3", "r4 r5"))
 etc
 "#,
         );
 
         let points = RPlugin::get_available_points(temp.path()).unwrap();
-        assert_eq!(points, &["r1", "r2", "r3"]);
+        assert_eq!(points, &["r1", "r2", "r3", "r4", "r5"]);
     }
 
     #[test]
diff --git a/tmc-langs-util/src/parse_util.rs b/tmc-langs-util/src/parse_util.rs
@@ -1,21 +1,27 @@
 //! Contains parse functions that may be convenient for implementing language plugins.
-use nom::{branch, bytes, character, error::VerboseError, multi, sequence, IResult};
+use nom::{branch, bytes, character, combinator, error::VerboseError, multi, sequence, IResult};
 
-/// Parses a string delimited by double quotes.
+/// Parses a string delimited by double quotes. Trims.
 pub fn string(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-    sequence::delimited(
-        character::complete::char('"'),
-        bytes::complete::is_not("\""),
-        character::complete::char('"'),
+    combinator::map(
+        sequence::delimited(
+            character::complete::char('"'),
+            bytes::complete::is_not("\""),
+            character::complete::char('"'),
+        ),
+        str::trim,
     )(i)
 }
 
-/// Parses a string delimited by single quotes.
+/// Parses a string delimited by single quotes. Trims.
 pub fn string_single(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
-    sequence::delimited(
-        character::complete::char('\''),
-        bytes::complete::is_not("'"),
-        character::complete::char('\''),
+    combinator::map(
+        sequence::delimited(
+            character::complete::char('\''),
+            bytes::complete::is_not("'"),
+            character::complete::char('\''),
+        ),
+        str::trim,
     )(i)
 }
 

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ impl LanguagePlugin for AntPlugin {`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
`120`		`- Self::java_points_parser(i).map(\|(a, b)\| (a, vec![b]))`
	`120`	`+ Self::java_points_parser(i)`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`fn get_default_student_file_paths() -> Vec<PathBuf> {`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl LanguagePlugin for MavenPlugin {`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
`127`		`- Self::java_points_parser(i).map(\|(a, b)\| (a, vec![b]))`
	`127`	`+ Self::java_points_parser(i)`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -95,10 +95,9 @@ impl LanguagePlugin for NoTestsPlugin {`
`95`	`95`	`vec![PathBuf::from("test")]`
`96`	`96`	`}`
`97`	`97`
`98`		`- fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
`99`		`- // does not match any characters`
`100`		`- nom::combinator::value("", nom::character::complete::one_of(""))(i)`
`101`		`- .map(\|(a, b)\| (a, vec![b]))`
	`98`	`+ fn points_parser(_: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {`
	`99`	`+ // never parses anything`
	`100`	`+ Err(nom::Err::Error(VerboseError { errors: vec![] }))`
`102`	`101`	`}`
`103`	`102`	`}`
`104`	`103`