buildscripts

Author: RogueMacro

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "grill"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["William Tetlie <william.tetlie@gmail.com>"]
 license-file = "LICENSE"

Cargo.toml

@@ -6,4 +6,5 @@ pub mod make;
 pub mod new;
 pub mod publish;
 pub mod purge;
+pub mod rebuild;
 pub mod update;

src/commands.rs

@@ -0,0 +1,86 @@
+use std::{borrow::Cow, fs, path::Path};
+
+use anyhow::Result;
+use indicatif::{ProgressBar, ProgressStyle};
+
+use crate::{paths, prelude::*};
+
+pub fn cli() -> App {
+    App::new("rebuild")
+        .about("Run the Build script for this package")
+        .arg(
+            Arg::new("all")
+                .long("all")
+                .short('a')
+                .help("Rebuild all packages")
+                .conflicts_with("pkgs"),
+        )
+        .arg(
+            Arg::new("pkgs")
+                .multiple_values(true)
+                .help("Rebuild the specified packages"),
+        )
+        .arg(Arg::new("quiet").long("quiet").short('q'))
+}
+
+pub fn exec(args: &ArgMatches) -> Result<()> {
+    let quiet = args.is_present("quiet");
+
+    if args.is_present("all") {
+        for path in fs::read_dir(paths::pkgs("."))? {
+            rebuild(&path?.path(), quiet)?;
+        }
+    } else if let Some(mut pkgs) = args.values_of("pkgs") {
+        for dir in fs::read_dir(paths::pkgs("."))? {
+            let dir = dir?;
+            let dir_name = dir.file_name();
+            let ident = dir_name.to_string_lossy();
+            let (pkg, _) = ident.rsplit_once('-').context("Invalid file name")?;
+
+            if pkgs.any(|v| v == ident || v == pkg) {
+                rebuild(&dir.path(), quiet)?;
+            }
+        }
+    }
+
+    rebuild(Path::new("."), quiet)
+}
+
+fn rebuild(path: &Path, quiet: bool) -> Result<()> {
+    let file_name = if path.ends_with(".") {
+        Cow::Owned(
+            std::env::current_dir()?
+                .file_name()
+                .context("Invalid file name")?
+                .to_string_lossy()
+                .to_string(),
+        )
+    } else {
+        path.file_name()
+            .context("Invalid file name")?
+            .to_string_lossy()
+    };
+
+    let spinner = if !quiet {
+        let spinner = ProgressBar::new_spinner()
+            .with_message(format!("{}", file_name))
+            .with_style(
+                ProgressStyle::default_spinner()
+                    .template("{prefix:>12} {msg} {spinner}")?
+                    .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈✔"),
+            );
+        spinner.enable_steady_tick(std::time::Duration::from_millis(100));
+        Some(spinner)
+    } else {
+        None
+    };
+
+    crate::ops::rebuild(path, spinner.as_ref())?;
+
+    if let Some(spinner) = spinner {
+        spinner.set_prefix(console::style("Finished").bright().green().to_string());
+        spinner.finish();
+    }
+
+    Ok(())
+}

src/commands/rebuild.rs

@@ -23,6 +23,7 @@ pub fn cli() -> App {
         .subcommand(commands::new::cli())
         .subcommand(commands::publish::cli())
         .subcommand(commands::purge::cli())
+        .subcommand(commands::rebuild::cli())
         .subcommand(commands::update::cli())
 }
 

src/lib.rs

@@ -18,6 +18,7 @@ fn main() -> Result<()> {
                 "new" => grill::commands::new::exec(args),
                 "publish" => grill::commands::publish::exec(args),
                 "purge" => grill::commands::purge::exec(args),
+                "rebuild" => grill::commands::rebuild::exec(args),
                 "update" => grill::commands::update::exec(args),
                 _ => bail!("Unkown command: {}", cmd),
             },

src/main.rs

@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 #[serde(rename_all = "PascalCase")]
 pub struct Manifest {
     pub package: Package,
+    pub buildscript: Option<Buildscript>,
     #[serde(default)]
     pub dependencies: HashMap<String, Dependency>,
     #[serde(default)]
@@ -80,6 +81,12 @@ pub struct Package {
     pub corlib: bool,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
+pub struct Buildscript {
+    pub path: PathBuf,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum Dependency {

src/manifest.rs

@@ -1,6 +1,10 @@
+pub mod beefbuild;
 pub mod init;
 pub mod install;
 pub mod make;
+pub mod rebuild;
 
+pub use init::*;
 pub use install::*;
 pub use make::*;
+pub use rebuild::*;

src/ops.rs

@@ -0,0 +1,40 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::{Command, Output},
+};
+
+use anyhow::{Context, Result};
+
+pub fn run<P>(path: P) -> Result<Output>
+where
+    P: AsRef<Path>,
+{
+    build(&path)?;
+
+    let mut command = create_command(path)?;
+    command.arg("-run");
+    Ok(command.output()?)
+}
+
+pub fn build<P>(path: P) -> Result<Output>
+where
+    P: AsRef<Path>,
+{
+    Ok(create_command(path)?.output()?)
+}
+
+fn create_command<P>(path: P) -> Result<Command>
+where
+    P: AsRef<Path>,
+{
+    let beefpath =
+        env::var("BeefPath").context("BeefPath not found. Are you sure Beef is installed?")?;
+    let mut exe = PathBuf::from(beefpath);
+    exe.push("bin");
+    exe.push("BeefBuild");
+
+    let mut command = Command::new(exe);
+    command.arg(format!("-workspace={}", path.as_ref().to_string_lossy()));
+    Ok(command)
+}

src/ops/beefbuild.rs

@@ -18,11 +18,12 @@ use crate::{
 /// Returns the path to the installed package and a bool indicating
 /// if the package was downloaded.
 pub fn install<S, C>(
+    ws: &Path,
     pkg: S,
     version: &Version,
     index: Option<&Index>,
     progress_callback: C,
-) -> Result<(PathBuf, bool)>
+) -> Result<(PathBuf, PathBuf, bool)>
 where
     S: AsRef<str>,
     C: FnMut(git2::Progress<'_>),
@@ -49,29 +50,31 @@ where
         .with_context(|| format!("{} is not a version of '{}'", version, pkg))?;
 
     let ident = format!("{}-{}", pkg, version);
-    let path = paths::pkg(".", &ident);
+    let path = paths::pkg(ws, Path::new(&ident));
     if path.exists() {
-        return Ok((path, false));
+        return Ok((paths::pkg(".", &ident), path, false));
     }
 
-    let (path, _) = install_git(
+    let (relative_path, full_path, _) = install_git(
+        ws,
         &entry.url,
         Some(&metadata.rev),
         Some(&ident),
         progress_callback,
     )?;
 
-    Ok((path, true))
+    Ok((relative_path, full_path, true))
 }
 
-/// Returns the path to the installed package and the revision
-/// that was checked out.
+/// Returns the path to the installed package, first relative to the workspace,
+/// then relative to the working directory. Last is the revision that was checked out.
 pub fn install_git<C>(
+    ws: &Path,
     url: &Url,
     rev: Option<&str>,
     pkg_ident: Option<&String>,
     mut progress_callback: C,
-) -> Result<(PathBuf, String)>
+) -> Result<(PathBuf, PathBuf, String)>
 where
     C: FnMut(git2::Progress<'_>),
 {
@@ -121,26 +124,28 @@ where
         // Dropping the repository gives us access to the directory
     }
 
-    let path = pkg_ident
-        .map(|ident| paths::pkg(".", ident))
+    let relative_path = pkg_ident
+        .map(|ident| paths::pkg("", ident))
         .unwrap_or_else(|| {
             let mut pkg = url.host().unwrap().to_string();
             pkg.push_str(&url.path().replace('/', "-").replace(".git", ""));
             pkg = format!("{}-{}", pkg, checkout_rev);
-            paths::pkg(".", &pkg)
+            paths::pkg("", &pkg)
         });
 
-    if path.exists() {
-        return Ok((path, checkout_rev));
+    let full_path = ws.join(&relative_path);
+
+    if full_path.exists() {
+        return Ok((relative_path, full_path, checkout_rev));
     }
 
-    fs::rename(paths::tmp(), &path).context("Failed to move tmp folder")?;
+    fs::rename(paths::tmp(), &full_path).context("Failed to move tmp folder")?;
 
     if pkg_ident.is_some() {
-        prepare_pkg(&path, pkg_ident.map(String::as_str))?;
+        prepare_pkg(&full_path, pkg_ident.map(String::as_str))?;
     }
 
-    Ok((path, checkout_rev))
+    Ok((relative_path, full_path, checkout_rev))
 }
 
 pub fn prepare_pkg(path: &Path, ident: Option<&str>) -> Result<()> {