Clean up a lot. Change some of the tests. And restructureed the struct and methods. Added doc with comments.

Author: jnbdz

location/location.go

@@ -10,28 +10,40 @@ import (
 	"github.com/adrg/xdg"
 )
 
+// ILocation 🧩 Is the interface for the NewLocationService.
 type ILocation interface {
 	SystemPaths() *SystemPaths
-	ThisAppPaths() *ApplicationPaths
+	ApplicationPaths() *ApplicationPaths
 }
+
+// SLocation 🏛️ Is the main structure for the NewLocationService.
 type SLocation struct {
 	appName         AppName
 	appVersion      AppVersion
 	pluginTypeNames PluginTypeNames
 	paths           *Paths
 }
 
+// For mocking 🥸.
 var (
 	xdgCacheFile   = xdg.CacheFile
 	xdgConfigFile  = xdg.ConfigFile
 	xdgRuntimeFile = xdg.RuntimeFile
 	xdgDataFile    = xdg.DataFile
 )
 
-func (service *SLocation) setAll() error {
-	service.paths.ThisApplicationPaths.Name = service.appName
-	service.paths.ThisApplicationPaths.PluginTypeNames = service.pluginTypeNames
+// SystemPaths returns struct of all systems paths
+func (service *SLocation) SystemPaths() *SystemPaths {
+	return service.paths.SystemPaths
+}
+
+// ApplicationPaths returns the struct of all the main application paths
+func (service *SLocation) ApplicationPaths() *ApplicationPaths {
+	return service.paths.ApplicationPaths
+}
 
+// setAllPaths calls on all the private methods to set in the struct all the absolute paths.
+func (service *SLocation) setAllPaths() error {
 	relFilePath := fmt.Sprintf("%s/%s", service.appName, service.appName)
 
 	err := service.setSystemPaths()
@@ -59,7 +71,7 @@ func (service *SLocation) setAll() error {
 		return err
 	}
 
-	service.setBinPaths()
+	service.setBinPath()
 
 	err = service.setPluginPaths()
 	if err != nil {
@@ -74,11 +86,8 @@ func (service *SLocation) setAll() error {
 	return nil
 }
 
-// setSystemPaths sets the basic system paths
+// setSystemPaths sets the system paths.
 func (service *SLocation) setSystemPaths() error {
-	//
-	// System
-	//
 	sysPaths := &SystemPaths{
 		Home:            xdg.Home,
 		DataHome:        xdg.DataHome,
@@ -99,9 +108,6 @@ func (service *SLocation) setSystemPaths() error {
 		runtime.GOOS != "plan9" {
 		sysPaths.UserLocalHome = filepath.Join(xdg.DataHome, ".local")
 
-		// TODO:
-		//sysPaths.UserApplicationsHome = filepath.Join(xdg.DataHome, "applications")
-
 		var existApplicationsPath string
 		for _, applicationsPath := range xdg.ApplicationDirs {
 			if file.Exists(applicationsPath) {
@@ -111,7 +117,7 @@ func (service *SLocation) setSystemPaths() error {
 		}
 		if existApplicationsPath != "" {
 			sysPaths.UserApplicationsHome = existApplicationsPath
-			service.paths.ThisApplicationPaths.Paths.ApplicationsDesktopFile = fmt.Sprintf(
+			service.paths.ApplicationPaths.ApplicationsDesktopFile = fmt.Sprintf(
 				"%s/%s.desktop",
 				existApplicationsPath,
 				string(service.appName),
@@ -126,248 +132,85 @@ func (service *SLocation) setSystemPaths() error {
 	return nil
 }
 
-// setDataPaths
+// setDataPaths sets the application specific data directory path.
 func (service *SLocation) setDataPaths() error {
 	dataDir, err := xdgDataFile(string(service.appName))
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.DataFile was unable to set "%s" path`, dataDir), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.DataHome = dataDir
+	service.paths.ApplicationPaths.DataHome = dataDir
 
 	return nil
 }
 
-// setConfigPaths
+// setConfigPaths sets the application config directory and file YAML absolute paths.
 func (service *SLocation) setConfigPaths(relFilePath string) error {
 	configFile, err := xdgConfigFile(relFilePath + ".yaml")
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.ConfigFile was unable to set "%s" path`, configFile), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.ConfigFile = configFile
-	service.paths.ThisApplicationPaths.Paths.ConfigHome = filepath.Dir(configFile)
+	service.paths.ApplicationPaths.ConfigFile = configFile
+	service.paths.ApplicationPaths.ConfigHome = filepath.Dir(configFile)
 
 	return nil
 }
 
-// setStatePaths
+// setStatePaths sets the absolute path to the state directory.
 func (service *SLocation) setStatePaths() error {
 	stateDir, err := xdg.StateFile(string(service.appName))
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.StateFile was unable to set "%s" path`, stateDir), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.StateHome = stateDir
+	service.paths.ApplicationPaths.StateHome = stateDir
 
 	return nil
 }
 
-// setCachePaths
+// setCachePaths sets the to the cache directory and file absolute paths.
 func (service *SLocation) setCachePaths(relFilePath string) error {
 	cacheFilePath, err := xdgCacheFile(relFilePath + ".cache")
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.CacheFile was unable to set "%s" path`, cacheFilePath), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.CacheHome = filepath.Dir(cacheFilePath)
-	service.paths.ThisApplicationPaths.Paths.CacheFile = cacheFilePath
+	service.paths.ApplicationPaths.CacheHome = filepath.Dir(cacheFilePath)
+	service.paths.ApplicationPaths.CacheFile = cacheFilePath
 
 	return nil
 }
 
-// setBinPaths
-func (service *SLocation) setBinPaths() {
-	service.paths.ThisApplicationPaths.Paths.BinFile = fmt.Sprintf("%s/%s", xdg.BinHome, service.appName)
+// setBinPath sets the absolute bin path.
+// The bin is the application main binary.
+func (service *SLocation) setBinPath() {
+	service.paths.ApplicationPaths.BinFile = fmt.Sprintf("%s/%s", xdg.BinHome, service.appName)
 }
 
-// setPluginPaths
+// setPluginPaths sets the path or paths to the plugin directory.
 func (service *SLocation) setPluginPaths() error {
 	pluginDirs := make(map[string]string)
 	for _, pluginTypeName := range service.pluginTypeNames {
 		pluginDirs[pluginTypeName] = fmt.Sprintf("%s/%s.d", xdg.DataHome, pluginTypeName)
 	}
-	service.paths.ThisApplicationPaths.Paths.PluginsHome = pluginDirs
+	service.paths.ApplicationPaths.PluginsHome = pluginDirs
 
 	return nil
 }
 
-// setSecretPaths
+// setSecretPaths sets the secret absolute paths.
 func (service *SLocation) setSecretPaths() error {
 	secretsRelPath := fmt.Sprintf("%s/secrets", service.appName)
 
 	tmpSecrets, err := xdgRuntimeFile(secretsRelPath)
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.RuntimeFile was unable to set "%s" path`, tmpSecrets), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.RuntimeDir = filepath.Dir(tmpSecrets)
-	service.paths.ThisApplicationPaths.Paths.SecretsHome = tmpSecrets
+	service.paths.ApplicationPaths.RuntimeDir = filepath.Dir(tmpSecrets)
+	service.paths.ApplicationPaths.SecretsHome = tmpSecrets
 
 	tmpSecretsMTls, err := xdgRuntimeFile(secretsRelPath + "/mTLS")
 	if err != nil {
 		return errors.Join(fmt.Errorf(`xdg.RuntimeFile was unable to set "%s" path`, tmpSecrets), err)
 	}
-	service.paths.ThisApplicationPaths.Paths.MTLSHome = tmpSecretsMTls
-
-	return nil
-}
-
-// SystemPaths returns struct of all systems paths
-func (service *SLocation) SystemPaths() *SystemPaths {
-	return service.paths.SystemPaths
-}
-
-// ThisAppPaths returns the struct of all the main application paths
-func (service *SLocation) ThisAppPaths() *ApplicationPaths {
-	return service.paths.ThisApplicationPaths.Paths
-}
-
-// Paths return the absolute paths for the different parts of storage
-/*func (d *AbsPaths) Paths(collectionName string) (*AbsPaths, error) {
-	mainPath, err := d.Main()
-	if err != nil {
-		return &AbsPaths{}, err
-	}
-
-	return d.paths(mainPath, collectionName)
-}
-
-// Main returns the main path for `.hery` storage path
-// TODO: Maybe name it Root
-func (d *AbsPaths) Main() (string, error) {
-	//
-	// Using env var
-	//
-
-	envStoragePathValue := os.Getenv(HeryStoragePath)
-
-	if envStoragePathValue != "" {
-		envStoragePath, err := filepathAbs(envStoragePathValue)
-		if err != nil {
-			return "", err
-		}
-		return envStoragePath, nil
-	}
-
-	//
-	// Using current location
-	//
-
-	cwd, err := osGetwd()
-	if err != nil {
-		return "", err
-	}
-
-	localStoragePath := filepathJoin(cwd, ".hery")
-
-	if fileExists(localStoragePath) {
-		return localStoragePath, nil
-	}
-
-	//
-	// Default
-	//
-
-	var mainDir string
-	switch runtime.GOOS {
-	case "windows":
-		appDataDir := os.Getenv("APPDATA")
-		mainDir = filepathJoin(appDataDir, "Hery")
-	default: // "linux" and "darwin" (macOS)
-		homeDir, err := os.UserHomeDir()
-		if err != nil {
-			return "", fmt.Errorf("error getting home directory: %s", err)
-		}
-		mainDir = filepathJoin(homeDir, ".hery")
-	}
-
-	return mainDir, nil
-}
-
-// EntityPath returns the absolute path to a specific entity
-func (d *AbsPaths) EntityPath(entitiesPath, entityRelativePath string) string {
-	return filepathJoin(entitiesPath, entityRelativePath)
-}
-
-// TmpPaths returns the tmp absolute paths for the different parts of storage
-func (d *AbsPaths) TmpPaths(collectionName string) (*AbsPaths, error) {
-	mainTmpPath, err := d.TmpMain()
-	if err != nil {
-		return &AbsPaths{}, err
-	}
-
-	return d.paths(mainTmpPath, collectionName)
-}
-
-// TmpMain returns the tmp main path for `.hery` storage path
-func (d *AbsPaths) TmpMain() (string, error) {
-	tempDir, err := osMkdirTemp("", "hery_*")
-	if err != nil {
-		return "", err
-	}
-
-	storageTmpPath := filepath.Join(tempDir, ".hery")
-	err = osMkdirAll(storageTmpPath, perm)
-	if err != nil {
-		return "", err
-	}
-
-	return storageTmpPath, nil
-}
-
-// MakePaths makes all the storage subdirectories
-func (d *AbsPaths) MakePaths(paths AbsPaths) error {
-	err := osMkdirAll(paths.Storage, perm)
-	if err != nil {
-		return err
-	}
-
-	err = osMkdirAll(paths.Catalog, perm)
-	if err != nil {
-		return err
-	}
-
-	err = osMkdirAll(paths.Collection, perm)
-	if err != nil {
-		return err
-	}
-
-	err = osMkdirAll(paths.Entities, perm)
-	if err != nil {
-		return err
-	}
+	service.paths.ApplicationPaths.MTLSHome = tmpSecretsMTls
 
 	return nil
 }
-
-// paths internal function to generate the paths for different part of storage based on main path and collection name
-func (d *AbsPaths) paths(mainPath, collectionName string) (*AbsPaths, error) {
-	catalogPath := d.catalogPath(mainPath)
-	collectionPath := d.collectionPath(catalogPath, collectionName)
-	entityPath := d.entitiesPath(collectionPath)
-	cachePath := d.cachePath(collectionName, collectionPath)
-
-	return &AbsPaths{
-		Storage:    mainPath,
-		Catalog:    catalogPath,
-		Collection: collectionPath,
-		Entities:   entityPath,
-		Cache:      cachePath,
-	}, nil
-}
-
-// catalogPath returns the catalog absolute path
-func (d *AbsPaths) catalogPath(mainPath string) string {
-	return filepathJoin(mainPath, "collection")
-}
-
-// collectionPath returns the collection absolute path
-func (d *AbsPaths) collectionPath(mainPath, collectionName string) string {
-	return filepathJoin(mainPath, collectionName)
-}
-
-// entityPath returns the entity absolute path
-func (d *AbsPaths) entitiesPath(collectionPath string) string {
-	return filepathJoin(collectionPath, "entity")
-}
-
-// cachePath returns the collection cache absolute path
-func (d *AbsPaths) cachePath(collectionName, collectionPath string) string {
-	return filepathJoin(collectionPath, fmt.Sprintf("%s.cache", collectionName))
-}*/

location/location_test.go

@@ -1,6 +1,8 @@
 package location
 
-/*func TestPaths(t *testing.T) {
-	locationService := NewLocationService()
-	locationService.Paths()
+/*func Test_setSystemPaths(t *testing.T) {
+	tests := []struct {
+		name string
+		path string
+	}
 }*/