refactor: make export options into a struct

Author: viktomas

main.go

@@ -22,6 +22,14 @@ type page struct {
 	text       string
 }
 
+type exportOptions struct {
+	graphPath           string
+	blogFolder          string
+	assetsRelativePath  string
+	webAssetsPathPrefix string
+	unquotedProperties  []string
+}
+
 /*
 findMatchingFiles finds all files in rootPath that contain substring
 ignoreRegexp is an expression that is evaluated on **relative** path of files within the graph (e.g. `.git/HEAD` or `logseq/.bkp/something.md`) if it matches, the file is not processed
@@ -63,52 +71,67 @@ func findMatchingFiles(appFS afero.Fs, rootPath string, substring string, ignore
 	return result, nil
 }
 
-func main() {
+/*
+parseOptions produce a valid exportOptions object
+if a mandatory argument is missing, parseOptions will print error message, program usage and exits with os.Exit(1)
+*/
+func parseOptions() exportOptions {
 	graphPath := flag.String("graphPath", "", "[MANDATORY] Folder where all public pages are exported.") // TODO rename graphPath -> graphFolder or maybe logseqFolder
 	blogFolder := flag.String("blogFolder", "", "[MANDATORY] Folder where this program creates a new subfolder with public logseq pages.")
 	assetsRelativePath := flag.String("assetsRelativePath", "logseq-images", "relative path within blogFolder where the assets (images) should be stored (e.g. 'static/images/logseq'). Default is `logseq-images`")
 	webAssetsPathPrefix := flag.String("webAssetsPathPrefix", "/logseq-images", "path that the images are going to be served on on the web (e.g. '/public/images/logseq'). Default is `/logseq-images`")
-	unquotedProperties := flag.String("unquotedProperties", "", "comma-separated list of logseq page properties that won't be quoted in the markdown front matter, e.g. 'date,public,slug")
+	rawUnquotedProperties := flag.String("unquotedProperties", "", "comma-separated list of logseq page properties that won't be quoted in the markdown front matter, e.g. 'date,public,slug")
 	flag.Parse()
 	if *graphPath == "" || *blogFolder == "" {
 		log.Println("mandatory argument is missing")
 		flag.Usage()
 		os.Exit(1)
 	}
+	unquotedProperties := parseUnquotedProperties(*rawUnquotedProperties)
+	return exportOptions{
+		graphPath:           *graphPath,
+		blogFolder:          *blogFolder,
+		assetsRelativePath:  *assetsRelativePath,
+		webAssetsPathPrefix: *webAssetsPathPrefix,
+		unquotedProperties:  unquotedProperties,
+	}
+}
+
+func main() {
 	appFS := afero.NewOsFs()
-	publicFiles, err := findMatchingFiles(appFS, *graphPath, "public::", regexp.MustCompile(`^(logseq|.git)/`))
+	options := parseOptions()
+	publicFiles, err := findMatchingFiles(appFS, options.graphPath, "public::", regexp.MustCompile(`^(logseq|.git)/`))
 	if err != nil {
 		log.Fatalf("Error during walking through a folder %v", err)
 	}
-	puq := parseUnquotedProperties(*unquotedProperties)
 	for _, publicFile := range publicFiles {
-		err = exportPublicPage(appFS, publicFile, *webAssetsPathPrefix, *blogFolder, *assetsRelativePath, puq)
+		err = exportPublicPage(appFS, publicFile, options)
 		if err != nil {
 			log.Fatalf("Error when exporting page %q: %v", publicFile, err)
 		}
 	}
 }
 
-func exportPublicPage(appFS afero.Fs, publicFile string, webAssetsPathPrefix string, blogFolder string, assetsRelativePath string, unquotedProperties []string) error {
+func exportPublicPage(appFS afero.Fs, publicFile string, options exportOptions) error {
 	srcContent, err := afero.ReadFile(appFS, publicFile)
 	if err != nil {
 		return fmt.Errorf("reading the %q file failed: %v", publicFile, err)
 	}
 	_, name := filepath.Split(publicFile)
 	page := parsePage(name, string(srcContent))
-	result := transformPage(page, webAssetsPathPrefix)
-	assetFolder := filepath.Join(blogFolder, assetsRelativePath)
+	result := transformPage(page, options.webAssetsPathPrefix)
+	assetFolder := filepath.Join(options.blogFolder, options.assetsRelativePath)
 	err = copyAssets(appFS, publicFile, assetFolder, result.assets)
 	if err != nil {
 		return fmt.Errorf("copying assets for page %q failed: %v", publicFile, err)
 	}
-	dest := filepath.Join(blogFolder, result.filename)
+	dest := filepath.Join(options.blogFolder, result.filename)
 	folder, _ := filepath.Split(dest)
 	err = appFS.MkdirAll(folder, os.ModePerm)
 	if err != nil {
 		return fmt.Errorf("creating parent directory for %q failed: %v", dest, err)
 	}
-	outputFileContent := render(result, unquotedProperties)
+	outputFileContent := render(result, options.unquotedProperties)
 	err = afero.WriteFile(appFS, dest, []byte(outputFileContent), 0644)
 	if err != nil {
 		return fmt.Errorf("copying file %q failed: %v", dest, err)