Feature: Pallet Engine (Add pallet - MVP)

Cargo.toml

@@ -17,20 +17,24 @@ console = "0.15"
 duct = "0.13"
 git2 = "0.18"
 log = "0.4"
-# semver = "1.0.20"
+semver = "1.0.20"
 strum = "0.26"
 strum_macros = "0.26"
 tempfile = "3.8"
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 url = { version = "2.5", optional = true }
 walkdir = "2.4"
+toml_edit = { version = "0.22.7" }
 regex="1.5.4"
 
 # contracts
 contract-build = { version = "4.0.0-rc.3", optional = true }
 contract-extrinsics = { version = "4.0.0-rc.3", optional = true }
 sp-core = { version = "30.0.0", optional = true }
-subxt-signer = { version = "0.34.0", features = ["subxt", "sr25519"], optional = true }
+subxt-signer = { version = "0.34.0", features = [
+    "subxt",
+    "sr25519",
+], optional = true }
 subxt = { version = "0.34.0", optional = true }
 ink_env = { version = "5.0.0-rc.2", optional = true }
 sp-weights = { version = "29.0.0", optional = true }
@@ -43,10 +47,18 @@ reqwest = { version = "0.11", optional = true }
 serde_json = { version = "1.0", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 symlink = { version = "0.1", optional = true }
-toml_edit = { version = "0.22", optional = true }
 tracing-subscriber = { version = "0.3", optional = true }
 zombienet-sdk = { git = "https://github.com/r0gue-io/zombienet-sdk", branch = "pop", optional = true }
 zombienet-support = { git = "https://github.com/r0gue-io/zombienet-sdk", branch = "pop", optional = true }
+uuid = { version = "1.7.0", features = ["v4"], optional = true }
+frame-support-procedural-tools = { version = "9.0.0", optional = true }
+proc-macro2 = { version = "1.0.70", features = [
+    "span-locations",
+], optional = true }
+quote = { version = "1.0.33", optional = true }
+syn = { version = "2.0.52", features = ["full"], optional = true }
+cfg-expr = { version = "0.15.5", optional = true }
+prettyplease = { version = "0.2.15", optional = true }
 
 [dev-dependencies]
 assert_cmd = "2.0.14"
@@ -72,11 +84,17 @@ parachain = [
     "dep:reqwest",
     "dep:serde_json",
     "dep:symlink",
-    "dep:toml_edit",
     "dep:tracing-subscriber",
     "dep:url",
     "dep:zombienet-sdk",
-    "dep:zombienet-support"
+    "dep:zombienet-support",
+    "uuid",
+    "frame-support-procedural-tools",
+    "proc-macro2",
+    "quote",
+    "syn",
+    "cfg-expr",
+    "prettyplease",
 ]
 e2e_parachain = []
 

README.md

@@ -57,7 +57,7 @@ There's also the shorter version:
 pop new parachain my-app -s DOT -d 6 -i 1_000_000_000
 ```
 
-To create a new pallet, simply `pop new pallet`. And that's it. You will have a new `pallet-template` ready for hacking.
+To create a new pallet, simply `pop new pallet`. And that's it. You will have a new `pallet-parachain-template` ready for hacking.
 To customize the new pallet you can follow these options:
 
 ```sh

src/commands/add/mod.rs

@@ -0,0 +1,85 @@
+#![cfg(feature = "parachain")]
+use std::path::PathBuf;
+
+use crate::engines::pallet_engine;
+use clap::{Args, Subcommand};
+use cliclack::{intro, outro};
+use console::style;
+
+#[derive(Args)]
+#[command(args_conflicts_with_subcommands = true)]
+pub(crate) struct AddArgs {
+	#[command(subcommand)]
+	commands: AddCommands,
+	#[arg(global = true, short, long = "runtime")]
+	/// Runtime path; for example: `sub0/runtime/src/lib.rs`
+	/// Runtime cargo manifest path will be inferred as `(parent of lib.rs)/Cargo.toml`
+	pub(crate) runtime_path: Option<String>,
+}
+#[derive(Subcommand)]
+#[command(subcommand_required = true)]
+pub(crate) enum AddCommands {
+	#[command(subcommand)]
+	/// Add a pallet
+	#[clap(alias = "p")]
+	Pallet(AddPallet),
+}
+
+#[derive(Subcommand, Clone)]
+#[command(subcommand_required = true)]
+pub(crate) enum AddPallet {
+	/// Insert `pallet-parachain-template` into the runtime.
+	Template,
+	/// Insert a frame-pallet into the runtime.
+	Frame(FrameArgs),
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct FrameArgs {
+	#[arg(short, long)]
+	// TODO: Not ready for use
+	pub(crate) name: String,
+}
+
+impl AddArgs {
+	pub(crate) fn execute(&self) -> anyhow::Result<()> {
+		match self.commands {
+			AddCommands::Pallet(ref cmd) => cmd.clone().execute(&self.runtime_path),
+		}
+	}
+}
+impl AddPallet {
+	pub(crate) fn execute(self, runtime_path: &Option<String>) -> anyhow::Result<()> {
+		let runtime_path = match runtime_path {
+			Some(ref s) => {
+				let path = PathBuf::from(s);
+				if !path.exists() {
+					anyhow::bail!("Invalid runtime path: {}", path.display());
+				}
+				path
+			},
+			None => {
+				// TODO: Fetch runtime either from cache
+				unimplemented!(
+					"provide a runtime path until feat:cache is implemented: --runtime <path>"
+				);
+			},
+		};
+		let pallet = match self {
+			AddPallet::Template => "pallet-parachain-template".to_string(),
+			AddPallet::Frame(FrameArgs { .. }) => {
+				eprintln!("Sorry, frame pallets cannot be added right now");
+				std::process::exit(1);
+				// format!("FRAME pallet-{name}")
+			},
+		};
+		intro(format!(
+			"{}: Adding pallet \"{}\"!",
+			style(" Pop CLI ").black().on_magenta(),
+			&pallet,
+		))?;
+		pallet_engine::execute(self, runtime_path.clone())?;
+		outro(format!("Added {}\n-> to {}", pallet, runtime_path.display()))?;
+		Ok(())
+	}
+}

src/commands/mod.rs

@@ -1,3 +1,4 @@
+pub(crate) mod add;
 pub(crate) mod build;
 pub(crate) mod call;
 pub(crate) mod new;

src/commands/new/pallet.rs

@@ -10,7 +10,7 @@ use std::fs;
 
 #[derive(Args)]
 pub struct NewPalletCommand {
-	#[arg(help = "Name of the pallet", default_value = "pallet-template")]
+	#[arg(help = "Name of the pallet", default_value = "pallet-parachain-template")]
 	pub(crate) name: String,
 	#[arg(short, long, help = "Name of authors", default_value = "Anonymous")]
 	pub(crate) authors: Option<String>,

src/engines/pallet_engine/dependency.rs

@@ -0,0 +1,137 @@
+//! Dependency representations for Pallets
+use std::path::{self, Path, PathBuf};
+use strum_macros::{Display, EnumString};
+
+#[derive(EnumString, Display, Debug)]
+pub(super) enum Features {
+	#[strum(serialize = "std")]
+	Std,
+	#[strum(serialize = "runtime-benchmarks")]
+	RuntimeBenchmarks,
+	#[strum(serialize = "try-runtime")]
+	TryRuntime,
+	/// Custom feature
+	Custom(String),
+}
+#[derive(Display, Debug, Clone)]
+pub(super) enum Location {
+	/// Local path is form `path = "X"`
+	Local(std::path::PathBuf, Option<semver::Version>),
+	/// `git = {url}`
+	Git(reqwest::Url, Option<semver::Version>),
+	/// String should be of format `version = "X"`
+	CratesIO(semver::Version),
+}
+impl From<reqwest::Url> for Location {
+	fn from(url: reqwest::Url) -> Self {
+		Self::Git(url, None)
+	}
+}
+impl From<std::path::PathBuf> for Location {
+	fn from(path: std::path::PathBuf) -> Self {
+		Self::Local(path, None)
+	}
+}
+impl From<(std::path::PathBuf, semver::Version)> for Location {
+	fn from(info: (std::path::PathBuf, semver::Version)) -> Self {
+		Self::Local(info.0, Some(info.1))
+	}
+}
+impl<'a> From<&'a std::path::Path> for Location {
+	fn from(path: &'a std::path::Path) -> Self {
+		Self::Local(path.to_path_buf(), None)
+	}
+}
+impl<'a> From<(&'a std::path::Path, semver::Version)> for Location {
+	fn from(info: (&'a std::path::Path, semver::Version)) -> Self {
+		Self::Local(info.0.to_path_buf(), Some(info.1.into()))
+	}
+}
+impl From<semver::Version> for Location {
+	fn from(version: semver::Version) -> Self {
+		Self::CratesIO(version)
+	}
+}
+impl Into<String> for Location {
+	fn into(self) -> String {
+		match self {
+			Location::Local(path, Some(version)) => {
+				format!("{{ path = \"{}\", version = \"{}\" }}", path.display(), version)
+			},
+			Location::Local(path, _) => format!("{{ path = \"{}\" }}", path.display()),
+			Location::Git(url, Some(version)) => {
+				format!("{{ git = \"{}\", version = \"{}\" }}", url, version)
+			},
+			Location::Git(url, _) => format!("{{ git = \"{}\" }}", url),
+			Location::CratesIO(version) => format!("{{ version = \"{}\" }}", version),
+		}
+	}
+}
+impl Into<toml_edit::Value> for Location {
+	fn into(self) -> toml_edit::Value {
+		let s = Into::<String>::into(self);
+		let t = s
+			.parse::<toml_edit::Value>()
+			.expect("Location String parse as Toml Value failed");
+		toml_edit::Value::InlineTable(
+			t.as_inline_table().expect(" Parsed Location -> ILT cast infallible").to_owned(),
+		)
+	}
+}
+
+#[derive(Debug)]
+pub(super) struct Dependency {
+	/// Name for the dependency
+	pub(super) name: String,
+	/// Additional features that need to be enabled. Format -> {name}/{feature}
+	pub(super) features: Vec<Features>,
+	/// Maybe local path, git url, or from crates.io in which case we will use this for version
+	pub(super) path: Location,
+	/// Default features such as `std` are disabled by default for runtime pallet dependencies
+	pub(super) default_features: bool,
+}
+
+impl Dependency {
+	/// Generate the main dependency as an inline table
+	pub(super) fn entry(&self) -> toml_edit::InlineTable {
+		let mut t = toml_edit::Table::new();
+		let location = Into::<toml_edit::Value>::into(self.path.clone());
+		t.extend(
+			location
+				.as_inline_table()
+				.expect("Location to String should produce valid inline table")
+				.to_owned(),
+		);
+		t["default-features"] = toml_edit::value(self.default_features);
+		t.into_inline_table()
+	}
+	/// Create dependencies required for adding a local pallet to runtime
+	/// $(workspace_root)/pallets/pallet-name
+	// Todo: Some values are hardcoded for now as this only deals with the pallet-parachain-template
+	// Should be moved to args once that's not the case
+	pub(super) fn local_template_runtime(pallet_name: &'static str, workspace: &PathBuf) -> Self {
+		let name = format!("{pallet_name}");
+		Self {
+			features: vec![Features::RuntimeBenchmarks, Features::TryRuntime, Features::Std],
+			path: (
+				// The reason is, `pop new pallet` places a new pallet on $(workspace_root)/pallets
+				workspace.join("pallets/").join(&name).to_path_buf(),
+				semver::Version::new(1, 0, 0),
+			)
+				.into(),
+			default_features: false,
+			name,
+		}
+	}
+	// TODO: Remove code - Node doesn't require template pallet deps by default
+	// but this maybe desirable for custom pallets.
+	// /// Create dependencies required for adding a pallet-parachain-template to node
+	// pub(super) fn template_node() -> Self {
+	// 	Self {
+	// 		features: vec![Features::RuntimeBenchmarks, Features::TryRuntime],
+	// 		// TODO hardcode for now
+	// 		path: format!("../pallets/pallet-parachain-template"),
+	// 		default_features: true,
+	// 	}
+	// }
+}