Initial release 0.1.0

Author: BassedWarrior

.gitignore

@@ -0,0 +1 @@
+target/*

Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "cppargo"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

Cargo.toml

@@ -0,0 +1,48 @@
+# Cppargo
+
+`cppargo` is a tool to mimic the basic functionalities of the `cargo` utility 
+for Rust projects but for C++ projects.
+
+## Usage
+
+### Create new project
+
+In order to create a new project, use the command
+
+```
+cppargo new {project_name}
+```
+
+This will create a new directory `project_name` in the current working 
+directory. 
+
+Inside of which it will also create a `src` with a mock `project_name.cpp` 
+hello world program. This is the directory where all of the source files for 
+the project.
+
+It will also create a `target` directory where the excecutable files are to 
+be stored and run from.
+
+### Build projects
+
+In order to build a project, use the command
+
+```
+cppargo build
+```
+
+Make sure to run this command within the project directory. As it will look 
+for the `src` directory to compile all of the `.cpp` files insde it using `g++`
+to create the `project_name` file within the `target` directory.
+
+### Run projects
+
+In order to run a project, use the command
+
+```
+cppargo run
+```
+
+Within the project directory. This will first perform a `cppargo build` and 
+then run the `target/project_name` file generated after a successful 
+compilation.

README.md

@@ -0,0 +1,144 @@
+use std::{
+    fs,
+    process::Command,
+    env,
+    path::Path,
+};
+
+fn new_project(name: &str) -> Result<(), &'static str> {
+    let project_dir: &Path = Path::new(name);
+    if project_dir.exists() {
+        return Ok(())
+    }
+    
+    if fs::create_dir(project_dir).is_err() {
+        return Err("Failed to create project directory.")
+    };
+    
+    if fs::create_dir(project_dir.join("src")).is_err() {
+        return Err("Failed to create project source directory.")
+    };
+    
+    if fs::create_dir(project_dir.join("target")).is_err() {
+        return Err("Failed to create project target directory.")
+    };
+
+    let hello_world_program = concat!(
+            "#include <iostream>\n",
+            "\n",
+            "int main() {\n",
+            "    std::cout << \"Hello World!\\n\";\n",
+            "    return 0;\n",
+            "};"
+        );
+
+    if fs::write(
+        project_dir.join("src").join("main.cpp"), hello_world_program
+    ).is_err() {
+        return Err("Failed to create project main.cpp file.")
+    };
+
+    Ok(())
+}
+
+fn build_project() -> Result<(), &'static str> {
+    let project_dir = match env::current_dir() {
+        Ok(path) => path,
+        Err(_) => return Err("Couldn't get project directory.")
+    };
+    let project_src = project_dir.join("src");
+    let project_target = project_dir.join("target");
+
+    if ! (project_src.exists() && project_target.exists()) {
+        return Err("No src and target directories.")
+    };
+
+    let src_files = match fs::read_dir(project_src) {
+        Ok(files) => {
+            files.filter_map(|f| f.ok())
+                .map(|f| f.path())
+                .filter(|f| f.extension().unwrap() == "cpp")
+        },
+        Err(_) => return Err("Couldn't read source directory.")
+    };
+    
+    let project_name = match project_dir.file_name() {
+        Some(name) => name,
+        None => return Err("Couldn't get project name.")
+    };
+
+    let output_file = project_target.join(project_name);
+
+    let output_args = ["-o", output_file.to_str().unwrap()];
+
+    match Command::new("g++").args(output_args).args(src_files).spawn() {
+        Ok(mut compiler) => {
+            if compiler.wait().is_err() {
+                return Err("Compilation failed.")
+            };
+        },
+        Err(_) => return Err("Couldn't start compiler.")
+    };
+    
+    Ok(())
+}
+
+fn run_project() -> Result<(), &'static str> {
+    let project_dir = match env::current_dir() {
+        Ok(path) => path,
+        Err(_) => return Err("Couldn't access project directory.")
+    };
+    
+    let project_target = project_dir.join("target");
+
+    let project_name = match project_dir.file_name() {
+        Some(name) => name,
+        None => return Err("Couldn't get project name.")
+    };
+
+    let project_excecutable = project_target.join(project_name);
+    
+    let _ = match Command::new(project_excecutable).spawn() {
+        Ok(mut child) => child.wait(),
+        Err(_) => return Err("Couldn't excecute project file.")
+    };
+
+    Ok(())
+}
+
+fn main() {
+    let mut args = env::args();
+    args.next();  // Discard excecutable name
+
+    let command = args.next().expect("No command provided.");
+
+    if command == "new" {
+        let project_name = args.next().expect("No project name provided.");
+        println!("Creating new project {project_name}...");
+        match new_project(&project_name) {
+            Ok(_) => println!("Project {project_name} created succesfully!"),
+            Err(err) => eprintln!("{err}")
+        };
+    } else if command == "build" {
+        println!("Building project...");
+        match build_project() {
+            Ok(_) => println!("Project built succesfully!"),
+            Err(err) => eprintln!("{err}")
+        };
+    } else if command == "run" {
+        println!("Building project...");
+        match build_project() {
+            Ok(_) => println!("Project built succesfully!"),
+            Err(err) => {
+                eprintln!("{err}"); 
+                return
+            },
+        };
+        println!("Running project...");
+        if let Err(err) = run_project() {
+            eprintln!("{err}");
+        };
+    } else {
+        eprintln!("Invalid command provided.");
+    };
+}