add pkg init from

src/cli.rs

@@ -79,6 +79,10 @@ pub struct PackageInitCommand {
     #[argh(option)]
     /// base PKGBUILD from a package
     pub from: Option<String>,
+
+    #[argh(switch)]
+    /// print to stdout instead of creating PKGBUILD
+    pub stdout: bool,
 }
 
 #[derive(FromArgs, PartialEq, Debug)]

src/main.rs

@@ -318,21 +318,28 @@ async fn main() {
         }
         cli::PaccoCLICommands::Package(package_command) => match package_command.cmd {
             cli::PackageCommands::Init(init_args) => {
-                if let Some(from) = init_args.from {
-                    unimplemented!()
+                let content = if let Some(from) = init_args.from {
+                    let pkginfo = PackageFile::new(std::path::PathBuf::from(from)).pkginfo();
+                    pkginfo.pkgbuild()
                 } else {
                     let kind = init_args.kind.unwrap_or("init".to_string());
 
                     match kind.as_str() {
                         "init" => {
-                            std::fs::write("PKGBUILD", include_str!("../PKGBUILDS/PKGBUILD.init"))
-                                .unwrap();
+                            include_str!("../PKGBUILDS/PKGBUILD.init")
                         }
                         _ => {
                             println!("Unknown PKGBUILD kind {kind}");
                             std::process::exit(1);
                         }
                     }
+                    .to_string()
+                };
+
+                if init_args.stdout {
+                    println!("{content}");
+                } else {
+                    std::fs::write("PKGBUILD", content).unwrap();
                 }
             }
             cli::PackageCommands::Info(info_args) => {

src/pkg/package.rs

@@ -734,6 +734,16 @@ pub struct OptionalDependency {
     pub reason: Option<String>,
 }
 
+impl OptionalDependency {
+    pub fn as_str(&self) -> String {
+        if let Some(reason) = &self.reason {
+            format!("{}: {}", self.pkg, reason)
+        } else {
+            self.pkg.clone()
+        }
+    }
+}
+
 impl PackageInfo {
     pub fn new(keys: Vec<(String, String)>) -> Self {
         let mut info = Self::default();
@@ -856,4 +866,73 @@ impl PackageInfo {
 
         info
     }
+
+    pub fn gen_array(key: &str, vals: &[String]) -> String {
+        if vals.is_empty() {
+            return String::new();
+        }
+
+        let mut ret = format!("{key}=(");
+
+        for (index, val) in vals.iter().enumerate() {
+            if index == vals.len() - 1 {
+                ret.push_str(&format!("'{val}'"));
+            } else {
+                ret.push_str(&format!("'{val}' "));
+            }
+        }
+
+        ret.push_str(")\n");
+        ret
+    }
+
+    /// Generate a basic `PKGBUILD` from `PKGINFO`
+    pub fn pkgbuild(&self) -> String {
+        #[allow(non_snake_case)]
+        let mut PKGBUILD = String::new();
+
+        if let Some(packager) = &self.packager {
+            PKGBUILD.push_str(&format!("# Packager: {packager}\n\n"));
+        }
+
+        PKGBUILD.push_str(&format!("pkgbase={}\n", self.pkgbase));
+        PKGBUILD.push_str(&format!("pkgname={}\n", self.name));
+        PKGBUILD.push_str(&format!("pkgdesc={}\n", self.description));
+        PKGBUILD.push_str(&format!("pkgver={}\n", self.version));
+
+        let arch: Vec<_> = self.architectures.iter().map(|x| x.to_string()).collect();
+        PKGBUILD.push_str(&PackageInfo::gen_array("arch", &arch));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("license", &self.licenses));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("makedepends", &self.makedepends));
+        PKGBUILD.push_str(&PackageInfo::gen_array("depends", &self.dependencies));
+        PKGBUILD.push_str(&PackageInfo::gen_array("checkdepends", &self.check_depends));
+        PKGBUILD.push_str(&PackageInfo::gen_array(
+            "optdepends",
+            &self
+                .opt_depends
+                .iter()
+                .map(|x| x.as_str())
+                .collect::<Vec<_>>(),
+        ));
+
+        if let Some(website) = &self.website {
+            PKGBUILD.push_str(&format!("url={}\n", website));
+        }
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("provides", &self.provides));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("replaces", &self.replaces));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("backup", &self.backup));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("conflicts", &self.conflict));
+
+        PKGBUILD.push_str(&PackageInfo::gen_array("groups", &self.groups));
+
+        PKGBUILD.push_str("\npackage() {\n\trsync -avzhruP ../root/ \"$pkdir/\"\n}");
+
+        PKGBUILD
+    }
 }