Running now works

Author: Taxrosdev

src/build/mod.rs

@@ -21,7 +21,7 @@ struct BuildManifest {
     metadata: Metadata,
     /// A list of commands that this will give access to
     #[serde(default)]
-    commands: Vec<String>,
+    commands: Vec<PathBuf>,
     /// Directory relative to the manifest
     directory: PathBuf,
     /// Edition

src/lib.rs

@@ -4,4 +4,5 @@ pub mod chunks;
 mod crypto;
 pub mod network;
 pub mod repo;
+pub mod run;
 mod utils;

src/main.rs

@@ -1,9 +1,10 @@
-use anyhow::Result;
+use anyhow::{Result, bail};
 use clap::{Parser, Subcommand};
 use comfy_table::Table;
 use flint::{
     build::build,
-    repo::{self, update_manifest},
+    repo::{self, get_package, update_manifest},
+    run::{install, start},
 };
 use std::{
     fs,
@@ -18,7 +19,6 @@ mod utils;
 /// Simple program to greet a person
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
-#[command(styles = CLAP_STYLING)]
 struct Args {
     /// Install system-wide (requires root)
     #[arg(long, conflicts_with = "user")]
@@ -45,16 +45,37 @@ enum Command {
         repo_name: String,
     },
     /// Install a package
-    Install,
+    Install {
+        /// The Repository to install from
+        #[arg(long)]
+        repo_name: Option<String>,
+        /// The package to install
+        package: String,
+    },
     /// Remove a package
-    Remove,
+    Remove {
+        repo_name: Option<String>,
+        package: String,
+    },
     /// Interact with bundles
     Bundle {
         #[command(subcommand)]
         command: BundleCommands,
     },
     /// Updates a repository and its packages
     Update,
+    /// Run a package's entrypoint
+    Run {
+        /// The Repository the package is in
+        #[arg(long)]
+        repo_name: Option<String>,
+        /// The package to install
+        package: String,
+        /// The entrypoint in question. Will default to the first entrypoint
+        entrypoint: Option<String>,
+        /// Extra arguments
+        args: Option<Vec<String>>,
+    },
 }
 
 #[derive(Subcommand)]
@@ -118,106 +139,179 @@ fn main() -> Result<()> {
     };
 
     match args.command {
-        Command::Repo { command } => match command {
-            RepoCommands::Create { repo_name } => repo::create(&path.join(repo_name))?,
-
-            RepoCommands::List => {
-                let mut table = Table::new();
-
-                table.set_header(vec![
-                    "Name",
-                    "Title",
-                    "URL",
-                    "Hash Kind",
-                    "Homepage",
-                    "License",
-                    "Version",
-                ]);
+        Command::Repo { command } => repo_commands(path, command)?,
+
+        Command::Build {
+            build_manifest_path,
+            repo_name,
+        } => {
+            build(&build_manifest_path, &path.join(repo_name))?;
+        }
+
+        Command::Install { repo_name, package } => {
+            let target_repo_path: PathBuf = if let Some(repo_name) = repo_name {
+                path.join(repo_name)
+            } else {
+                let mut possible_repos = Vec::new();
 
                 for repo_entry in fs::read_dir(path)? {
                     let repo_dir = repo_entry?;
-                    let repo_name = repo_dir.file_name();
-                    let repo_name_str = repo_name.to_str().unwrap();
-
-                    let repo = repo::read_manifest(&repo_dir.path())?;
-
-                    table.add_row(vec![
-                        &repo_name_str,
-                        repo.metadata.title.unwrap_or_default().as_str(),
-                        &repo.updates_url.unwrap_or_default(),
-                        &repo.hash_kind.to_string(),
-                        &repo.metadata.homepage_url.unwrap_or_default(),
-                        &repo.metadata.license.unwrap_or_default(),
-                        &repo.metadata.version.unwrap_or_default(),
-                    ]);
+                    let package = get_package(&repo_dir.path(), &package);
+
+                    if package.is_ok() {
+                        possible_repos.push((repo_dir.path(), package?));
+                    }
                 }
 
-                println!("{table}");
-            }
+                if possible_repos.is_empty() {
+                    bail!("No Repositories contain that package.")
+                }
 
-            RepoCommands::Add {
-                repo_name,
-                remote_url,
-            } => todo!(),
+                if possible_repos.len() == 1 {
+                    possible_repos.first().unwrap().0.clone()
+                } else {
+                    todo!(
+                        "Multiple Repositories contain Multiple versions of this package. Handling for this is currently not implemented."
+                    )
+                }
+            };
 
-            RepoCommands::Remove { repo_name } => {
-                fs::remove_dir_all(path.join(repo_name))?;
-            }
+            install(&target_repo_path, &package)?;
+        }
 
-            RepoCommands::Update {
-                homepage_url,
-                license,
-                title,
-                version,
-                repo_name,
-            } => {
-                let repo_path = &path.join(repo_name);
-                let mut repo = repo::read_manifest(repo_path)?;
-
-                if title.is_some() {
-                    repo.metadata.title = title;
-                }
-                if homepage_url.is_some() {
-                    repo.metadata.homepage_url = homepage_url;
+        Command::Remove { repo_name, package } => todo!(),
+
+        Command::Bundle { command } => todo!(),
+
+        Command::Update => todo!(),
+
+        Command::Run {
+            repo_name,
+            package,
+            entrypoint,
+            args,
+        } => {
+            let target_repo_path: PathBuf = if let Some(repo_name) = repo_name {
+                path.join(repo_name)
+            } else {
+                let mut possible_repos = Vec::new();
+
+                for repo_entry in fs::read_dir(path)? {
+                    let repo_dir = repo_entry?;
+                    let package = get_package(&repo_dir.path(), &package);
+
+                    if package.is_ok() {
+                        possible_repos.push((repo_dir.path(), package?));
+                    }
                 }
-                if license.is_some() {
-                    repo.metadata.license = license;
+
+                if possible_repos.is_empty() {
+                    bail!("No Repositories contain that package.")
                 }
-                if version.is_some() {
-                    repo.metadata.version = version;
+
+                if possible_repos.len() == 1 {
+                    possible_repos.first().unwrap().0.clone()
+                } else {
+                    todo!(
+                        "Multiple Repositories contain Multiple versions of this package. Handling for this is currently not implemented."
+                    )
                 }
+            };
+
+            let entrypoint = entrypoint.unwrap_or_else(|| {
+                let package = get_package(&target_repo_path, &package).unwrap();
 
-                let manifest_serialized = &serde_yaml::to_string(&repo)?;
-                let signature = sign(repo_path, manifest_serialized)?;
+                // TODO: Make this cleaner
+                package.commands.first().unwrap().to_str().unwrap().into()
+            });
 
-                update_manifest(repo_path, manifest_serialized, &signature.to_bytes())?;
+            start(
+                &target_repo_path,
+                &package,
+                &entrypoint,
+                args.unwrap_or_default(),
+            )?;
+        }
+    };
+
+    Ok(())
+}
+
+fn repo_commands(path: &Path, command: RepoCommands) -> Result<()> {
+    match command {
+        RepoCommands::Create { repo_name } => repo::create(&path.join(repo_name))?,
+
+        RepoCommands::List => {
+            let mut table = Table::new();
+
+            table.set_header(vec![
+                "Name",
+                "Title",
+                "URL",
+                "Hash Kind",
+                "Homepage",
+                "License",
+                "Version",
+            ]);
+
+            for repo_entry in fs::read_dir(path)? {
+                let repo_dir = repo_entry?;
+                let repo_name = repo_dir.file_name();
+                let repo_name_str = repo_name.to_str().unwrap();
+
+                let repo = repo::read_manifest(&repo_dir.path())?;
+
+                table.add_row(vec![
+                    &repo_name_str,
+                    repo.metadata.title.unwrap_or_default().as_str(),
+                    &repo.updates_url.unwrap_or_default(),
+                    &repo.hash_kind.to_string(),
+                    &repo.metadata.homepage_url.unwrap_or_default(),
+                    &repo.metadata.license.unwrap_or_default(),
+                    &repo.metadata.version.unwrap_or_default(),
+                ]);
             }
-        },
 
-        Command::Build {
-            build_manifest_path,
+            println!("{table}");
+        }
+        RepoCommands::Add {
             repo_name,
-        } => {
-            build(&build_manifest_path, &path.join(repo_name))?;
+            remote_url,
+        } => todo!(),
+
+        RepoCommands::Remove { repo_name } => {
+            fs::remove_dir_all(path.join(repo_name))?;
         }
 
-        Command::Install => todo!(),
+        RepoCommands::Update {
+            homepage_url,
+            license,
+            title,
+            version,
+            repo_name,
+        } => {
+            let repo_path = &path.join(repo_name);
+            let mut repo = repo::read_manifest(repo_path)?;
 
-        Command::Remove => todo!(),
+            if title.is_some() {
+                repo.metadata.title = title;
+            }
+            if homepage_url.is_some() {
+                repo.metadata.homepage_url = homepage_url;
+            }
+            if license.is_some() {
+                repo.metadata.license = license;
+            }
+            if version.is_some() {
+                repo.metadata.version = version;
+            }
 
-        Command::Bundle { command } => todo!(),
+            let manifest_serialized = &serde_yaml::to_string(&repo)?;
+            let signature = sign(repo_path, manifest_serialized)?;
 
-        Command::Update => todo!(),
+            update_manifest(repo_path, manifest_serialized, &signature.to_bytes())?;
+        }
     };
 
     Ok(())
 }
-
-pub const CLAP_STYLING: clap::builder::styling::Styles = clap::builder::styling::Styles::styled()
-    .header(clap_cargo::style::HEADER)
-    .usage(clap_cargo::style::USAGE)
-    .literal(clap_cargo::style::LITERAL)
-    .placeholder(clap_cargo::style::PLACEHOLDER)
-    .error(clap_cargo::style::ERROR)
-    .valid(clap_cargo::style::VALID)
-    .invalid(clap_cargo::style::INVALID);

src/repo/manifest.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use crate::chunks::{Chunk, HashKind};
 
 #[derive(serde::Deserialize, serde::Serialize, Debug, Clone)]
@@ -17,7 +19,7 @@ pub struct PackageManifest {
     pub id: String,
     pub aliases: Vec<String>,
     pub chunks: Vec<Chunk>,
-    pub commands: Vec<String>,
+    pub commands: Vec<PathBuf>,
 }
 
 /// All of these are user visible, and should carry no actual weight.

src/repo/mod.rs

@@ -117,6 +117,8 @@ pub fn remove_package(package_id: &str, repo_path: &Path) -> Result<()> {
 /// - Repository doesn't exist
 /// - ID doesn't exist inside the Repository
 pub fn get_package(repo_path: &Path, id: &str) -> Result<PackageManifest> {
+    println!("{repo_path:?}");
+
     let repo_manifest = read_manifest(repo_path)?;
 
     // Check ID's and aliases