add graphen-cli

Author: timon-schelling

desktop/bundle/build.rs

@@ -1,7 +1,13 @@
 fn main() {
 	println!("cargo:rerun-if-env-changed=CARGO_PROFILE");
 	println!("cargo:rerun-if-env-changed=PROFILE");
-	let profile = std::env::var("CARGO_PROFILE").or_else(|_| std::env::var("PROFILE")).unwrap();
+	let mut profile = std::env::var("CARGO_PROFILE").or_else(|_| std::env::var("PROFILE")).unwrap();
+	if profile == "release"
+		&& let Ok(debug_str) = std::env::var("DEBUG")
+		&& debug_str.parse().unwrap_or(false)
+	{
+		profile = "profiling".to_string();
+	}
 	println!("cargo:rustc-env=CARGO_PROFILE={profile}");
 
 	println!("cargo:rerun-if-env-changed=DEP_CEF_DLL_WRAPPER_CEF_DIR");

desktop/bundle/src/common.rs

@@ -29,8 +29,7 @@ pub(crate) fn cef_path() -> PathBuf {
 }
 
 pub(crate) fn build_bin(package: &str, bin: Option<&str>) -> Result<PathBuf, Box<dyn Error>> {
-	let profile = &profile_name();
-	let mut args = vec!["build", "--package", package, "--profile", profile];
+	let mut args = vec!["build", "--package", package, "--profile", profile_name()];
 	if let Some(bin) = bin {
 		args.push("--bin");
 		args.push(bin);

desktop/bundle/src/linux.rs

@@ -6,8 +6,10 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
 	// TODO: Implement bundling for linux
 
 	// TODO: Consider adding more useful cli
-	if std::env::args().any(|a| a == "open") {
-		run_command(&app_bin.to_string_lossy(), &[]).expect("failed to open app");
+	let args: Vec<String> = std::env::args().collect();
+	if let Some(pos) = args.iter().position(|a| a == "open") {
+		let extra_args: Vec<&str> = args[pos + 1..].iter().map(|s| s.as_str()).collect();
+		run_command(&app_bin.to_string_lossy(), &extra_args).expect("failed to open app");
 	} else {
 		eprintln!("Binary built and placed at {}", app_bin.to_string_lossy());
 		eprintln!("Bundling for Linux is not yet implemented.");

desktop/bundle/src/mac.rs

@@ -22,9 +22,11 @@ pub fn main() -> Result<(), Box<dyn Error>> {
 	let app_dir = bundle(&profile_path, &app_bin, &helper_bin);
 
 	// TODO: Consider adding more useful cli
-	if std::env::args().any(|a| a == "open") {
+	let args: Vec<String> = std::env::args().collect();
+	if let Some(pos) = args.iter().position(|a| a == "open") {
+		let extra_args: Vec<&str> = args[pos + 1..].iter().map(|s| s.as_str()).collect();
 		let executable_path = app_dir.join(EXEC_PATH).join(APP_NAME);
-		run_command(&executable_path.to_string_lossy(), &[]).expect("failed to open app");
+		run_command(&executable_path.to_string_lossy(), &extra_args).expect("failed to open app");
 	}
 
 	Ok(())

desktop/bundle/src/win.rs

@@ -12,9 +12,11 @@ pub fn main() -> Result<(), Box<dyn Error>> {
 	let executable = bundle(&profile_path(), &app_bin);
 
 	// TODO: Consider adding more useful cli
-	if std::env::args().any(|a| a == "open") {
+	let args: Vec<String> = std::env::args().collect();
+	if let Some(pos) = args.iter().position(|a| a == "open") {
 		let executable_path = executable.to_string_lossy();
-		run_command(&executable_path, &[]).expect("failed to open app")
+		let extra_args: Vec<&str> = args[pos + 1..].iter().map(|s| s.as_str()).collect();
+		run_command(&executable_path, &extra_args).expect("failed to open app")
 	}
 
 	Ok(())

tools/building/src/deps.rs

@@ -26,6 +26,7 @@ fn dependencies(task: &Task) -> Vec<Dependency> {
 			args: &["--version"],
 			name: "cargo-about",
 			install: Some("cargo install cargo-about"),
+			skip: Some(&|task| matches!(task.target, Target::Cli)),
 			..Default::default()
 		},
 		Dependency {
@@ -39,7 +40,7 @@ fn dependencies(task: &Task) -> Vec<Dependency> {
 					Task {
 						target: Target::Web,
 						action: Action::Run,
-						profile: _
+						..
 					}
 				)
 			}),
@@ -51,19 +52,21 @@ fn dependencies(task: &Task) -> Vec<Dependency> {
 			name: "wasm-bindgen-cli",
 			version: Some("0.2.100"),
 			install: Some("cargo install -f wasm-bindgen-cli@0.2.100"),
-			..Default::default()
+			skip: Some(&|task| matches!(task.target, Target::Cli)),
 		},
 		Dependency {
 			command: "wasm-pack",
 			args: &["--version"],
 			name: "wasm-pack",
 			install: Some("cargo install wasm-pack"),
+			skip: Some(&|task| matches!(task.target, Target::Cli)),
 			..Default::default()
 		},
 		Dependency {
 			command: "node",
 			args: &["--version"],
 			name: "Node.js",
+			skip: Some(&|task| matches!(task.target, Target::Cli)),
 			..Default::default()
 		},
 		Dependency {

tools/building/src/lib.rs

@@ -6,6 +6,7 @@ pub mod deps;
 pub enum Target {
 	Web,
 	Desktop,
+	Cli,
 }
 
 pub enum Action {
@@ -24,31 +25,45 @@ pub struct Task {
 	pub target: Target,
 	pub action: Action,
 	pub profile: Profile,
+	pub args: Vec<String>,
 }
 
 impl Task {
 	pub fn parse(args: &[&str]) -> Option<Self> {
+		let split = args.iter().position(|a| *a == "--").unwrap_or(args.len());
+		let passthru_args = args[split..].iter().skip(1).map(|s| s.to_string()).collect();
+		let args = &args[..split];
+
 		let (target, rest) = match args.first() {
 			Some(&"desktop") => (Target::Desktop, &args[1..]),
 			Some(&"web") => (Target::Web, &args[1..]),
-			_ => (Target::Web, args),
+			Some(&"cli") => (Target::Cli, &args[1..]),
+			Some(&"help") => return None,
+			None => (Target::Web, args),
+			_ => return None,
 		};
 
 		let (action, rest) = match rest.first() {
 			Some(&"build") => (Action::Build, &rest[1..]),
 			Some(&"run") => (Action::Run, &rest[1..]),
-			_ => (Action::Run, rest),
+			None => (Action::Run, rest),
+			_ => return None,
 		};
 
-		let profile = match rest.first().copied().unwrap_or_default() {
-			"" => Profile::Default,
-			"release" => Profile::Release,
-			"debug" => Profile::Debug,
-			"profiling" => Profile::Profiling,
+		let profile = match rest.first() {
+			Some(&"release") => Profile::Release,
+			Some(&"debug") => Profile::Debug,
+			Some(&"profiling") => Profile::Profiling,
+			None => Profile::Default,
 			_ => return None,
 		};
 
-		Some(Task { target, action, profile })
+		Some(Task {
+			target,
+			action,
+			profile,
+			args: passthru_args,
+		})
 	}
 }
 

tools/building/src/main.rs

@@ -4,13 +4,16 @@ use building::*;
 
 fn usage() {
 	eprintln!();
-	eprintln!("Usage: cargo run [<command>] [release|debug|profiling]");
+	eprintln!("Usage: cargo run [<command>] [release|debug|profiling] -- [args...]");
 	eprintln!();
 	eprintln!("Commands:");
 	eprintln!("  web [run]         Run the web app on local dev server");
 	eprintln!("  web build         Build the web app");
 	eprintln!("  desktop [run]     Run the desktop app");
 	eprintln!("  desktop build     Build the desktop app");
+	eprintln!("  cli [run]         Run the Graphen CLI");
+	eprintln!("  cli build         Build the Graphen CLI");
+	eprintln!("  help              Show this message");
 	eprintln!();
 }
 
@@ -45,29 +48,30 @@ fn run_task(task: &Task) -> Result<(), Error> {
 		(Target::Web, Action::Build, Profile::Release | Profile::Default) => npm_run_in_frontend_dir("build")?,
 		(Target::Web, Action::Build, Profile::Profiling) => npm_run_in_frontend_dir("build-profiling")?,
 
-		(Target::Desktop, Action::Run, Profile::Debug | Profile::Default) => {
-			npm_run_in_frontend_dir("build-native-dev")?;
+		(Target::Desktop, action, profile) => {
+			if matches!((action, profile), (_, Profile::Release) | (Action::Build, Profile::Default)) {
+				npm_run_in_frontend_dir("build-native")?;
+			} else {
+				npm_run_in_frontend_dir("build-native-dev")?;
+			};
 			run("cargo run -p third-party-licenses --features desktop")?;
-			run("cargo run -p graphite-desktop-bundle -- open")?;
-		}
-		(Target::Desktop, Action::Run, Profile::Release) => {
-			npm_run_in_frontend_dir("build-native")?;
-			run("cargo run -p third-party-licenses --features desktop")?;
-			run("cargo run -r -p graphite-desktop-bundle -- open")?;
-		}
-		(Target::Desktop, Action::Run, Profile::Profiling) => todo!("profiling run for desktop"),
 
-		(Target::Desktop, Action::Build, Profile::Debug) => {
-			npm_run_in_frontend_dir("build-native-dev")?;
-			run("cargo run -p third-party-licenses --features desktop")?;
-			run("cargo run -p graphite-desktop-bundle")?;
+			let cargo_profile = match profile {
+				Profile::Debug | Profile::Default => "dev",
+				Profile::Release => "release",
+				Profile::Profiling => "profiling",
+			};
+			let args = if let Action::Run = action { format!(" -- open {}", task.args.join(" ")) } else { "".to_string() };
+			run(&format!("cargo run --profile {cargo_profile} -p graphite-desktop-bundle{args}"))?;
 		}
-		(Target::Desktop, Action::Build, Profile::Release | Profile::Default) => {
-			npm_run_in_frontend_dir("build-native")?;
-			run("cargo run -p third-party-licenses --features desktop")?;
-			run("cargo run -r -p graphite-desktop-bundle")?;
-		}
-		(Target::Desktop, Action::Build, Profile::Profiling) => todo!("profiling build for desktop"),
+
+		(Target::Cli, Action::Run, Profile::Debug | Profile::Default) => run(&format!("cargo run -p graphene-cli -- {}", task.args.join(" ")))?,
+		(Target::Cli, Action::Run, Profile::Release) => run(&format!("cargo run -r -p graphene-cli -- {}", task.args.join(" ")))?,
+		(Target::Cli, Action::Run, Profile::Profiling) => run(&format!("cargo run --profile profiling -p graphene-cli -- {}", task.args.join(" ")))?,
+
+		(Target::Cli, Action::Build, Profile::Debug) => run("cargo build -p graphene-cli")?,
+		(Target::Cli, Action::Build, Profile::Release | Profile::Default) => run("cargo build -r -p graphene-cli")?,
+		(Target::Cli, Action::Build, Profile::Profiling) => run("cargo build --profile profiling -p graphene-cli")?,
 	}
 	Ok(())
 }