updated patching process

README.md

@@ -10,6 +10,14 @@
 This is a "simple" script for building the Spitfire Browser based on Mozilla Firefox source code.
 </p>
 
+## Project Overview
+
+Spitfire Builder script is a tool designed to automate the building, patching, packaging, and uploading of the Spitfire Browser, which is based on the Mozilla Firefox source code. It streamlines tasks like:
+- Cloning and updating the Mozilla source repository.
+- Applying patches for Spitfire.
+- Building the browser for different platforms.
+- Compressing and uploading builts to a remote server.
+
 ## Dependencies
 
 - Mercurial (hg)
@@ -17,33 +25,84 @@ This is a "simple" script for building the Spitfire Browser based on Mozilla Fir
 - Golang (tested with v1.21)
 - Python 3.11 and pip3
 
-# Example usage:
+## Flags
 
-## Build:
+Below is a detailed description of all the flags supported by the Spitfire Builder script:
 
+### **General Flags**
+
+- **`-h`**:
+  Displays the help message and exits. Use this to see all available flags and their descriptions.
+
+### **Build Process Flags**
+
+- **`-a`**:
+  Perform all steps of the build process, including cleaning, updating the repository, building, and applying patches.
+- **`-b`**:
+  Compiles the source code without cleaning or updating.
+- **`--clean`**:
+  Cleans the build directory by removing temporary or cached files.
+- **`-u`**:
+  Updates the Mozilla source repository to the latest revision using Mercurial (`hg pull`).
+- **`--patches`**:
+  Applies custom patches to the source code.
+- **`-r`**:
+  Runs the built project after the build process completes successfully.
+
+### **Compression and Upload Flags**
+
+- **`-c`**:
+  Compresses the build output into a `.tar.gz` file. Use with the `--upload-path` flag to specify the directory to compress.
+- **`--upload`**:
+  Uploads the compressed build file to a remote server (e.g., SourceForge). Requires a configuration file (`sourceforge_config.json`) to define upload parameters.
+- **`--upload-path=<path>`**:
+  Specifies the directory or file to upload. This is required for both compression and uploading.
+
+### **Customization Flags**
+
+- **`-p=<path>`**:
+  Specifies the build directory path. If not provided, the default path is used.
+- **`-t=<target>`**:
+  Sets the target format for the build output. The format follows `component-arch-release-platform`.
+- **`-v=<version>`**:
+  Defines the version of the package. For nightly builds, the current date is used by default.
+- **`--component=<name>`**:
+  Sets the name of the component being built (default: 'browser').
+- **`--arch=<architecture>`**:
+  Specifies the architecture for the build (default: system architecture, e.g., `amd64`).
+- **`--release=<type>`**:
+  Specifies the release type (`stable`, `nightly`, etc.). Default is `nightly`.
+- **`--platform=<platform>`**:
+  Sets the platform for the build (default: system platform, e.g., `linux`).
+
+## Example usage:
+
+- **All steps**:
 ```sh
 go run . -a
 ```
 
-## Upload:
+- **Build only**:
+```sh
+go run . -b
+```
 
+- **Upload**:
 ```sh
 go run . --upload -c --upload-path=./mozilla-central/obj-x86_64-pc-linux-gnu/dist/bin
 ```
 
-## Build and upload:
-
+- **Build and upload**:
 ```sh
 go run . --upload -c --upload-path=./mozilla-central/obj-x86_64-pc-linux-gnu/dist/bin -a
 ```
 
-## Display all flags:
-
+- **Display all flags**:
 ```sh
 go run . -h
 ```
 
-### Config file for uploading example:
+## Config file for uploading example:
 
 *sourceforge_config.json*
 
@@ -67,7 +126,7 @@ A:amd64
 S:788506622
 I:3324483350
 T:Spitfire build
-U:https://spitfirebrowser.com/
+U:https://spitfirebrowser.xyz/
 L:AGPL-3.0
 o:browser
 m:Internet Addict
@@ -79,7 +138,7 @@ q:
 Z:905cd0cc2dea9e400e1ecd099462b6b19188a9f1
 ```
 
-## Repositary structure
+## Repository structure
 
 ```
 spitfire-browser/

go.mod

@@ -1,3 +1,3 @@
-module spitfire
+module spitfire-builder
 
 go 1.18

main.go

@@ -8,7 +8,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime" // for detecting system architecture and platform
-	"spitfire/spitfire"
+	"spitfire-builder/spitfire"
 	"time"
 	//"errors"
 )
@@ -141,7 +141,7 @@ func main() {
 		fmt.Printf("Resolved uploadPath: %s\n", uploadPath)
 	}
 
-	if all || buildFlag {
+	if all || buildFlag || patches || clean || update {
 		BuildProcess()
 	}
 
@@ -152,24 +152,24 @@ func main() {
 	spitfire.PrintErrors()
 }
 
-// BuildProcess handles the build process: downloading, cleaning, configuring, and building the project.
+// Update the BuildProcess function to pass patchesRepo
 func BuildProcess() {
 	sourcePath, err := spitfire.ResolvePath("./mozilla-central")
 	if err != nil {
 		log.Fatalf("Error resolving source path: %v", err)
 	}
 
-	patchesDir, err := spitfire.ResolvePath(filepath.Join(sourcePath, "Spitfire"))
-	if err != nil {
-		log.Fatalf("Error resolving patches directory: %v", err)
-	}
-
 	if all {
 		spitfire.DownloadSource(sourcePath, sourceRepo)
 		spitfire.DiscardChanges(sourcePath)
 		spitfire.CleanBuild(sourcePath)
 		spitfire.UpdateRepo(sourcePath)
-		spitfire.UpdatePatches(patchesDir, patchesRepo, sourcePath)
+
+		// Pass patchesRepo to ApplyPatches
+		if err := spitfire.ApplyPatches(sourcePath, patchesRepo); err != nil {
+			log.Fatalf("Error during patch application: %v", err)
+		}
+
 		spitfire.Configure(sourcePath)
 		spitfire.Build(sourcePath)
 		if run {
@@ -185,7 +185,11 @@ func BuildProcess() {
 		fmt.Println("Mozilla repository updated.")
 	} else if patches {
 		spitfire.DownloadSource(sourcePath, sourceRepo)
-		spitfire.UpdatePatches(patchesDir, patchesRepo, sourcePath)
+
+		// Pass patchesRepo to ApplyPatches
+		if err := spitfire.ApplyPatches(sourcePath, patchesRepo); err != nil {
+			log.Fatalf("Error during patch application: %v", err)
+		}
 		fmt.Println("Patches updated.")
 	} else if buildFlag {
 		spitfire.Configure(sourcePath)
@@ -283,28 +287,6 @@ func PackageAndUploadProcess() {
 	}
 }
 
-// // waitForPath checks if a path exists, waiting for up to maxWait seconds and retrying every interval seconds.
-// func waitForPath(path string, maxWait int, interval int) error {
-//     waited := 0
-//     for {
-//         if PathExists(path) {
-//             return nil // Path exists
-//         }
-//         if waited >= maxWait {
-//             return errors.New("path does not exist after waiting")
-//         }
-//         fmt.Printf("Waiting for path %s to exist...\n", path)
-//         time.Sleep(time.Duration(interval) * time.Second)
-//         waited += interval
-//     }
-// }
-
-// // PathExists checks if the path exists
-// func PathExists(path string) bool {
-//     _, err := os.Stat(path)
-//     return !os.IsNotExist(err)
-// }
-
 // restoreWorkingDirectory restores the initial working directory after any operation that might change it.
 func restoreWorkingDirectory() {
 	err := os.Chdir(initialDir)

spitfire/patch.go

@@ -0,0 +1,50 @@
+package spitfire
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+// ApplyPatches handles cloning and applying patches
+func ApplyPatches(sourcePath string, patchesRepo string) error {
+	// Define the patches repository and clone directory
+	patchesCloneDir := filepath.Join(sourcePath, "patches")
+	fmt.Printf("Source Path: %s\n", sourcePath)
+	fmt.Printf("Patches Clone Directory: %s\n", patchesCloneDir)
+	fmt.Printf("Patches Repository URL: %s\n", patchesRepo)
+
+	// Check if the patches directory already exists
+	if _, err := os.Stat(patchesCloneDir); os.IsNotExist(err) {
+		// Clone the patches repository
+		fmt.Println("Patches directory does not exist. Proceeding to clone.")
+		cmdClone := exec.Command("git", "clone", patchesRepo, patchesCloneDir)
+		cmdClone.Stdout = os.Stdout
+		cmdClone.Stderr = os.Stderr
+		if err := cmdClone.Run(); err != nil {
+			return fmt.Errorf("failed to clone patches repository: %v", err)
+		}
+		fmt.Println("Patches repository cloned successfully.")
+	} else {
+		fmt.Println("Patches directory already exists. Skipping clone.")
+	}
+
+	// Verify the directory exists
+	if _, err := os.Stat(patchesCloneDir); os.IsNotExist(err) {
+		return fmt.Errorf("patches directory not found after cloning: %s", patchesCloneDir)
+	}
+
+	// Apply the patches using `go run apply.go`
+	applyCmd := exec.Command("go", "run", "apply.go", "--path="+sourcePath)
+	applyCmd.Dir = patchesCloneDir // Run from the patches directory
+	applyCmd.Stdout = os.Stdout
+	applyCmd.Stderr = os.Stderr
+	fmt.Println("Applying patches...")
+	if err := applyCmd.Run(); err != nil {
+		return fmt.Errorf("failed to apply patches: %v", err)
+	}
+
+	fmt.Println("Patches applied successfully.")
+	return nil
+}