Librarify

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "lingua-franca"
+name = "lingo"
 version = "0.2.0"
 edition = "2021"
 
@@ -8,10 +8,19 @@ homepage = "https://lf-lang.org"
 repository = "https://github.com/lf-lang/lingo"
 license = "BSD-2-Clause"
 
+[lib]
+name = "liblingo"
+path = "src/lib.rs"
+
 [[bin]]
 name = "lingo"
 publish = true
 path = "./src/main.rs"
+required-features = ["binary"]
+
+[features]
+default = ["binary"]
+binary = ["which", "git2"]
 
 [dependencies]
 
@@ -20,13 +29,14 @@ os-version = "0.2"
 serde = "1.0"
 serde_json = "1.0"
 serde_derive = "1.0"
-which = "5.0"
 regex = "1.8"
 lazy_static = "1.4"
 rayon = "1.7"
-toml = {version = "0.8"}
+toml = { version = "0.8" }
 crossbeam = "0.8"
-termion = "2.0"
-git2 = "0.18"
 run_script = "0.10"
 tempfile = "3.0"
+which = { version = "5.0", optional = true }
+git2 = { version = "0.18", optional = true }
+log = "0.4.21"
+print_logger = "0.2.0"

src/args.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 #[clap(rename_all = "lowercase")]
 pub enum TargetLanguage {
     C,
+    CCpp,
     Cpp,
     Rust,
     TypeScript,

src/backends/cmake.rs

@@ -2,8 +2,8 @@ use std::fs;
 
 use std::process::Command;
 
+use crate::package::App;
 use crate::util::execute_command_to_build_result;
-use crate::App;
 
 use crate::backends::{
     BatchBackend, BatchBuildResults, BuildCommandOptions, BuildProfile, BuildResult, CommandSpec,

src/backends/lfc.rs

@@ -60,7 +60,7 @@ impl BatchBackend for LFC {
 
 /// Formats LFC arguments to JSON.
 #[derive(Serialize, Clone)]
-struct LfcJsonArgs<'a> {
+pub struct LfcJsonArgs<'a> {
     /// Path to the LF source file containing the main reactor.
     pub src: &'a Path,
     /// Path to the directory into which build artifacts like

src/backends/mod.rs

@@ -8,18 +8,23 @@ use rayon::prelude::*;
 use crate::args::{BuildSystem, Platform};
 use crate::package::App;
 use crate::util::errors::{AnyError, BuildResult, LingoError};
+use crate::WhichCapability;
 
 pub mod cmake;
 pub mod lfc;
 pub mod npm;
 pub mod pnpm;
 
-pub fn execute_command<'a>(command: &CommandSpec, apps: &[&'a App]) -> BatchBuildResults<'a> {
+pub fn execute_command<'a>(
+    command: &CommandSpec,
+    apps: &[&'a App],
+    which: WhichCapability,
+) -> BatchBuildResults<'a> {
     // Group apps by build system
     let mut by_build_system = HashMap::<BuildSystem, Vec<&App>>::new();
     for &app in apps {
         by_build_system
-            .entry(app.build_system())
+            .entry(app.build_system(&which))
             .or_default()
             .push(app);
     }
@@ -121,10 +126,10 @@ impl<'a> BatchBuildResults<'a> {
         for (app, b) in &self.results {
             match b {
                 Ok(()) => {
-                    println!("- {}: Success", &app.name);
+                    log::info!("- {}: Success", &app.name);
                 }
                 Err(e) => {
-                    println!("- {}: Error: {}", &app.name, e);
+                    log::error!("- {}: Error: {}", &app.name, e);
                 }
             }
         }

src/lib.rs

@@ -0,0 +1,59 @@
+use std::io;
+
+pub mod args;
+pub mod backends;
+pub mod package;
+pub mod util;
+
+#[derive(Debug)]
+pub enum WhichError {
+    /// An executable binary with that name was not found
+    CannotFindBinaryPath,
+    /// There was nowhere to search and the provided name wasn't an absolute path
+    CannotGetCurrentDirAndPathListEmpty,
+    /// Failed to canonicalize the path found
+    CannotCanonicalize,
+}
+#[derive(Debug)]
+pub struct GitCloneError(pub String); // TODO: create a more domain-specific error time like the actual git2::Error
+
+impl std::fmt::Display for WhichError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WhichError::CannotFindBinaryPath => write!(f, "cannot find binary"),
+            WhichError::CannotGetCurrentDirAndPathListEmpty => {
+                write!(f, "cannot get current dir and path list empty")
+            }
+            WhichError::CannotCanonicalize => write!(f, "cannot canonicalize"),
+        }
+    }
+}
+
+impl std::fmt::Display for GitCloneError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::error::Error for WhichError {}
+
+impl std::error::Error for GitCloneError {}
+
+pub struct GitUrl<'a>(&'a str);
+
+impl<'a> From<&'a str> for GitUrl<'a> {
+    fn from(value: &'a str) -> Self {
+        GitUrl(value)
+    }
+}
+
+impl<'a> From<GitUrl<'a>> for &'a str {
+    fn from(value: GitUrl<'a>) -> Self {
+        value.0
+    }
+}
+
+pub type WhichCapability<'a> = Box<dyn Fn(&str) -> Result<std::path::PathBuf, WhichError> + 'a>;
+pub type GitCloneCapability<'a> =
+    Box<dyn Fn(GitUrl, &std::path::Path) -> Result<(), GitCloneError> + 'a>;
+pub type FsReadCapability<'a> = Box<dyn Fn(&std::path::Path) -> io::Result<String> + 'a>;

src/main.rs

@@ -1,35 +1,53 @@
 use std::io::ErrorKind;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::{env, io};
 
 use clap::Parser;
 
-use crate::args::InitArgs;
-use args::{BuildArgs, Command as ConsoleCommand, CommandLineArgs};
-use package::App;
+use git2::Repository;
+use liblingo::args::InitArgs;
+use liblingo::args::{BuildArgs, Command as ConsoleCommand, CommandLineArgs};
 
-use crate::backends::{BatchBuildResults, BuildCommandOptions, CommandSpec};
-use crate::package::{Config, ConfigFile};
-use crate::util::errors::{BuildResult, LingoError};
+use liblingo::backends::{BatchBuildResults, BuildCommandOptions, CommandSpec};
+use liblingo::package::{Config, ConfigFile};
+use liblingo::util::errors::{BuildResult, LingoError};
+use liblingo::{GitCloneError, GitUrl, WhichError};
 
-pub mod args;
-pub mod backends;
-pub mod package;
-pub(crate) mod util;
+fn do_repo_clone(url: GitUrl, into: &std::path::Path) -> Result<(), GitCloneError> {
+    Repository::clone(url.into(), into).map_or_else(
+        |err: git2::Error| Err(GitCloneError(format!("{}", err))),
+        |_| Ok(()),
+    )
+}
+
+fn do_which(cmd: &str) -> Result<PathBuf, WhichError> {
+    which::which(cmd).map_err(|err| match err {
+        which::Error::CannotFindBinaryPath => WhichError::CannotFindBinaryPath,
+        which::Error::CannotGetCurrentDirAndPathListEmpty => {
+            WhichError::CannotGetCurrentDirAndPathListEmpty
+        }
+        which::Error::CannotCanonicalize => WhichError::CannotCanonicalize,
+    })
+}
+
+fn do_read_to_string(p: &Path) -> io::Result<String> {
+    std::fs::read_to_string(p)
+}
 
 fn main() {
+    print_logger::new().init().unwrap();
     // parses command line arguments
     let args = CommandLineArgs::parse();
 
     // Finds Lingo.toml recursively inside the parent directories.
     // If it exists the returned path is absolute.
-    let lingo_path = util::find_toml(&env::current_dir().unwrap());
+    let lingo_path = liblingo::util::find_toml(&env::current_dir().unwrap());
 
     // tries to read Lingo.toml
     let mut wrapped_config = lingo_path.as_ref().and_then(|path| {
-        ConfigFile::from(path)
-            .map_err(|err| println!("Error while reading Lingo.toml: {}", err))
+        ConfigFile::from(path, Box::new(do_read_to_string))
+            .map_err(|err| log::error!("Error while reading Lingo.toml: {}", err))
             .ok()
             .map(|cf| cf.to_config(path.parent().unwrap()))
     });
@@ -51,7 +69,7 @@ fn print_res(result: BuildResult) {
     match result {
         Ok(_) => {}
         Err(errs) => {
-            println!("{}", errs);
+            log::error!("{}", errs);
         }
     }
 }
@@ -87,14 +105,14 @@ fn execute_command(config: Option<&Config>, command: ConsoleCommand) -> CommandR
             "Error: Missing Lingo.toml file",
         )))),
         (Some(config), ConsoleCommand::Build(build_command_args)) => {
-            println!("Building ...");
+            log::info!("Building ...");
             CommandResult::Batch(build(&build_command_args, config))
         }
         (Some(config), ConsoleCommand::Run(build_command_args)) => {
             let mut res = build(&build_command_args, config);
             res.map(|app| {
                 let mut command = Command::new(app.executable_path());
-                util::run_and_capture(&mut command)?;
+                liblingo::util::run_and_capture(&mut command)?;
                 Ok(())
             });
             CommandResult::Batch(res)
@@ -109,15 +127,16 @@ fn execute_command(config: Option<&Config>, command: ConsoleCommand) -> CommandR
 fn do_init(init_config: InitArgs) -> BuildResult {
     let initial_config = ConfigFile::new_for_init_task(init_config)?;
     initial_config.write(Path::new("./Lingo.toml"))?;
-    initial_config.setup_example()
+    initial_config.setup_example(Box::new(do_repo_clone))
 }
 
 fn build<'a>(args: &BuildArgs, config: &'a Config) -> BatchBuildResults<'a> {
     run_command(
         CommandSpec::Build(BuildCommandOptions {
             profile: args.build_profile(),
             compile_target_code: !args.no_compile,
-            lfc_exec_path: util::find_lfc_exec(args).expect("TODO replace me"),
+            lfc_exec_path: liblingo::util::find_lfc_exec(args, Box::new(do_which))
+                .expect("TODO replace me"),
             max_threads: args.threads,
             keep_going: args.keep_going,
         }),
@@ -128,7 +147,7 @@ fn build<'a>(args: &BuildArgs, config: &'a Config) -> BatchBuildResults<'a> {
 
 fn run_command(task: CommandSpec, config: &Config, _fail_at_end: bool) -> BatchBuildResults {
     let apps = config.apps.iter().collect::<Vec<_>>();
-    backends::execute_command(&task, &apps)
+    liblingo::backends::execute_command(&task, &apps, Box::new(do_which))
 }
 
 enum CommandResult<'a> {

src/package/mod.rs

@@ -1,20 +1,19 @@
 use crate::args::{BuildSystem, InitArgs, Platform, TargetLanguage};
 use crate::util::{analyzer, copy_recursively};
+use crate::{FsReadCapability, GitCloneCapability, GitUrl, WhichCapability};
 
 use serde_derive::{Deserialize, Serialize};
 
 use std::collections::HashMap;
 
-use std::fs::{read_to_string, remove_dir_all, remove_file, write};
+use std::fs::{remove_dir_all, remove_file, write};
 use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 use std::{env, io};
 
 use crate::args::BuildSystem::{CMake, LFC};
 use crate::util::errors::{BuildResult, LingoError};
-use git2::Repository;
 use tempfile::tempdir;
-use which::which;
 
 fn is_valid_location_for_project(path: &std::path::Path) -> bool {
     !path.join("src").exists() && !path.join(".git").exists() && !path.join("application").exists()
@@ -91,7 +90,7 @@ pub struct App {
 }
 
 impl App {
-    pub fn build_system(&self) -> BuildSystem {
+    pub fn build_system(&self, which: &WhichCapability) -> BuildSystem {
         match self.target {
             TargetLanguage::C => LFC,
             TargetLanguage::Cpp => CMake,
@@ -211,10 +210,15 @@ impl ConfigFile {
         write(path, toml_string)
     }
 
-    pub fn from(path: &Path) -> io::Result<ConfigFile> {
-        read_to_string(path).and_then(|contents| {
-            toml::from_str(&contents)
-                .map_err(|e| io::Error::new(ErrorKind::InvalidData, format!("{}", e)))
+    pub fn from(path: &Path, fsr: FsReadCapability) -> io::Result<ConfigFile> {
+        let contents = fsr(path);
+        contents.and_then(|contents| {
+            toml::from_str(&contents).map_err(|e| {
+                io::Error::new(
+                    ErrorKind::InvalidData,
+                    format!("failed to convert string to toml: {}", e),
+                )
+            })
         })
     }
 
@@ -233,10 +237,10 @@ impl ConfigFile {
         Ok(())
     }
 
-    fn setup_template_repo(&self, url: &str) -> BuildResult {
+    fn setup_template_repo(&self, url: &str, clone: GitCloneCapability) -> BuildResult {
         let dir = tempdir()?;
         let tmp_path = dir.path();
-        Repository::clone(url, tmp_path)?;
+        clone(GitUrl::from(url), tmp_path)?;
         // Copy the cloned template repo into the project directory
         copy_recursively(tmp_path, Path::new("."))?;
         // Remove temporary folder
@@ -245,29 +249,29 @@ impl ConfigFile {
     }
 
     // Sets up a LF project with Zephyr as the target platform.
-    fn setup_zephyr(&self) -> BuildResult {
+    fn setup_zephyr(&self, clone: GitCloneCapability) -> BuildResult {
         let url = "https://github.com/lf-lang/lf-west-template";
-        self.setup_template_repo(url)?;
+        self.setup_template_repo(url, clone)?;
         remove_file(".gitignore")?;
         remove_dir_all(Path::new(".git"))?;
         Ok(())
     }
 
     // Sets up a LF project with RP2040 MCU as the target platform.
     // Initializes a repo using the lf-pico-template
-    fn setup_rp2040(&self) -> BuildResult {
+    fn setup_rp2040(&self, clone: GitCloneCapability) -> BuildResult {
         let url = "https://github.com/lf-lang/lf-pico-template";
         // leave git artifacts
-        self.setup_template_repo(url)?;
+        self.setup_template_repo(url, clone)?;
         Ok(())
     }
 
-    pub fn setup_example(&self) -> BuildResult {
+    pub fn setup_example(&self, clone: GitCloneCapability) -> BuildResult {
         if is_valid_location_for_project(Path::new(".")) {
             match self.apps[0].platform {
                 Some(Platform::Native) => self.setup_native(),
-                Some(Platform::Zephyr) => self.setup_zephyr(),
-                Some(Platform::RP2040) => self.setup_rp2040(),
+                Some(Platform::Zephyr) => self.setup_zephyr(clone),
+                Some(Platform::RP2040) => self.setup_rp2040(clone),
                 _ => Ok(()),
             }
         } else {