temp

Author: Heliozoa

tmc-langs-cli/src/error.rs

@@ -0,0 +1,9 @@
+use std::path::PathBuf;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+#[error("Invalid token. Deleted credentials file at {path}")]
+pub struct InvalidTokenError {
+    pub path: PathBuf,
+    pub source: anyhow::Error,
+}

tmc-langs-framework/Cargo.toml

@@ -15,6 +15,8 @@ serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.8"
 zip = "0.5"
 schemars = "0.7"
+once_cell = "1"
+nom = "5"
 
 [dev-dependencies]
 env_logger = "0.7"

tmc-langs-framework/src/lib.rs

@@ -9,6 +9,7 @@ pub mod policy;
 
 use domain::TmcProjectYml;
 pub use error::TmcError;
+pub use nom;
 pub use plugin::LanguagePlugin;
 pub use policy::StudentFilePolicy;
 pub use zip;

tmc-langs-framework/src/plugin.rs

@@ -9,6 +9,9 @@ use crate::io::{file_util, submission_processing, tmc_zip};
 use crate::policy::StudentFilePolicy;
 pub use isolang::Language;
 use log::debug;
+use nom::{bytes::complete, combinator, error::ErrorKind, error::ParseError, sequence, IResult};
+use once_cell::sync::Lazy;
+use regex::Regex;
 use std::collections::{HashMap, HashSet};
 use std::io::{Read, Seek, Write};
 use std::path::{Path, PathBuf};
@@ -426,6 +429,43 @@ pub trait LanguagePlugin {
     fn get_default_exercise_file_paths(&self) -> Vec<PathBuf> {
         vec![PathBuf::from("test")]
     }
+
+    fn get_available_points(&self, exercise_path: &Path) -> Result<Vec<String>, TmcError> {
+        let config = self.get_exercise_packaging_configuration(exercise_path)?;
+
+        //let points_re = Regex::new(r#"(.*)@\s*[pP]oints\s*\(\s*['"](.*)['"]\s*\)"#).unwrap();
+
+        let mut points = Vec::new();
+        for exercise_file_path in config.exercise_file_paths {
+            let exercise_file_path = exercise_path.join(exercise_file_path);
+            if !exercise_file_path.exists() {
+                continue;
+            }
+
+            // file path may point to a directory of file, walkdir takes care of both
+            for entry in WalkDir::new(exercise_file_path) {
+                let entry = entry?;
+                if entry.path().is_file() {
+                    log::debug!("parsing points from {}", entry.path().display());
+                    let file_contents = file_util::read_file_to_string(entry.path())?;
+
+                    let parser = sequence::tuple((
+                        Self::line_comment_parser,
+                        Self::block_comment_parser,
+                        Self::points_parser,
+                        complete::take(1usize),
+                    ));
+                    let res: IResult<_, _, (&str, ErrorKind)> = parser(&file_contents);
+                    let (rem, (lc, bc, ps, nc)) = res.unwrap();
+                }
+            }
+        }
+        Ok(points)
+    }
+
+    fn line_comment_parser<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, (), E>;
+    fn block_comment_parser<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, (), E>;
+    fn points_parser<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, &str, E>;
 }
 
 #[cfg(test)]
@@ -486,6 +526,16 @@ mod test {
         fn clean(&self, _path: &Path) -> Result<(), TmcError> {
             unimplemented!()
         }
+
+        fn line_comment_parser<'a, E: ParseError<&'a str>>(_: &'a str) -> IResult<&'a str, (), E> {
+            unimplemented!()
+        }
+        fn block_comment_parser<'a, E: ParseError<&'a str>>(_: &'a str) -> IResult<&'a str, (), E> {
+            unimplemented!()
+        }
+        fn points_parser<'a, E: ParseError<&'a str>>(_: &'a str) -> IResult<&'a str, &str, E> {
+            unimplemented!()
+        }
     }
 
     #[test]

tmc-langs-util/src/task_executor.rs

@@ -191,52 +191,7 @@ pub fn find_exercise_directories(exercise_path: &Path) -> Vec<PathBuf> {
 
 /// Parses available exercise points from the exercise without compiling it.
 pub fn get_available_points(exercise_path: &Path) -> Result<Vec<String>, UtilError> {
-    let plugin = get_language_plugin(exercise_path)?;
-    let config = plugin.get_exercise_packaging_configuration(exercise_path)?;
-
-    let points_re = Regex::new(r#"(.*)@\s*[pP]oints\s*\(\s*['"](.*)['"]\s*\)"#).unwrap();
-    let mut points = Vec::new();
-    for exercise_file_path in config.exercise_file_paths {
-        let exercise_file_path = exercise_path.join(exercise_file_path);
-        if !exercise_file_path.exists() {
-            continue;
-        }
-
-        // file path may point to a directory of file, walkdir takes care of both
-        for entry in WalkDir::new(exercise_file_path) {
-            let entry = entry?;
-            if entry.path().is_file() {
-                log::debug!("parsing points from {}", entry.path().display());
-                let file_contents = file_util::read_file_to_string(entry.path())?;
-
-                let mut in_comment = false;
-                for line in file_contents.lines() {
-                    let start = line.trim_start();
-                    // skip commented lines
-                    if start.starts_with("//") || start.starts_with('#') {
-                        continue;
-                    }
-                    if start.starts_with("/*") {
-                        in_comment = true;
-                    }
-                    if !in_comment {
-                        if let Some(captures) = points_re.captures(line) {
-                            let first_end = captures[1].trim_end();
-                            if !first_end.ends_with("//")
-                                && !first_end.ends_with('#')
-                                && !first_end.ends_with("/*")
-                            {
-                                points.push(captures[2].to_string());
-                            }
-                        }
-                    }
-                    if start.ends_with("*/") {
-                        in_comment = false;
-                    }
-                }
-            }
-        }
-    }
+    let points = get_language_plugin(exercise_path)?.get_available_points(exercise_path)?;
     Ok(points)
 }
 
@@ -251,6 +206,7 @@ pub fn get_available_points(exercise_path: &Path) -> Result<Vec<String>, UtilErr
     fn run_tests(&self, path: &Path) -> Result<RunResult, TmcError> {}
     fn check_code_style(&self, path: &Path, locale: Language) -> Result<Option<ValidationResult>, TmcError> {}
     fn prepare_stub(&self, exercise_path: &Path, repo_path: &Path, dest_path: &Path) -> Result<(), TmcError> {}
+    fn get_available_points(&self, exercise_path: &Path) -> Result<Vec<String>, TmcError> {}
 )]
 enum Plugin {
     CSharp(CSharpPlugin),