refactor: Update version information in resources.rc file

Author: itsfuad

compressor/compressor.go

@@ -8,15 +8,16 @@ import (
 	"os"
 	"path"
 	"sync"
+	"path/filepath"
 
 	"file-compressor/utils"
 )
 
-// Compress compresses the specified files into a single compressed file.
+// Compress compresses the specified files or folders into a single compressed file.
 func Compress(filenameStrs []string, outputDir *string, password *string) error {
-	// Check if there are files to compress
+	// Check if there are files or folders to compress
 	if len(filenameStrs) == 0 {
-		return errors.New("no files to compress")
+		return errors.New("no files or folders to compress")
 	}
 
 	// Set default output directory if not provided
@@ -34,30 +35,39 @@ func Compress(filenameStrs []string, outputDir *string, password *string) error
 	// Channel to receive errors from goroutines
 	errChan := make(chan error, len(filenameStrs))
 
-	// Read files and store their content concurrently
+	// Process each input file or folder
 	for _, filename := range filenameStrs {
 		wg.Add(1)
 		go func(filename string) {
 			defer wg.Done()
 
-			// Check if the file exists
-			if _, err := os.Stat(filename); os.IsNotExist(err) {
-				errChan <- fmt.Errorf("file does not exist: %s", filename)
+			// Check if the file or folder exists
+			info, err := os.Stat(filename)
+			if os.IsNotExist(err) {
+				errChan <- fmt.Errorf("file or folder does not exist: %s", filename)
 				return
 			}
 
-			// Read file content
-			content, err := os.ReadFile(filename)
-			if err != nil {
-				errChan <- fmt.Errorf("failed to read file %s: %w", filename, err)
-				return
+			// Handle directory recursively
+			if info.IsDir() {
+				err := compressFolderRecursive(filename, &files)
+				if err != nil {
+					errChan <- err
+				}
+			} else {
+				// Read file content
+				content, err := os.ReadFile(filename)
+				if err != nil {
+					errChan <- fmt.Errorf("failed to read file %s: %w", filename, err)
+					return
+				}
+
+				// Store file information (name and content)
+				files = append(files, utils.File{
+					Name:    path.Base(filename),
+					Content: content,
+				})
 			}
-
-			// Store file information (name and content)
-			files = append(files, utils.File{
-				Name:    path.Base(filename),
-				Content: content,
-			})
 		}(filename)
 	}
 
@@ -95,8 +105,42 @@ func Compress(filenameStrs []string, outputDir *string, password *string) error
 	return nil
 }
 
+// Function to recursively compress a folder and its contents
+func compressFolderRecursive(folderPath string, files *[]utils.File) error {
+	// Traverse the folder contents
+	err := filepath.Walk(folderPath, func(filePath string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			// Read file content
+			content, err := os.ReadFile(filePath)
+			if err != nil {
+				return fmt.Errorf("failed to read file %s: %w", filePath, err)
+			}
+
+			filename, err := filepath.Rel(folderPath, filePath)
+			if err != nil {
+				return fmt.Errorf("failed to get relative path for file %s: %w", filePath, err)
+			}
+
+			// Store file information (relative path and content)
+			*files = append(*files, utils.File{
+				Name:    filepath.ToSlash(filename), // Store relative path
+				Content: content,
+			})
+		}
+		return nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("error compressing folder %s: %w", folderPath, err)
+	}
 
-// Decompress decompresses the specified compressed file into individual files.
+	return nil
+}
+
+// Decompress decompresses the specified compressed file into individual files or folders.
 func Decompress(filenameStrs []string, outputDir *string, password *string) error {
 	// Check if there are files to decompress
 	if len(filenameStrs) == 0 {
@@ -135,13 +179,22 @@ func Decompress(filenameStrs []string, outputDir *string, password *string) erro
 	// Channel to receive errors from goroutines
 	errChan := make(chan error, len(files))
 
-	// Write decompressed files to the output directory concurrently
+	// Process each decompressed file
 	for _, file := range files {
 		wg.Add(1)
 		go func(file utils.File) {
 			defer wg.Done()
 
-			err := os.WriteFile(*outputDir+"/"+file.Name, file.Content, 0644)
+			// Create directories if they don't exist
+			outputPath := filepath.Join(*outputDir, filepath.Dir(file.Name))
+			err := os.MkdirAll(outputPath, os.ModePerm)
+			if err != nil {
+				errChan <- fmt.Errorf("failed to create directory %s: %w", outputPath, err)
+				return
+			}
+
+			// Write decompressed file content
+			err = os.WriteFile(filepath.Join(*outputDir, file.Name), file.Content, 0644)
 			if err != nil {
 				errChan <- fmt.Errorf("failed to write decompressed file %s: %w", file.Name, err)
 				return

resources.rc

@@ -3,8 +3,8 @@
 IDI_ICON1 ICON "icon.ico"
 
 1 VERSIONINFO
-FILEVERSION 0,0,3
-PRODUCTVERSION 0,0,3
+FILEVERSION 0,0,4
+PRODUCTVERSION 0,0,4
 FILEOS 0x4
 FILETYPE 0x1
 {
@@ -14,12 +14,12 @@ FILETYPE 0x1
         {
             VALUE "CompanyName", "BrainbirdLab"
             VALUE "FileDescription", "File Compress-Encryption program"
-            VALUE "FileVersion", "0.0.3"
+            VALUE "FileVersion", "0.0.4"
             VALUE "InternalName", "piarch"
             VALUE "LegalCopyright", "BrainbirdLab"
             VALUE "OriginalFilename", "piarch"
             VALUE "ProductName", "piarch"
-            VALUE "ProductVersion", "0.0.3"
+            VALUE "ProductVersion", "0.0.4"
             VALUE "Author", "Fuad Hasan"
         }
     }

resources.syso

@@ -1,69 +1,71 @@
+//parseCLI.go
+
 package utils
 
 import (
 	"flag"
 	"os"
+	"path/filepath"
 	"strings"
 )
 
-
 func ParseCLI() ([]string, *string, *string, *bool) {
-	//cli arguments
-
-	//if -v or --version is passed then skip the other flags
+	// CLI arguments
 	version := flag.Bool("v", false, "Print version")
-	inputFiles := flag.String("i", "", "Input files to be compressed")
+	inputFiles := flag.String("i", "", "Input files or directory to be compressed")
 	outputDir := flag.String("o", "", "Output directory for compressed files (Optional)")
 	password := flag.String("p", "", "Password for encryption (Optional)")
-	readAllFiles := flag.Bool("a", false, "Read all files in the test directory")
+	readAllFiles := flag.Bool("a", false, "Read all files in the input directory")
 	decompressMode := flag.Bool("d", false, "Decompress mode")
 	flag.Parse()
 
 	if *version {
 		ColorPrint(WHITE, "---------- PI ARCHIVER ----------\n")
 		ColorPrint(YELLOW, "Version: v0.0.2\n")
-		//dev info
+		// dev info
 		ColorPrint(WHITE, "Developed by: https://github.com/itsfuad/\n")
 		ColorPrint(WHITE, "---------------------------------")
 		os.Exit(0)
 	}
 
 	if *inputFiles == "" {
-		ColorPrint(RED, "No input files provided\n")
+		ColorPrint(RED, "No input files or directory provided\n")
 		flag.Usage()
 		os.Exit(1)
 	}
 
-	// Read all files
 	var filenameStrs []string
 
-	// Split input files by comma and trim spaces and quotes(if any, `'` | `"`)
-
+	// Handle reading all files in the input directory
 	if *readAllFiles {
-
-		//filenameStrs is the folder name
-		dir := inputFiles
-		//if dir exists
-		if _, err := os.Stat(*dir); os.IsNotExist(err) {
-			ColorPrint(RED, "Directory does not exist.\n")
+		// Check if input is a directory
+		info, err := os.Stat(*inputFiles)
+		if os.IsNotExist(err) {
+			ColorPrint(RED, "Input directory does not exist.\n")
 			os.Exit(1)
 		}
 
-		//read all filenames in the directory
-		files, err := os.ReadDir(*dir)
-		if err != nil {
-			ColorPrint(RED, err.Error()+"\n")
+		if !info.IsDir() {
+			ColorPrint(RED, "Provided input is not a directory.\n")
 			os.Exit(1)
 		}
 
-		for _, file := range files {
-			if file.IsDir() {
-				continue
+		// Read all files in the directory
+		err = filepath.Walk(*inputFiles, func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
 			}
-
-			filenameStrs = append(filenameStrs, *dir+"/"+file.Name())
+			if !info.IsDir() {
+				filenameStrs = append(filenameStrs, path)
+			}
+			return nil
+		})
+		if err != nil {
+			ColorPrint(RED, err.Error())
+			os.Exit(1)
 		}
 	} else {
+		// Split input files by comma and trim spaces and quotes (if any)
 		for _, filename := range strings.Split(*inputFiles, ",") {
 			filenameStrs = append(filenameStrs, strings.Trim(filename, " '\""))
 		}