parse-util

Author: Heliozoa

plugins/r/src/plugin.rs

@@ -9,10 +9,10 @@ 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, multi, sequence, IResult},
+    nom::{branch, bytes, character, error::VerboseError, sequence, IResult},
     LanguagePlugin, TmcCommand, TmcError, {ExerciseDesc, RunResult, TestDesc},
 };
-use tmc_langs_util::file_util;
+use tmc_langs_util::{file_util, parse_util};
 use zip::ZipArchive;
 
 #[derive(Default)]
@@ -143,13 +143,16 @@ impl LanguagePlugin for RPlugin {
     }
 
     fn points_parser(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
-        let mut test_parser = sequence::preceded(
+        let test_parser = sequence::preceded(
             sequence::tuple((
                 bytes::complete::tag("test"),
                 character::complete::multispace0,
                 character::complete::char('('),
                 character::complete::multispace0,
-                arg_parser,
+                parse_util::string, // parses the first argument which should be a string
+                character::complete::multispace0,
+                character::complete::char(','),
+                character::complete::multispace0,
             )),
             c_parser,
         );
@@ -163,48 +166,19 @@ impl LanguagePlugin for RPlugin {
             c_parser,
         );
 
-        // 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::delimited(
                 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(
+                parse_util::comma_separated_strings,
                 sequence::tuple((
-                    character::complete::char('"'),
-                    bytes::complete::is_not("\""),
-                    character::complete::char('"'),
+                    character::complete::multispace0,
+                    character::complete::char(')'),
                 )),
-                |r| str::trim(r.1),
             )(i)
         }
 
@@ -556,4 +530,23 @@ etc
         let points = RPlugin::get_available_points(temp.path()).unwrap();
         assert_eq!(points, &["r1", "r2", "r3"]);
     }
+
+    #[test]
+    fn parses_first_arg_with_comma_regression() {
+        init();
+
+        let temp = tempfile::tempdir().unwrap();
+        file_to(
+            &temp,
+            "tests/testthat/testExercise.R",
+            r#"
+something
+test("some test, with a comma", c("r1", "r2", "r3"))
+etc
+"#,
+        );
+
+        let points = RPlugin::get_available_points(temp.path()).unwrap();
+        assert_eq!(points, &["r1", "r2", "r3"]);
+    }
 }

tmc-langs-util/Cargo.toml

@@ -8,6 +8,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 fd-lock = "2"
 log = "0.4"
+nom = "6"
 once_cell = "1"
 serde = { version = "1", features = ["derive"] }
 tempfile = "3"

tmc-langs-util/src/lib.rs

@@ -5,6 +5,7 @@
 pub mod error;
 pub mod file_util;
 pub mod notification_reporter;
+pub mod parse_util;
 pub mod progress_reporter;
 
 pub use error::FileError;

tmc-langs-util/src/parse_util.rs

@@ -0,0 +1,90 @@
+//! Contains parse functions that may be convenient for implementing language plugins.
+use nom::{branch, bytes, character, error::VerboseError, multi, sequence, IResult};
+
+/// Parses a string delimited by double quotes.
+pub fn string(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    sequence::delimited(
+        character::complete::char('"'),
+        bytes::complete::is_not("\""),
+        character::complete::char('"'),
+    )(i)
+}
+
+/// Parses a string delimited by single quotes.
+pub fn string_single(i: &str) -> IResult<&str, &str, VerboseError<&str>> {
+    sequence::delimited(
+        character::complete::char('\''),
+        bytes::complete::is_not("'"),
+        character::complete::char('\''),
+    )(i)
+}
+
+/// Parses a comma-separated list of double quote strings like "a", "b", "c".
+pub fn comma_separated_strings(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+    comma_separated_things(string, i)
+}
+
+/// Parses a comma-separated list of single quote strings like 'a', 'b', 'c'.
+pub fn comma_separated_strings_single(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+    comma_separated_things(string_single, i)
+}
+
+/// Parses a comma-separated list of mixed quote strings like 'a', "b", 'c'.
+pub fn comma_separated_strings_either(i: &str) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+    comma_separated_things(branch::alt((string, string_single)), i)
+}
+
+/// Parses a comma-separated list of things, thing being defined by the parser given to the function.
+fn comma_separated_things<'a>(
+    thing_parser: impl FnMut(&'a str) -> IResult<&'a str, &'a str, VerboseError<&'a str>>,
+    i: &'a str,
+) -> IResult<&str, Vec<&str>, VerboseError<&str>> {
+    multi::separated_list1(
+        sequence::delimited(
+            character::complete::multispace0,
+            character::complete::char(','),
+            character::complete::multispace0,
+        ),
+        thing_parser,
+    )(i)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn parses_string() {
+        let (left, res) = string("\"abcd\"").unwrap();
+        assert!(left.is_empty());
+        assert_eq!(res, "abcd");
+    }
+
+    #[test]
+    fn parses_string_single() {
+        let (left, res) = string_single("'abcd'").unwrap();
+        assert!(left.is_empty());
+        assert_eq!(res, "abcd");
+    }
+
+    #[test]
+    fn parses_comma_separated_strings() {
+        let (left, res) = comma_separated_strings("\"abcd\", \"efgh\", \"hijk\"").unwrap();
+        assert!(left.is_empty());
+        assert_eq!(res, &["abcd", "efgh", "hijk"]);
+    }
+
+    #[test]
+    fn parses_comma_separated_strings_single() {
+        let (left, res) = comma_separated_strings_single("'abcd', 'efgh', 'hijk'").unwrap();
+        assert!(left.is_empty());
+        assert_eq!(res, &["abcd", "efgh", "hijk"]);
+    }
+
+    #[test]
+    fn parses_comma_separated_strings_either() {
+        let (left, res) = comma_separated_strings_either("'abcd', \"efgh\", 'hijk'").unwrap();
+        assert!(left.is_empty());
+        assert_eq!(res, &["abcd", "efgh", "hijk"]);
+    }
+}