style: maintainability tech debt resorbtion

split big functions into smaller atomic parts
removed sugar logger
added docstrings and comments in most places that required it

Author: BoxBoxJason

.gitignore

@@ -57,3 +57,5 @@ Desktop.ini
 mirroring.json
 go.sum
 sonar-project.properties
+unit-tests.xml
+coverage.out

cmd/main.go

@@ -36,18 +36,20 @@ func main() {
 			zap.L().Debug("Parsing command line arguments")
 
 			// Obtain the retry count
-			if args.Retry == -1 {
+			switch args.Retry {
+			case -1:
 				args.Retry = 10000
-			} else if args.Retry == 0 {
+			case 0:
 				zap.L().Fatal("retry count must be -1 (no limit) or strictly greater than 0")
 			}
 
 			// Set the timeout for GitLab API requests
-			if timeout == -1 {
+			switch timeout {
+			case -1:
 				args.Timeout = time.Duration(10000 * time.Second)
-			} else if timeout == 0 {
+			case 0:
 				zap.L().Fatal("timeout must be -1 (no limit) or strictly greater than 0")
-			} else {
+			default:
 				args.Timeout = time.Duration(timeout) * time.Second
 			}
 
@@ -67,7 +69,7 @@ func main() {
 			zap.L().Debug("Parsing mirror mapping file")
 			mapping, err := utils.OpenMirrorMapping(mirrorMappingPath)
 			if err != nil {
-				zap.L().Sugar().Fatalf("Error opening mirror mapping file: %s", err)
+				zap.L().Fatal("Error opening mirror mapping file", zap.Error(err))
 			}
 			zap.L().Debug("Mirror mapping file parsed successfully")
 			args.MirrorMapping = mapping
@@ -97,18 +99,27 @@ func main() {
 	}
 }
 
+// promptForInput prompts the user for input and returns the trimmed response.
+// It handles errors and prints a message if the input is empty.
+// If the input is empty, it will return an empty string.
 func promptForInput(prompt string) string {
 	var input string
 	fmt.Printf("%s: ", prompt)
-	fmt.Scanln(&input)
-	return input
+	_, err := fmt.Scanln(&input)
+	if err != nil {
+		zap.L().Fatal("Error reading input", zap.Error(err))
+	}
+	return strings.TrimSpace(input)
 }
 
+// promptForMandatoryInput prompts the user for mandatory input and returns the trimmed response.
+// If the input is empty, it will log a fatal error message and exit the program.
+// It also logs the input value if hideOutput is false.
 func promptForMandatoryInput(defaultValue string, prompt string, errorMsg string, loggerMsg string, promptsDisabled bool, hideOutput bool) string {
 	input := strings.TrimSpace(defaultValue)
 	if input == "" {
 		if !promptsDisabled {
-			input = strings.TrimSpace(promptForInput(prompt))
+			input = promptForInput(prompt)
 			if input == "" {
 				zap.L().Fatal(errorMsg)
 			}
@@ -118,12 +129,15 @@ func promptForMandatoryInput(defaultValue string, prompt string, errorMsg string
 				zap.L().Debug(loggerMsg)
 			}
 		} else {
-			zap.L().Sugar().Fatal("Prompting is disabled, %s", errorMsg)
+			zap.L().Fatal("Prompting is disabled")
 		}
 	}
 	return input
 }
 
+// setupZapLogger sets up the Zap logger with the specified verbosity level.
+// It configures the logger to use ISO8601 time format and capitalizes the log levels.
+// The logger is set to production mode by default, but can be configured for debug mode if verbose is true.
 func setupZapLogger(verbose bool) {
 	// Set up the logger configuration
 	config := zap.NewProductionConfig()

internal/mirroring/get.go

@@ -12,89 +12,96 @@ import (
 	"go.uber.org/zap"
 )
 
+// fetchProjects retrieves all projects that match the filters from the GitLab instance and stores them in the instance cache.
+// It also updates the mirror mapping with the corresponding group creation options.
+//
+// The function is run in a goroutine for each project, and a wait group is used to wait for all goroutines to finish.
 func (g *GitlabInstance) fetchProjects(projectFilters *map[string]bool, groupFilters *map[string]bool, mirrorMapping *utils.MirrorMapping, isSource bool) error {
 	sourceString := "source"
 	if !isSource {
 		sourceString = "destination"
 	}
-	zap.L().Sugar().Debugf("Fetching all projects from %s GitLab instance", sourceString)
+	zap.L().Debug("Fetching all projects from GitLab instance", zap.String("role", sourceString))
 	projects, _, err := g.Gitlab.Projects.ListProjects(nil)
 	if err != nil {
 		return err
 	}
 
-	zap.L().Sugar().Debugf("Processing %d projects from %s GitLab instance", len(projects), sourceString)
+	zap.L().Debug("Processing projects from GitLab instance", zap.String("role", sourceString), zap.Int("projects", len(projects)))
 
 	// Create a wait group to wait for all goroutines to finish
 	var wg sync.WaitGroup
 
 	for _, project := range projects {
 		wg.Add(1)
-		// Acquire a token from the semaphore
 
 		go func(project *gitlab.Project) {
 			defer wg.Done()
 
-			// Check if the project matches the filters:
-			//   - either is in the projects map
-			//   - or path starts with any of the groups in the groups map
-			if _, ok := (*projectFilters)[project.PathWithNamespace]; ok {
-				g.addProject(project.PathWithNamespace, project)
-			} else {
-				for group := range *groupFilters {
-					if strings.HasPrefix(project.PathWithNamespace, group) {
-						// Add the project to the gitlab instance projects cache
-						g.addProject(project.PathWithNamespace, project)
-
-						if isSource {
-							// Retrieve the corresponding group creation options from the mirror mapping
-							groupCreationOptions, ok := mirrorMapping.Groups[group]
-							if !ok {
-								zap.L().Sugar().Errorf("Group %s not found in mirror mapping (internal error, please review script)", group)
-							}
-
-							// Calculate the relative path between the project and the group
-							relativePath, err := filepath.Rel(group, project.PathWithNamespace)
-							if err != nil {
-								zap.L().Sugar().Errorf("Failed to calculate relative path for project %s: %s", project.PathWithNamespace, err)
-							}
-
-							// Add the project to the mirror mapping
-							mirrorMapping.AddProject(project.PathWithNamespace, &utils.MirroringOptions{
-								DestinationPath:     filepath.Join(groupCreationOptions.DestinationPath, relativePath),
-								CI_CD_Catalog:       groupCreationOptions.CI_CD_Catalog,
-								Issues:              groupCreationOptions.Issues,
-								MirrorTriggerBuilds: groupCreationOptions.MirrorTriggerBuilds,
-								Visibility:          groupCreationOptions.Visibility,
-								MirrorReleases:      groupCreationOptions.MirrorReleases,
-							})
-						}
-						break
-					}
-				}
+			group, matches := g.checkPathMatchesFilters(project.PathWithNamespace, projectFilters, groupFilters)
+			if matches {
+				g.storeProject(project, group, mirrorMapping, isSource)
 			}
+
 		}(project)
 	}
 
 	wg.Wait()
 
-	zap.L().Sugar().Debugf("Found %d projects to mirror in the %s GitLab instance", len(g.Projects), sourceString)
-
+	zap.L().Debug("Found matching projects in the GitLab instance", zap.String("role", sourceString), zap.Int("projects", len(g.Projects)))
 	return nil
 }
 
+// storeProject stores the project in the Gitlab instance projects cache
+// and updates the mirror mapping with the corresponding group creation options.
+func (g *GitlabInstance) storeProject(project *gitlab.Project, parentGroupPath string, mirrorMapping *utils.MirrorMapping, isSource bool) {
+	// Add the project to the gitlab instance projects cache
+	g.addProject(project.PathWithNamespace, project)
+
+	if isSource {
+		zap.L().Debug("Storing project in mirror mapping", zap.String("project", project.HTTPURLToRepo), zap.String("group", parentGroupPath))
+		// Retrieve the corresponding group creation options from the mirror mapping
+		groupCreationOptions, ok := mirrorMapping.GetGroup(parentGroupPath)
+		if !ok {
+			zap.L().Error("Group not found in mirror mapping", zap.String("group", parentGroupPath))
+			return
+		}
+
+		// Calculate the relative path between the project and the group
+		relativePath, err := filepath.Rel(parentGroupPath, project.PathWithNamespace)
+		if err != nil {
+			zap.L().Error("Failed to calculate relative path for project", zap.String("project", project.HTTPURLToRepo), zap.String("group", parentGroupPath), zap.Error(err))
+			return
+		}
+
+		// Add the project to the mirror mapping with the corresponding group creation options
+		mirrorMapping.AddProject(project.PathWithNamespace, &utils.MirroringOptions{
+			DestinationPath:     filepath.Join(groupCreationOptions.DestinationPath, relativePath),
+			CI_CD_Catalog:       groupCreationOptions.CI_CD_Catalog,
+			Issues:              groupCreationOptions.Issues,
+			MirrorTriggerBuilds: groupCreationOptions.MirrorTriggerBuilds,
+			Visibility:          groupCreationOptions.Visibility,
+			MirrorReleases:      groupCreationOptions.MirrorReleases,
+		})
+	}
+}
+
+// fetchGroups retrieves all groups that match the filters from the GitLab instance and stores them in the instance cache.
+// It also updates the mirror mapping with the corresponding group creation options.
+//
+// The function is run in a goroutine for each group, and a wait group is used to wait for all goroutines to finish.
 func (g *GitlabInstance) fetchGroups(groupFilters *map[string]bool, mirrorMapping *utils.MirrorMapping, isSource bool) error {
 	sourceString := "source"
 	if !isSource {
 		sourceString = "destination"
 	}
-	zap.L().Sugar().Debugf("Fetching all groups from %s GitLab instance", sourceString)
+	zap.L().Debug("Fetching all groups from GitLab instance", zap.String("role", sourceString))
 	groups, _, err := g.Gitlab.Groups.ListGroups(nil)
 	if err != nil {
 		return err
 	}
 
-	zap.L().Sugar().Debugf("Processing %d groups from %s GitLab instance", len(groups), sourceString)
+	zap.L().Debug("Processing groups from GitLab instance", zap.String("role", sourceString), zap.Int("groups", len(groups)))
 
 	// Create a wait group to wait for all goroutines to finish
 	var wg sync.WaitGroup
@@ -105,55 +112,84 @@ func (g *GitlabInstance) fetchGroups(groupFilters *map[string]bool, mirrorMappin
 		go func(group *gitlab.Group) {
 			defer wg.Done()
 
-			// Check if the group matches the filters:
-			//   - either is in the groups map
-			//   - or path starts with any of the groups in the groups map
-			//   - or is a subgroup of any of the groups in the groups map
-			if _, ok := (*groupFilters)[group.FullPath]; ok {
-				g.addGroup(group.FullPath, group)
-			} else {
-				for groupPath := range *groupFilters {
-					if strings.HasPrefix(group.FullPath, groupPath) {
-						// Add the group to the gitlab instance groups cache
-						g.addGroup(group.FullPath, group)
-
-						if isSource {
-							// Retrieve the corresponding group creation options from the mirror mapping
-							groupCreationOptions, ok := mirrorMapping.Groups[groupPath]
-							if !ok {
-								zap.L().Sugar().Fatalf("Group %s not found in mirror mapping (internal error, please review script)", groupPath)
-							}
-
-							// Calculate the relative path between the group and the groupPath
-							relativePath, err := filepath.Rel(groupPath, group.FullPath)
-							if err != nil {
-								zap.L().Sugar().Fatalf("Failed to calculate relative path for group %s: %s", group.FullPath, err)
-							}
-
-							// Add the group to the mirror mapping
-							mirrorMapping.AddGroup(group.FullPath, &utils.MirroringOptions{
-								DestinationPath:     filepath.Join(groupCreationOptions.DestinationPath, relativePath),
-								CI_CD_Catalog:       groupCreationOptions.CI_CD_Catalog,
-								Issues:              groupCreationOptions.Issues,
-								MirrorTriggerBuilds: groupCreationOptions.MirrorTriggerBuilds,
-								Visibility:          groupCreationOptions.Visibility,
-								MirrorReleases:      groupCreationOptions.MirrorReleases,
-							})
-						}
-						break
-					}
-				}
+			groupPath, matches := g.checkPathMatchesFilters(group.FullPath, nil, groupFilters)
+			if matches {
+				g.storeGroup(group, groupPath, mirrorMapping, isSource)
 			}
 		}(group)
 	}
 
 	wg.Wait()
 
-	zap.L().Sugar().Debugf("Found %d matching groups in %s GitLab instance", len(g.Groups), sourceString)
+	zap.L().Debug("Found matching groups in the GitLab instance", zap.String("role", sourceString), zap.Int("groups", len(g.Groups)))
 
 	return nil
 }
 
+// storeGroup stores the group in the Gitlab instance groups cache
+// and updates the mirror mapping with the corresponding group creation options.
+func (g *GitlabInstance) storeGroup(group *gitlab.Group, parentGroupPath string, mirrorMapping *utils.MirrorMapping, isSource bool) {
+	if group != nil {
+		// Add the group to the gitlab instance groups cache
+		g.addGroup(group.FullPath, group)
+
+		if isSource {
+			zap.L().Debug("Storing group in mirror mapping", zap.String("group", group.FullPath), zap.String("parentGroup", parentGroupPath))
+			// Retrieve the corresponding group creation options from the mirror mapping
+			groupCreationOptions, ok := mirrorMapping.Groups[parentGroupPath]
+			if !ok {
+				zap.L().Error("Group not found in mirror mapping", zap.String("group", parentGroupPath))
+				return
+			}
+
+			// Calculate the relative path between the group and the parent group
+			relativePath, err := filepath.Rel(parentGroupPath, group.FullPath)
+			if err != nil {
+				zap.L().Error("Failed to calculate relative path for group", zap.String("group", group.FullPath), zap.String("parentGroup", parentGroupPath), zap.Error(err))
+				return
+			}
+
+			// Add the group to the mirror mapping
+			mirrorMapping.AddGroup(group.FullPath, &utils.MirroringOptions{
+				DestinationPath:     filepath.Join(groupCreationOptions.DestinationPath, relativePath),
+				CI_CD_Catalog:       groupCreationOptions.CI_CD_Catalog,
+				Issues:              groupCreationOptions.Issues,
+				MirrorTriggerBuilds: groupCreationOptions.MirrorTriggerBuilds,
+				Visibility:          groupCreationOptions.Visibility,
+				MirrorReleases:      groupCreationOptions.MirrorReleases,
+			})
+		}
+	} else {
+		zap.L().Error("Failed to store group in mirror mapping: nil group")
+	}
+}
+
+// checkPathMatchesFilters checks if the resources matches the filters
+//   - either is in the projects map
+//   - or path starts with any of the groups in the groups map
+//
+// In the case of a match with a group, it returns the group path
+func (g *GitlabInstance) checkPathMatchesFilters(resourcePath string, projectFilters *map[string]bool, groupFilters *map[string]bool) (string, bool) {
+	zap.L().Debug("Checking if path matches filters", zap.String("path", resourcePath))
+	if projectFilters != nil {
+		if _, ok := (*projectFilters)[resourcePath]; ok {
+			zap.L().Debug("Resource path matches project filter", zap.String("project", resourcePath))
+			return "", true
+		}
+	}
+	if groupFilters != nil {
+		for groupPath := range *groupFilters {
+			if strings.HasPrefix(resourcePath, groupPath) {
+				zap.L().Debug("Resource path matches group filter", zap.String("resource", resourcePath), zap.String("group", groupPath))
+				return groupPath, true
+			}
+		}
+	}
+	return "", false
+}
+
+// fetchAll retrieves all projects and groups from the GitLab instance
+// that match the filters and stores them in the instance cache.
 func fetchAll(gitlabInstance *GitlabInstance, projectFilters map[string]bool, groupFilters map[string]bool, mirrorMapping *utils.MirrorMapping, isSource bool) error {
 	wg := sync.WaitGroup{}
 	errCh := make(chan error, 2)
@@ -176,6 +212,10 @@ func fetchAll(gitlabInstance *GitlabInstance, projectFilters map[string]bool, gr
 	return utils.MergeErrors(errCh, 2)
 }
 
+// getParentNamespaceID retrieves the parent namespace ID for a given project or group path.
+// It checks if the parent path is already in the instance groups cache.
+//
+// If not, it returns an error indicating that the parent group was not found.
 func (g *GitlabInstance) getParentNamespaceID(projectOrGroupPath string) (int, error) {
 	parentGroupID := -1
 	parentPath := filepath.Dir(projectOrGroupPath)