Merge pull request #2 from nsumbadze/install-search

Install search

Author: nsumbadze

internal/config/paths.go

@@ -0,0 +1,186 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+const userOnlyDirPerm os.FileMode = 0700
+
+var (
+	ErrHomeDirRequired          = errors.New("config: home directory required")
+	ErrConfigPathNotRegularFile = errors.New("config: config path is not a regular file")
+)
+
+type FilePath struct {
+	value string
+}
+
+func (p FilePath) String() string {
+	return p.value
+}
+
+type DirPath struct {
+	value string
+}
+
+func (p DirPath) String() string {
+	return p.value
+}
+
+type ConfigSource string
+
+const (
+	ConfigSourceCLIOverride     ConfigSource = "cli-override"
+	ConfigSourceProject         ConfigSource = "project"
+	ConfigSourceXDG             ConfigSource = "xdg"
+	ConfigSourceLegacyMigration ConfigSource = "legacy-migration"
+	ConfigSourceDefaults        ConfigSource = "defaults"
+	ConfigSourceNone            ConfigSource = ConfigSourceDefaults
+)
+
+type PathOptions struct {
+	Env map[string]string
+}
+
+type PathSet struct {
+	WriteConfigFile           FilePath
+	StateDir                  DirPath
+	CacheDir                  DirPath
+	LegacyMigrationConfigFile FilePath
+}
+
+type ConfigReadPath struct {
+	Source ConfigSource
+	Path   FilePath
+}
+
+type ConfigReadOptions struct {
+	CLIOverridePath   string
+	ProjectConfigPath string
+}
+
+func DiscoverPaths(options PathOptions) (PathSet, error) {
+	home, err := options.homeDir()
+	if err != nil {
+		return PathSet{}, err
+	}
+
+	configRoot := options.xdgRoot("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
+	stateRoot := options.xdgRoot("XDG_STATE_HOME", filepath.Join(home, ".local", "state"))
+	cacheRoot := options.xdgRoot("XDG_CACHE_HOME", filepath.Join(home, ".cache"))
+
+	return PathSet{
+		WriteConfigFile:           newFilePath(filepath.Join(configRoot, "lazynpm", "config.yaml")),
+		StateDir:                  newDirPath(filepath.Join(stateRoot, "lazynpm")),
+		CacheDir:                  newDirPath(filepath.Join(cacheRoot, "lazynpm")),
+		LegacyMigrationConfigFile: newFilePath(filepath.Join(home, ".config", "jesseduffield", "lazynpm", "config.yml")),
+	}, nil
+}
+
+func (p PathSet) SelectConfigReadPath(options ConfigReadOptions) (ConfigReadPath, error) {
+	candidates := []ConfigReadPath{
+		{Source: ConfigSourceCLIOverride, Path: newFilePath(options.CLIOverridePath)},
+		{Source: ConfigSourceProject, Path: newFilePath(options.ProjectConfigPath)},
+	}
+	for _, candidate := range candidates {
+		if candidate.Path.String() == "" {
+			continue
+		}
+		exists, err := fileExists(candidate.Path)
+		if err != nil {
+			return ConfigReadPath{}, err
+		}
+		if exists {
+			return candidate, nil
+		}
+	}
+
+	return p.selectUserConfigReadPath()
+}
+
+func (p PathSet) selectUserConfigReadPath() (ConfigReadPath, error) {
+	if exists, err := fileExists(p.WriteConfigFile); err != nil {
+		return ConfigReadPath{}, err
+	} else if exists {
+		return ConfigReadPath{Source: ConfigSourceXDG, Path: p.WriteConfigFile}, nil
+	}
+
+	if exists, err := fileExists(p.LegacyMigrationConfigFile); err != nil {
+		return ConfigReadPath{}, err
+	} else if exists {
+		return ConfigReadPath{Source: ConfigSourceLegacyMigration, Path: p.LegacyMigrationConfigFile}, nil
+	}
+
+	return ConfigReadPath{Source: ConfigSourceDefaults}, nil
+}
+
+func (p PathSet) EnsureDirectories() error {
+	dirs := []DirPath{
+		newDirPath(filepath.Dir(p.WriteConfigFile.String())),
+		p.StateDir,
+		p.CacheDir,
+	}
+	for _, dir := range dirs {
+		if err := os.MkdirAll(dir.String(), userOnlyDirPerm); err != nil {
+			return fmt.Errorf("create config directory %s: %w", dir.String(), err)
+		}
+	}
+	return nil
+}
+
+func (options PathOptions) homeDir() (string, error) {
+	if value, ok := options.lookupEnv("HOME"); ok && value != "" {
+		return value, nil
+	}
+	if options.Env != nil {
+		return "", ErrHomeDirRequired
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("discover home directory: %w", err)
+	}
+	if home == "" {
+		return "", ErrHomeDirRequired
+	}
+	return home, nil
+}
+
+func (options PathOptions) xdgRoot(name string, fallback string) string {
+	if value, ok := options.lookupEnv(name); ok && value != "" {
+		return value
+	}
+	return fallback
+}
+
+func (options PathOptions) lookupEnv(name string) (string, bool) {
+	if options.Env != nil {
+		value, ok := options.Env[name]
+		return value, ok
+	}
+	return os.LookupEnv(name)
+}
+
+func fileExists(path FilePath) (bool, error) {
+	info, err := os.Stat(path.String())
+	if err == nil {
+		if !info.Mode().IsRegular() {
+			return false, fmt.Errorf("%w: %s", ErrConfigPathNotRegularFile, path.String())
+		}
+		return true, nil
+	}
+	if errors.Is(err, os.ErrNotExist) {
+		return false, nil
+	}
+	return false, fmt.Errorf("inspect config file %s: %w", path.String(), err)
+}
+
+func newFilePath(value string) FilePath {
+	return FilePath{value: value}
+}
+
+func newDirPath(value string) DirPath {
+	return DirPath{value: value}
+}

internal/config/paths_test.go

@@ -0,0 +1,186 @@
+package config
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDiscoverPaths_usesXDGDefaults_whenOnlyHomeProvided(t *testing.T) {
+	// Given: an isolated HOME with no XDG override variables.
+	home := t.TempDir()
+
+	// When: config paths are discovered from the injected environment.
+	got, err := DiscoverPaths(PathOptions{Env: map[string]string{"HOME": home}})
+
+	// Then: lazynpm uses XDG defaults plus the legacy read-only migration input.
+	assert.NoError(t, err)
+	assert.Equal(t, filepath.Join(home, ".config", "lazynpm", "config.yaml"), got.WriteConfigFile.String())
+	assert.Equal(t, filepath.Join(home, ".local", "state", "lazynpm"), got.StateDir.String())
+	assert.Equal(t, filepath.Join(home, ".cache", "lazynpm"), got.CacheDir.String())
+	readPath, err := got.SelectConfigReadPath(ConfigReadOptions{})
+	assert.NoError(t, err)
+	assert.Equal(t, ConfigSourceNone, readPath.Source)
+	assert.Equal(t, filepath.Join(home, ".config", "jesseduffield", "lazynpm", "config.yml"), got.LegacyMigrationConfigFile.String())
+}
+
+func TestDiscoverPaths_usesProcessEnvironment_whenXDGVariablesAreUnset(t *testing.T) {
+	// Given: an isolated process environment with no XDG override variables.
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("XDG_CONFIG_HOME", "")
+	t.Setenv("XDG_STATE_HOME", "")
+	t.Setenv("XDG_CACHE_HOME", "")
+
+	// When: config paths are discovered from the process environment.
+	got, err := DiscoverPaths(PathOptions{})
+
+	// Then: discovery never consults the real user's config locations.
+	assert.NoError(t, err)
+	assert.Equal(t, filepath.Join(home, ".config", "lazynpm", "config.yaml"), got.WriteConfigFile.String())
+	assert.Equal(t, filepath.Join(home, ".local", "state", "lazynpm"), got.StateDir.String())
+	assert.Equal(t, filepath.Join(home, ".cache", "lazynpm"), got.CacheDir.String())
+}
+
+func TestDiscoverPaths_usesExplicitXDGEnv_whenProvided(t *testing.T) {
+	// Given: isolated XDG roots and HOME for the legacy migration path.
+	home := t.TempDir()
+	configRoot := filepath.Join(t.TempDir(), "config-root")
+	stateRoot := filepath.Join(t.TempDir(), "state-root")
+	cacheRoot := filepath.Join(t.TempDir(), "cache-root")
+
+	// When: config paths are discovered from explicit XDG variables.
+	got, err := DiscoverPaths(PathOptions{Env: map[string]string{
+		"HOME":            home,
+		"XDG_CONFIG_HOME": configRoot,
+		"XDG_STATE_HOME":  stateRoot,
+		"XDG_CACHE_HOME":  cacheRoot,
+	}})
+
+	// Then: the XDG roots override HOME-derived defaults without changing legacy input.
+	assert.NoError(t, err)
+	assert.Equal(t, filepath.Join(configRoot, "lazynpm", "config.yaml"), got.WriteConfigFile.String())
+	assert.Equal(t, filepath.Join(stateRoot, "lazynpm"), got.StateDir.String())
+	assert.Equal(t, filepath.Join(cacheRoot, "lazynpm"), got.CacheDir.String())
+	assert.Equal(t, filepath.Join(home, ".config", "jesseduffield", "lazynpm", "config.yml"), got.LegacyMigrationConfigFile.String())
+}
+
+func TestPathSet_SelectConfigReadPath_prefersXDG_whenBothConfigsExist(t *testing.T) {
+	// Given: both the new XDG config and the legacy migration file exist.
+	paths := mustDiscoverTempPaths(t)
+	writeFile(t, paths.WriteConfigFile.String())
+	writeFile(t, paths.LegacyMigrationConfigFile.String())
+
+	// When: the read path is selected.
+	got, err := paths.SelectConfigReadPath(ConfigReadOptions{})
+
+	// Then: the new XDG config wins over the legacy migration input.
+	assert.NoError(t, err)
+	assert.Equal(t, ConfigSourceXDG, got.Source)
+	assert.Equal(t, paths.WriteConfigFile.String(), got.Path.String())
+}
+
+func TestPathSet_SelectConfigReadPath_usesLegacy_whenOnlyLegacyExists(t *testing.T) {
+	// Given: only the read-only legacy migration file exists.
+	paths := mustDiscoverTempPaths(t)
+	writeFile(t, paths.LegacyMigrationConfigFile.String())
+
+	// When: the read path is selected.
+	got, err := paths.SelectConfigReadPath(ConfigReadOptions{})
+
+	// Then: the legacy file is available only as a migration source.
+	assert.NoError(t, err)
+	assert.Equal(t, ConfigSourceLegacyMigration, got.Source)
+	assert.Equal(t, paths.LegacyMigrationConfigFile.String(), got.Path.String())
+}
+
+func TestPathSet_SelectConfigReadPath_characterizesExistingUserSourceFallback(t *testing.T) {
+	// Given: an isolated user environment with only the legacy migration file.
+	paths := mustDiscoverTempPaths(t)
+	writeFile(t, paths.LegacyMigrationConfigFile.String())
+
+	// When: the existing user-source selector runs.
+	got, err := paths.SelectConfigReadPath(ConfigReadOptions{})
+
+	// Then: legacy configuration remains the selected read-only fallback.
+	assert.NoError(t, err)
+	assert.Equal(t, ConfigSourceLegacyMigration, got.Source)
+	assert.Equal(t, paths.LegacyMigrationConfigFile.String(), got.Path.String())
+}
+
+func TestPathSet_SelectConfigReadPath_returnsNone_whenNoConfigExists(t *testing.T) {
+	// Given: no config file exists in either the XDG or legacy location.
+	paths := mustDiscoverTempPaths(t)
+
+	// When: the read path is selected.
+	got, err := paths.SelectConfigReadPath(ConfigReadOptions{})
+
+	// Then: discovery succeeds without requiring any user config file.
+	assert.NoError(t, err)
+	assert.Equal(t, ConfigSourceNone, got.Source)
+	assert.Equal(t, "", got.Path.String())
+}
+
+func TestPathSet_SelectConfigReadPath_returnsError_whenXDGConfigPathIsDirectory(t *testing.T) {
+	// Given: the XDG config file location is occupied by a directory.
+	paths := mustDiscoverTempPaths(t)
+	assert.NoError(t, os.MkdirAll(paths.WriteConfigFile.String(), 0700))
+
+	// When: the read path is selected.
+	_, err := paths.SelectConfigReadPath(ConfigReadOptions{})
+
+	// Then: malformed filesystem input is not treated as a usable config source.
+	assert.True(t, errors.Is(err, ErrConfigPathNotRegularFile))
+}
+
+func TestPathSet_EnsureDirectories_createsXDGDirs_whenMissing(t *testing.T) {
+	// Given: discovered paths under isolated temp roots.
+	paths := mustDiscoverTempPaths(t)
+
+	// When: directory creation is requested.
+	err := paths.EnsureDirectories()
+
+	// Then: config, state, and cache directories exist with user-only permissions where supported.
+	assert.NoError(t, err)
+	assertUserOnlyDir(t, filepath.Dir(paths.WriteConfigFile.String()))
+	assertUserOnlyDir(t, paths.StateDir.String())
+	assertUserOnlyDir(t, paths.CacheDir.String())
+	_, err = os.Stat(filepath.Dir(paths.LegacyMigrationConfigFile.String()))
+	assert.True(t, os.IsNotExist(err))
+}
+
+func mustDiscoverTempPaths(t *testing.T) PathSet {
+	t.Helper()
+	home := t.TempDir()
+	paths, err := DiscoverPaths(PathOptions{Env: map[string]string{
+		"HOME":            home,
+		"XDG_CONFIG_HOME": filepath.Join(t.TempDir(), "config-root"),
+		"XDG_STATE_HOME":  filepath.Join(t.TempDir(), "state-root"),
+		"XDG_CACHE_HOME":  filepath.Join(t.TempDir(), "cache-root"),
+	}})
+	assert.NoError(t, err)
+	return paths
+}
+
+func writeFile(t *testing.T, path string) {
+	t.Helper()
+	assert.NoError(t, os.MkdirAll(filepath.Dir(path), 0700))
+	assert.NoError(t, os.WriteFile(path, []byte("config: true\n"), 0600))
+}
+
+func assertUserOnlyDir(t *testing.T, path string) {
+	t.Helper()
+	info, err := os.Stat(path)
+	if !assert.NoError(t, err) {
+		return
+	}
+	assert.True(t, info.IsDir())
+	if runtime.GOOS == "windows" {
+		return
+	}
+	assert.Equal(t, os.FileMode(0700), info.Mode().Perm())
+}