Merge pull request #121 from rage/restructuring

Restructuring

Author: Heliozoa

Cargo.toml

@@ -1,8 +1,10 @@
 [workspace]
 members =[
     "tmc-client",
+    "tmc-langs",
     "tmc-langs-cli",
     "tmc-langs-framework",
+    "tmc-langs-plugins",
     "tmc-langs-util",
 
     "plugins/csharp",

README.md

@@ -68,7 +68,11 @@ Documentation and binaries for the supported targets are built and the binaries
 
 ### tmc-langs-cli
 
-A binary CLI interface for TMC-langs for IDEs.
+A "frontend" for tmc-langs. A binary CLI client for TMC-langs for IDEs. Intended to be used programmatically, for a CLI meant for manual use see [tmc-cli-rust](https://github.com/rage/tmc-cli-rust).
+
+### tmc-langs
+
+The "backend". A library that provides a convenient API for implementing different frontends. A frontend (such as a CLI) should only depend on this and optionally the util library.
 
 ### tmc-client
 
@@ -78,9 +82,13 @@ A library for communicating with the TMC server.
 
 A library for creating language plugins.
 
+### tmc-langs-plugins
+
+A library that provides a convenient API for using all the different plugins.
+
 ### tmc-langs-util
 
-A library that provides a convenient interface abstracting over all available language plugins.
+A utility library that contains various kinds of useful functionality for other projects.
 
 ### plugins/csharp
 

plugins/csharp/Cargo.toml

@@ -7,15 +7,16 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 tmc-langs-framework = { path = "../../tmc-langs-framework" }
+tmc-langs-util = { path = "../../tmc-langs-util" }
 
 dirs = "3"
 log = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 thiserror = "1"
 walkdir = "2"
+zip = "0.5"
 
 [dev-dependencies]
 simple_logger = "1"
 tempfile = "3"
-zip = "0.5"

plugins/csharp/src/cs_test_result.rs

@@ -2,7 +2,7 @@
 
 use serde::Deserialize;
 use std::collections::HashSet;
-use tmc_langs_framework::domain::TestResult;
+use tmc_langs_framework::TestResult;
 
 /// Test result from the C# test runner.
 #[derive(Debug, Deserialize)]

plugins/csharp/src/error.rs

@@ -2,10 +2,8 @@
 
 use std::path::PathBuf;
 use thiserror::Error;
-use tmc_langs_framework::{
-    error::{CommandError, FileIo},
-    zip, TmcError,
-};
+use tmc_langs_framework::TmcError;
+use tmc_langs_util::FileError;
 
 #[derive(Debug, Error)]
 pub enum CSharpError {
@@ -20,12 +18,8 @@ pub enum CSharpError {
     MissingBootstrapDll(PathBuf),
 
     // Wrapping other error types.
-    #[error("Command not found")]
-    Command(#[from] CommandError),
     #[error("File IO error")]
-    FileIo(#[from] FileIo),
-    #[error("TMC error")]
-    Tmc(#[from] TmcError),
+    FileError(#[from] FileError),
     #[error("Zip error")]
     Zip(#[from] zip::result::ZipError),
 }
@@ -36,3 +30,10 @@ impl From<CSharpError> for TmcError {
         Self::Plugin(Box::new(err))
     }
 }
+
+// conversion from plugin error to a tmc result
+impl<T> Into<Result<T, TmcError>> for CSharpError {
+    fn into(self) -> Result<T, TmcError> {
+        Err(TmcError::Plugin(Box::new(self)))
+    }
+}

plugins/csharp/src/plugin.rs

@@ -9,19 +9,13 @@ use std::io::{BufReader, Cursor, Read, Seek};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tmc_langs_framework::{
-    command::TmcCommand,
-    domain::{
-        ExerciseDesc, RunResult, RunStatus, StyleValidationResult, StyleValidationStrategy,
-        TestDesc, TestResult,
-    },
-    error::{CommandError, FileIo},
-    file_util,
     nom::{bytes, character, combinator, error::VerboseError, sequence, IResult},
-    plugin::Language,
-    zip::ZipArchive,
-    LanguagePlugin, TmcError,
+    CommandError, ExerciseDesc, Language, LanguagePlugin, RunResult, RunStatus,
+    StyleValidationResult, StyleValidationStrategy, TestDesc, TestResult, TmcCommand, TmcError,
 };
+use tmc_langs_util::{file_util, FileError};
 use walkdir::WalkDir;
+use zip::ZipArchive;
 
 const TMC_CSHARP_RUNNER: &[u8] = include_bytes!("../deps/tmc-csharp-runner-1.1.1.zip");
 
@@ -57,7 +51,7 @@ impl CSharpPlugin {
                 let zip_bytes: Vec<u8> = file
                     .bytes()
                     .collect::<Result<Vec<_>, _>>()
-                    .map_err(|e| FileIo::FileRead(zip_file_path, e))?;
+                    .map_err(|e| FileError::FileRead(zip_file_path, e))?;
 
                 if target_bytes != zip_bytes {
                     return Ok(true); // bytes changed, need to extract
@@ -84,7 +78,7 @@ impl CSharpPlugin {
                 let bytes: Vec<u8> = file
                     .bytes()
                     .collect::<Result<Vec<_>, _>>()
-                    .map_err(|e| FileIo::FileRead(file_path, e))?;
+                    .map_err(|e| FileError::FileRead(file_path, e))?;
                 file_util::write_to_file(&mut bytes.as_slice(), target_file_path)?;
             }
         }

plugins/java/Cargo.toml

@@ -7,6 +7,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 tmc-langs-framework = { path = "../../tmc-langs-framework" }
+tmc-langs-util = { path = "../../tmc-langs-util" }
 
 dirs = "3"
 flate2 = "1"

plugins/java/src/ant_plugin.rs

@@ -10,13 +10,10 @@ use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tmc_langs_framework::{
-    command::TmcCommand,
-    domain::{ExerciseDesc, RunResult, StyleValidationResult},
-    file_util,
     nom::{error::VerboseError, IResult},
-    plugin::{Language, LanguagePlugin},
-    TmcError,
+    ExerciseDesc, Language, LanguagePlugin, RunResult, StyleValidationResult, TmcCommand, TmcError,
 };
+use tmc_langs_util::file_util;
 use walkdir::WalkDir;
 
 pub struct AntPlugin {
@@ -274,8 +271,8 @@ impl JavaPlugin for AntPlugin {
 mod test {
     use super::*;
     use std::fs;
-    use tmc_langs_framework::domain::StyleValidationStrategy;
-    use tmc_langs_framework::zip::ZipArchive;
+    use tmc_langs_framework::StyleValidationStrategy;
+    use zip::ZipArchive;
 
     fn init() {
         use log::*;
@@ -534,7 +531,7 @@ mod test {
         log::debug!("{:?}", test_result);
         assert_eq!(
             test_result.status,
-            tmc_langs_framework::domain::RunStatus::TestsFailed
+            tmc_langs_framework::RunStatus::TestsFailed
         );
     }
 
@@ -554,13 +551,8 @@ mod test {
         let mut source = test_result_err.source();
         while let Some(inner) = source {
             source = inner.source();
-            if let Some(cmd_error) =
-                inner.downcast_ref::<tmc_langs_framework::error::CommandError>()
-            {
-                if matches!(
-                    cmd_error,
-                    tmc_langs_framework::error::CommandError::TimeOut { .. }
-                ) {
+            if let Some(cmd_error) = inner.downcast_ref::<tmc_langs_framework::CommandError>() {
+                if matches!(cmd_error, tmc_langs_framework::CommandError::TimeOut { .. }) {
                     return;
                 }
             }

plugins/java/src/ant_policy.rs

@@ -1,7 +1,7 @@
 //! Ant student file policy
 
 use std::path::Path;
-use tmc_langs_framework::{policy::StudentFilePolicy, TmcProjectYml};
+use tmc_langs_framework::{StudentFilePolicy, TmcProjectYml};
 
 pub struct AntStudentFilePolicy {
     project_config: TmcProjectYml,

plugins/java/src/error.rs

@@ -3,10 +3,8 @@
 use std::io;
 use std::path::PathBuf;
 use thiserror::Error;
-use tmc_langs_framework::{
-    error::{CommandError, FileIo},
-    TmcError,
-};
+use tmc_langs_framework::TmcError;
+use tmc_langs_util::FileError;
 
 #[derive(Error, Debug)]
 pub enum JavaError {
@@ -35,24 +33,20 @@ pub enum JavaError {
     WalkDir(#[from] walkdir::Error),
     #[error("JSON error")]
     Json(#[from] serde_json::Error),
-    #[error("Failed to run command")]
-    Command(#[from] CommandError),
+    #[error("File IO error")]
+    FileError(#[from] FileError),
     #[error("Error")]
     Tmc(#[from] TmcError),
 }
 
+// conversion from plugin error to TmcError::Plugin
 impl From<JavaError> for TmcError {
     fn from(err: JavaError) -> TmcError {
         TmcError::Plugin(Box::new(err))
     }
 }
 
-impl From<FileIo> for JavaError {
-    fn from(err: FileIo) -> JavaError {
-        JavaError::Tmc(TmcError::FileIo(err))
-    }
-}
-
+// conversion from plugin error to a tmc result
 impl<T> Into<Result<T, TmcError>> for JavaError {
     fn into(self) -> Result<T, TmcError> {
         Err(TmcError::Plugin(Box::new(self)))