Added a $BPM_PKG_ARCH variable to source script

Added a "keep" field to package descriptor files which will prevent the specified files from being overwritten
Completely revamped the bpm-setup script in the bpm-utils package

bpm_utils/package_utils.go

@@ -25,6 +25,7 @@ type PackageInfo struct {
 	License     string
 	Arch        string
 	Type        string
+	Keep        []string
 	Depends     []string
 	MakeDepends []string
 	Provides    []string
@@ -100,6 +101,167 @@ func ReadPackage(filename string) (*PackageInfo, error) {
 	return nil, errors.New("pkg.info not found in archive")
 }
 
+func ReadPackageScripts(filename string) (map[string]string, error) {
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
+		return nil, err
+	}
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	archive, err := gzip.NewReader(file)
+	if err != nil {
+		return nil, err
+	}
+	tr := tar.NewReader(archive)
+	ret := make(map[string]string)
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		if header.Name == "pre_install.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_install.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "pre_update.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_update.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_remove.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		}
+	}
+	err = archive.Close()
+	if err != nil {
+		return nil, err
+	}
+	err = file.Close()
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+type Operation uint8
+
+const (
+	Install Operation = 0
+	Update            = 1
+	Remove            = 2
+)
+
+func ExecutePackageScripts(filename, rootDir string, operation Operation, postOperation bool) error {
+	pkgInfo, err := ReadPackage(filename)
+	if err != nil {
+		return err
+	}
+	scripts, err := ReadPackageScripts(filename)
+	if err != nil {
+		return err
+	}
+
+	run := func(name, content string) error {
+		temp, err := os.CreateTemp("", name)
+		if err != nil {
+			return err
+		}
+		_, err = temp.WriteString(content)
+		if err != nil {
+			return err
+		}
+		cmd := exec.Command("/bin/bash", temp.Name())
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Dir = rootDir
+		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
+		depends := make([]string, len(pkgInfo.Depends))
+		copy(depends, pkgInfo.Depends)
+		for i := 0; i < len(depends); i++ {
+			depends[i] = fmt.Sprintf("\"%s\"", depends[i])
+		}
+		makeDepends := make([]string, len(pkgInfo.MakeDepends))
+		copy(makeDepends, pkgInfo.MakeDepends)
+		for i := 0; i < len(makeDepends); i++ {
+			makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
+		}
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DEPENDS=(%s)", strings.Join(depends, " ")))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_MAKE_DEPENDS=(%s)", strings.Join(makeDepends, " ")))
+		cmd.Env = append(cmd.Env, "BPM_PKG_TYPE=source")
+		err = cmd.Run()
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	if operation == Install {
+		if val, ok := scripts["pre_install.sh"]; !postOperation && ok {
+			err := run("pre_install.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := scripts["post_install.sh"]; postOperation && ok {
+			err := run("post_install.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	} else if operation == Update {
+		if val, ok := scripts["pre_update.sh"]; !postOperation && ok {
+			err := run("pre_update.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := scripts["post_update.sh"]; postOperation && ok {
+			err := run("post_update.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	} else if operation == Remove {
+		if val, ok := scripts["post_remove.sh"]; postOperation && ok {
+			err := run("post_remove.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 func ReadPackageInfo(contents string, defaultValues bool) (*PackageInfo, error) {
 	pkgInfo := PackageInfo{
 		Name:        "",
@@ -109,6 +271,7 @@ func ReadPackageInfo(contents string, defaultValues bool) (*PackageInfo, error)
 		License:     "",
 		Arch:        "",
 		Type:        "",
+		Keep:        nil,
 		Depends:     nil,
 		MakeDepends: nil,
 		Provides:    nil,
@@ -148,6 +311,9 @@ func ReadPackageInfo(contents string, defaultValues bool) (*PackageInfo, error)
 			pkgInfo.Arch = split[1]
 		case "type":
 			pkgInfo.Type = split[1]
+		case "keep":
+			pkgInfo.Keep = strings.Split(strings.Replace(split[1], " ", "", -1), ",")
+			pkgInfo.Keep = stringSliceRemoveEmpty(pkgInfo.Keep)
 		case "depends":
 			pkgInfo.Depends = strings.Split(strings.Replace(split[1], " ", "", -1), ",")
 			pkgInfo.Depends = stringSliceRemoveEmpty(pkgInfo.Depends)
@@ -175,7 +341,7 @@ func ReadPackageInfo(contents string, defaultValues bool) (*PackageInfo, error)
 	return &pkgInfo, nil
 }
 
-func CreateInfoFile(pkgInfo PackageInfo) string {
+func CreateInfoFile(pkgInfo PackageInfo, keepSourceFields bool) string {
 	ret := ""
 	ret = ret + "name: " + pkgInfo.Name + "\n"
 	ret = ret + "description: " + pkgInfo.Description + "\n"
@@ -188,9 +354,15 @@ func CreateInfoFile(pkgInfo PackageInfo) string {
 	}
 	ret = ret + "architecture: " + pkgInfo.Arch + "\n"
 	ret = ret + "type: " + pkgInfo.Type + "\n"
+	if len(pkgInfo.Keep) > 0 {
+		ret = ret + "keep (" + strconv.Itoa(len(pkgInfo.Keep)) + "): " + strings.Join(pkgInfo.Keep, ",") + "\n"
+	}
 	if len(pkgInfo.Depends) > 0 {
 		ret = ret + "depends (" + strconv.Itoa(len(pkgInfo.Depends)) + "): " + strings.Join(pkgInfo.Depends, ",") + "\n"
 	}
+	if len(pkgInfo.MakeDepends) > 0 && keepSourceFields {
+		ret = ret + "make_depends (" + strconv.Itoa(len(pkgInfo.MakeDepends)) + "): " + strings.Join(pkgInfo.MakeDepends, ",") + "\n"
+	}
 	if len(pkgInfo.Provides) > 0 {
 		ret = ret + "provides (" + strconv.Itoa(len(pkgInfo.Provides)) + "): " + strings.Join(pkgInfo.Provides, ",") + "\n"
 	}
@@ -216,7 +388,8 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 	if err != nil {
 		return err
 	}
-	if IsPackageInstalled(pkgInfo.Name, installDir) {
+	packageInstalled := IsPackageInstalled(pkgInfo.Name, installDir)
+	if packageInstalled {
 		oldFiles = GetPackageFiles(pkgInfo.Name, installDir)
 	}
 	if !force {
@@ -227,8 +400,18 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			return errors.New("Could not resolve all dependencies. Missing " + strings.Join(unresolved, ", "))
 		}
 	}
-
 	if pkgInfo.Type == "binary" {
+		if !packageInstalled {
+			err = ExecutePackageScripts(filename, installDir, Install, false)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = ExecutePackageScripts(filename, installDir, Update, false)
+			if err != nil {
+				return err
+			}
+		}
 		seenHardlinks := make(map[string]string)
 		for {
 			header, err := tr.Next()
@@ -239,7 +422,8 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 				return err
 			}
 			if strings.HasPrefix(header.Name, "files/") && header.Name != "files/" {
-				extractFilename := path.Join(installDir, strings.TrimPrefix(header.Name, "files/"))
+				trimmedName := strings.TrimPrefix(header.Name, "files/")
+				extractFilename := path.Join(installDir, trimmedName)
 				switch header.Typeflag {
 				case tar.TypeDir:
 					files = append(files, strings.TrimPrefix(header.Name, "files/"))
@@ -251,6 +435,13 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 						fmt.Println("Creating Directory: " + extractFilename)
 					}
 				case tar.TypeReg:
+					if _, err := os.Stat(extractFilename); err == nil {
+						if slices.Contains(pkgInfo.Keep, trimmedName) {
+							fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)")
+							files = append(files, trimmedName)
+							continue
+						}
+					}
 					err := os.Remove(extractFilename)
 					if err != nil && !os.IsNotExist(err) {
 						return err
@@ -378,8 +569,16 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			return err
 		}
 		fmt.Println("Running source.sh file...")
-		if err != nil {
-			return err
+		if !packageInstalled {
+			err = ExecutePackageScripts(filename, installDir, Install, false)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = ExecutePackageScripts(filename, installDir, Update, false)
+			if err != nil {
+				return err
+			}
 		}
 		cmd := exec.Command("/bin/bash", "-e", "source.sh")
 		cmd.Stdin = os.Stdin
@@ -387,10 +586,12 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 		cmd.Stderr = os.Stderr
 		cmd.Dir = temp
 		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", installDir))
 		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
 		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
 		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
 		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
 		depends := make([]string, len(pkgInfo.Depends))
 		copy(depends, pkgInfo.Depends)
 		for i := 0; i < len(depends); i++ {
@@ -434,6 +635,13 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 					fmt.Println("Creating Directory: " + extractFilename)
 				}
 			} else if d.Type().IsRegular() {
+				if _, err := os.Stat(extractFilename); err == nil {
+					if slices.Contains(pkgInfo.Keep, relFilename) {
+						fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)")
+						files = append(files, relFilename)
+						return nil
+					}
+				}
 				err := os.Remove(extractFilename)
 				if err != nil && !os.IsNotExist(err) {
 					return err
@@ -494,10 +702,17 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			compiledInfo = *pkgInfo
 			compiledInfo.Type = "binary"
 			compiledInfo.Arch = GetArch()
-			err = os.WriteFile(path.Join(compiledDir, "pkg.info"), []byte(CreateInfoFile(compiledInfo)), 0644)
+			err = os.WriteFile(path.Join(compiledDir, "pkg.info"), []byte(CreateInfoFile(compiledInfo, false)), 0644)
 			if err != nil {
 				return err
 			}
+			scripts, err := ReadPackageScripts(filename)
+			for key, val := range scripts {
+				err = os.WriteFile(path.Join(compiledDir, key), []byte(val), 0644)
+				if err != nil {
+					return err
+				}
+			}
 			sed := fmt.Sprintf("s/%s/files/", strings.Replace(strings.TrimPrefix(path.Join(temp, "/output/"), "/"), "/", `\/`, -1))
 			cmd := exec.Command("/usr/bin/tar", "-czvf", compiledInfo.Name+"-"+compiledInfo.Version+".bpm", "pkg.info", path.Join(temp, "/output/"), "--transform", sed)
 			cmd.Stdin = os.Stdin
@@ -505,11 +720,17 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			cmd.Stderr = os.Stderr
 			cmd.Dir = compiledDir
 			fmt.Printf("running command: %s %s\n", cmd.Path, strings.Join(cmd.Args, " "))
-			err := cmd.Run()
+			err = cmd.Run()
 			if err != nil {
 				return err
 			}
 			err = os.Remove(path.Join(compiledDir, "pkg.info"))
+			for key := range scripts {
+				err = os.Remove(path.Join(compiledDir, key))
+				if err != nil {
+					return err
+				}
+			}
 			if err != nil {
 				return err
 			}
@@ -580,6 +801,25 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 		return err
 	}
 
+	scripts, err := ReadPackageScripts(filename)
+	if err != nil {
+		return err
+	}
+	if val, ok := scripts["post_remove.sh"]; ok {
+		f, err = os.Create(path.Join(pkgDir, "post_remove.sh"))
+		if err != nil {
+			return err
+		}
+		_, err = f.WriteString(val)
+		if err != nil {
+			return err
+		}
+		err = f.Close()
+		if err != nil {
+			return err
+		}
+	}
+
 	err = archive.Close()
 	if err != nil {
 		return err
@@ -652,6 +892,17 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			}
 		}
 	}
+	if !packageInstalled {
+		err = ExecutePackageScripts(filename, installDir, Install, true)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = ExecutePackageScripts(filename, installDir, Update, true)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -869,6 +1120,10 @@ func setPackageInfo(pkg, contents, rootDir string) error {
 func RemovePackage(pkg, rootDir string) error {
 	installedDir := path.Join(rootDir, "var/lib/bpm/installed/")
 	pkgDir := path.Join(installedDir, pkg)
+	pkgInfo := GetPackageInfo(pkg, rootDir, false)
+	if pkgInfo == nil {
+		return errors.New("could not get package info")
+	}
 	files := GetPackageFiles(pkg, rootDir)
 	var symlinks []string
 	for _, file := range files {
@@ -931,6 +1186,37 @@ func RemovePackage(pkg, rootDir string) error {
 			return err
 		}
 	}
+	if _, err := os.Stat(path.Join(pkgDir, "post_remove.sh")); err == nil {
+		cmd := exec.Command("/bin/bash", path.Join(pkgDir, "post_remove.sh"))
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Dir = rootDir
+		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
+		depends := make([]string, len(pkgInfo.Depends))
+		copy(depends, pkgInfo.Depends)
+		for i := 0; i < len(depends); i++ {
+			depends[i] = fmt.Sprintf("\"%s\"", depends[i])
+		}
+		makeDepends := make([]string, len(pkgInfo.MakeDepends))
+		copy(makeDepends, pkgInfo.MakeDepends)
+		for i := 0; i < len(makeDepends); i++ {
+			makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
+		}
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DEPENDS=(%s)", strings.Join(depends, " ")))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_MAKE_DEPENDS=(%s)", strings.Join(makeDepends, " ")))
+		cmd.Env = append(cmd.Env, "BPM_PKG_TYPE=source")
+		err = cmd.Run()
+		if err != nil {
+			return err
+		}
+	}
 	err := os.RemoveAll(pkgDir)
 	if err != nil {
 		return err

main.go

@@ -17,7 +17,7 @@ import (
 /*   A simple-to-use package manager  */
 /* ---------------------------------- */
 
-var bpmVer = "0.1.6"
+var bpmVer = "0.2.0"
 
 var subcommand = "help"
 var subcommandArgs []string
@@ -84,7 +84,7 @@ func resolveCommand() {
 				fmt.Printf("Package (%s) could not be found\n", pkg)
 				continue
 			}
-			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*info))
+			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*info, true))
 			if n == len(packages)-1 {
 				fmt.Println("----------------")
 			}
@@ -112,7 +112,7 @@ func resolveCommand() {
 					fmt.Printf("Package (%s) could not be found\n", pkg)
 					continue
 				}
-				fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*info))
+				fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*info, true))
 				if n == len(packages)-1 {
 					fmt.Println("----------------")
 				}
@@ -133,7 +133,7 @@ func resolveCommand() {
 			if err != nil {
 				log.Fatalf("Could not read package\nError: %s\n", err)
 			}
-			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*pkgInfo))
+			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*pkgInfo, true))
 			fmt.Println("----------------")
 			verb := "install"
 			if pkgInfo.Type == "source" {
@@ -149,14 +149,14 @@ func resolveCommand() {
 					continue
 				}
 				if pkgInfo.Type == "source" {
-					if unresolved := bpm_utils.CheckMakeDependencies(pkgInfo, rootDir); len(unresolved) != 0 {
+					if unresolved := bpm_utils.CheckMakeDependencies(pkgInfo, "/"); len(unresolved) != 0 {
 						fmt.Printf("skipping... cannot %s package (%s) due to missing make dependencies: %s\n", verb, pkgInfo.Name, strings.Join(unresolved, ", "))
 						continue
 					}
 				}
 			}
 			if rootDir != "/" {
-				fmt.Println("Warning: Installing to " + rootDir)
+				fmt.Println("Warning: Operating in " + rootDir)
 			}
 			if !yesAll {
 				reader := bufio.NewReader(os.Stdin)
@@ -231,10 +231,10 @@ func resolveCommand() {
 				fmt.Printf("Package (%s) could not be found\n", pkg)
 				continue
 			}
-			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*pkgInfo))
+			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*pkgInfo, true))
 			fmt.Println("----------------")
 			if rootDir != "/" {
-				fmt.Println("Warning: Installing to " + rootDir)
+				fmt.Println("Warning: Operating in " + rootDir)
 			}
 			if !yesAll {
 				reader := bufio.NewReader(os.Stdin)
@@ -305,11 +305,10 @@ func resolveCommand() {
 }
 
 func printHelp() {
-	fmt.Println("\033[1m------Help------\033[0m")
-	fmt.Println("\033[1m\\ Command Format /\033[0m")
+	fmt.Println("\033[1m---- Command Format ----\033[0m")
 	fmt.Println("-> command format: bpm <subcommand> [-flags]...")
 	fmt.Println("-> flags will be read if passed right after the subcommand otherwise they will be read as subcommand arguments")
-	fmt.Println("\033[1m\\ Command List /\033[0m")
+	fmt.Println("\033[1m---- Command List ----\033[0m")
 	fmt.Println("-> bpm version | shows information on the installed version of bpm")
 	fmt.Println("-> bpm info [-R] | shows information on an installed package")
 	fmt.Println("       -R=<root_path> lets you define the root path which will be used")

test_packages/x86_64/bpm-utils/files/usr/bin/bpm-create

@@ -1,51 +0,0 @@
-#!/bin/bash
-if [ $# -eq 0 ]
-then
-  echo "No output package name given!"
-  exit 1
-fi
-
-output=$1
-
-if [[ ! "$output" =~ ^[a-z.A-Z0-9_-]{1,}$ ]]; then
-  echo "Invalid output name! The name must only contain letters, numbers, hyphens or underscores!"
-  exit 1
-fi
-
-type="binary"
-
-echo "Creating package with the name $output..."
-
-if [ -d files ]; then
-  echo "files/ directory found"
-else
-  if [ -f source.sh ]; then
-    type="source"
-    echo "source.sh file found"
-    if [ -d source-files ]; then
-      echo "source-files/ directory found"
-    fi
-  else
-    echo "files/ directory or source.sh file not found in $PWD"
-    exit 1
-  fi
-fi
-
-if [ -f pkg.info ]; then
-  echo "pkg.info file found"
-else
-  echo "pkg.info file not found in $PWD"
-  exit 1
-fi
-
-echo "Creating $type package as $output"
-
-if [[ "$type" == "binary" ]]; then
-  tar -czf "$output" files/ pkg.info
-else
-  if [ -d source-files ]; then
-    tar -czf "$output" source.sh source-files/ pkg.info
-  else
-    tar -czf "$output" source.sh pkg.info
-  fi
-fi

test_packages/x86_64/bpm-utils/files/usr/bin/bpm-setup

@@ -1,66 +1,154 @@
 #!/bin/bash
-if [ $# -lt 2 ]; then
-  echo "Arguments missing! Try 'bpm-setup <directory> <binary/source>'"
+
+usage () {
+  echo "------BPM-Setup options------"
+  echo "bpm-setup -D <directory> | Path to package directory"
+  echo "bpm-setup -y | Skips confirmation prompt"
+  echo "bpm-setup -n <name> | Set the package name (Defaults to \"package-name\")"
+  echo "bpm-setup -d <description> | Set the package description (Defaults to \"Default package description\")"
+  echo "bpm-setup -v <version> | Set the package version (Defaults to \"1.0\")"
+  echo "bpm-setup -u <url> | Set the package URL (Optional)"
+  echo "bpm-setup -l <licenses> | Set the package licenses (Optional)"
+  echo "bpm-setup -t <binary/source> | Set the package type to binary or source (Defaults to binary)"
+  echo "bpm-setup -s <source template file> | Use a default template file (Defaults to /etc/bpm-utils/source.default)"
+}
+
+if [ $# -eq 0 ]; then
+  usage
+  exit
+fi
+
+NAME="package-name"
+DESCRIPTION="Default package description"
+VERSION="1.0"
+#URL="https://my.project.url/ (Optional)"
+#LICENSE="Your project's license (Optional)"
+TYPE="binary"
+SOURCE_FILE="/etc/bpm-utils/source.default"
+
+while getopts "D:n:d:v:u:l:t:s:y" o; do
+  case "${o}" in
+    D)
+      DIRECTORY="${OPTARG}"
+      ;;
+    y)
+      CONFIRM=yes
+      ;;
+    n)
+      NAME="${OPTARG}"
+      ;;
+    d)
+      DESCRIPTION="${OPTARG}"
+      ;;
+    v)
+      VERSION="${OPTARG}"
+      ;;
+    u)
+      URL="${OPTARG}"
+      ;;
+    l)
+      LICENSE="${OPTARG}"
+      ;;
+    t)
+      TYPE="${OPTARG}"
+      ;;
+    s)
+      SOURCE_FILE="$(realpath ${OPTARG})"
+      ;;
+    *)
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+if [ -z "${DIRECTORY}" ]; then
+  echo "Required directory argument missing. Try 'bpm-setup -D <directory> [other options...]"
   exit 1
 fi
 
-output=$1
-type=$2
+if [[ ! "${DIRECTORY}" == "/"* ]]; then
+  DIRECTORY="${PWD}/${DIRECTORY}"
+fi
 
-if [[ ! "$output" =~ ^[a-zA-Z0-9_-]{1,}$ ]]; then
-  echo "Invalid output name! The name must only contain letters, numbers, hyphens or underscores!"
+if [ -e "${DIRECTORY}" ]; then
+  echo "This path already exists"
   exit 1
 fi
 
-if [[ "$type" != "binary" ]] && [[ "$type" != "source" ]]; then
+if [[ "$TYPE" != "binary" ]] && [[ "$TYPE" != "source" ]]; then
   echo "Invalid package type! Package type must be either 'binary' or 'source'"
   exit 1
 fi
 
-mkdir -pv $output
-cd $output
 
-if [[ "$type" == "binary" ]]; then
-  cat > pkg.info << EOF
-name: package_name
-description: Package Description
-version: 1.0
-url: your package's website/repository url. Optonal
-license: your package's license. Optional  
-architecture: $(uname -m)
-type: binary
-EOF
+if [ -z "${CONFIRM}" ]; then
+  echo "Setting up package working directory at ${DIRECTORY} with the following information:"
+  echo "Package name: $NAME"
+  echo "Package description: $DESCRIPTION"
+  echo "Package version: $VERSION"
+  if [ -z "${URL}" ]; then
+    echo "Package URL: Not set"
+  else
+    echo "Package URL: $URL"
+  fi
+  if [ -z "${LICENSE}" ]; then
+    echo "Package license: Not set"
+  else
+    echo "Package license: $LICENSE"
+  fi
+  
+  echo "Package type: $TYPE"
+  read -p "Create package directory? [y/N]: " CREATE
+  case $CREATE in
+    [Yy]* )
+      ;;
+    *)
+      echo "Exiting bpm-setup..."
+      exit
+      ;;
+  esac
+fi
+
+if ! mkdir -pv $DIRECTORY; then
+  echo "Could not create $DIRECTORY!"
+  exit 1
+fi
+
+cd $DIRECTORY
+
+touch pkg.info
+echo "name: ${NAME}" >> pkg.info
+echo "description: ${DESCRIPTION}" >> pkg.info
+echo "version: ${VERSION}" >> pkg.info
+if [ ! -z "${URL}" ]; then echo "url: ${URL}" >> pkg.info; fi
+if [ ! -z "${LICENSE}" ]; then echo "license: ${LICENSE}" >> pkg.info; fi
+
+if [[ "$TYPE" == "binary" ]]; then
+  echo "architecture: $(uname -m)" >> pkg.info
+  echo "type: binary" >> pkg.info
   mkdir -pv files
   echo "Package directory created successfully!"
   echo "Make sure to edit the pkg.info file with the appropriate information for your package"
-  echo "Add your binaries under the files/ directory. For example a binary called 'my_binary' should go under files/usr/bin/my_binary"
+  echo "Add your binaries under the 'files' directory. For example a binary called 'my_binary' should go under files/usr/bin/my_binary"
   echo "You can turn your package into a .bpm file use the 'bpm-create <name>' command"
 else
-  cat > pkg.info << EOF
-name: package_name
-description: Package Description
-version: 1.0
-url: your package's website/repository url. Optional
-license: your package's license. Optional
-architecture: any
-type: source
-EOF
-  cat > source.sh << 'EOF'
-# This is the source.sh script. It is executed by BPM in a temporary directory when compiling a source package
-# BPM expects there to be an 'output' directory under the root of the temporary directory after this script finishes executing, otherwise your program may not be correctly installed
-# It is recommended you create the 'output' directory along with a 'source' directory in the root of the temporary directory like this
-echo "Compiling my_program..."
-# Creating 'source' and 'output' directory variables
-source=$(pwd)/source
-output=$(pwd)/output
-# Creating the 'source' and 'output' directories
-mkdir $source
-mkdir $output
-# Downloading files
-git clone https://myrepo.com/repo.git source
-EOF
+  echo "architecture: any" >> pkg.info
+  echo "type: source" >> pkg.info
+  mkdir -pv source-files
+  if [ -f "${SOURCE_FILE}" ]; then
+    touch source.temp
+    cat "${SOURCE_FILE}" > source.temp
+    export NAME DESCRIPTION VERSION URL LICENSE TYPE
+    envsubst '$NAME:$DESCRIPTION:$VERSION:$URL:$LICENSE:$TYPE' < source.temp > source.sh
+    rm source.temp
+  else
+    echo "Source file at ${SOURCE_FILE} does not exist! Creating empty source.sh instead..."
+    touch source.sh
+  fi
   echo "Package directory created successfully!"
   echo "Make sure to edit the pkg.info file with the appropriate information for your package"
-  echo "Add your compilation code in the source.sh file. Follow the instructions on the template file on how to do properly compile your program"
-  echo "You can turn your package into a .bpm file use the 'bpm-create <name>' command"
+  echo "Add your compilation code in the source.sh file. Follow the instructions on the template file on how to properly create your compilation script"
+  echo "You can add additional files that will be used during compilation to the 'source-files' directory"
+  echo "You can turn your package into a .bpm file use the 'bpm-package <filename>' command"
 fi

test_packages/x86_64/bpm-utils/pkg.info

@@ -1,7 +1,8 @@
 name: bpm-utils
 description: Utilities to create BPM packages
-version: 1.3.0
+version: 2.0.0
 url: https://gitlab.com/bubble-package-manager/bpm/
 license: GPL3
-architecture: x86_64
+architecture: any
+keep: etc/bpm-utils/source.default
 type: binary

test_packages/x86_64/bpm/pkg.info

@@ -1,6 +1,6 @@
 name: bpm
 description: The Bubble Package Manager
-version: 0.1.6
+version: 0.2.0
 url: https://gitlab.com/bubble-package-manager/bpm/
 license: GPL3
 architecture: x86_64