Implement basic installer

Author: evanpurkhiser

installer/compiler.go

@@ -8,6 +8,13 @@ import (
 	"go.evanpurkhiser.com/dots/resolver"
 )
 
+// mustCompile indicates if a dotfile msut be compiled, or if a single-source
+// dotfile does not require any transformations and may be directly installed.
+func shouldCompile(dotfile *resolver.Dotfile, config config.SourceConfig) bool {
+	return len(dotfile.Sources) > 1
+}
+
+// OpenDotfile opens a source dotfile for streaming compilation.
 func OpenDotfile(dotfile *resolver.Dotfile, config config.SourceConfig) (io.ReadCloser, error) {
 	files := make([]*os.File, len(dotfile.Sources))
 

installer/installer.go

@@ -1,165 +1,98 @@
 package installer
 
 import (
+	"fmt"
+	"io"
 	"os"
+	"path"
 	"sync"
 
 	"go.evanpurkhiser.com/dots/config"
-	"go.evanpurkhiser.com/dots/resolver"
 )
 
 const separator = string(os.PathSeparator)
 
-// A PreparedDotfile represents a dotfile that has been "prepared" for
-// installation by verifying it's contents against the existing dotfile, and
-// checking various other flags that require knowledge of the existing dotfile.
-type PreparedDotfile struct {
-	*resolver.Dotfile
+// directoryMode is the mode used to create directories for installed dotfiles.
+const directoryMode = 0755
 
-	// InstallPath is the full path to which the dotfile will be installed.
-	InstallPath string
+// InstallConfig represents configuration options available for installing
+// a single or set of dotfiles.
+type InstallConfig struct {
+	SourceConfig *config.SourceConfig
 
-	// ContentsDiffer is a boolean flag representing that the compiled source
-	// differs from the currently installed dotfile.
-	ContentsDiffer bool
-
-	// SourceModesDiffer indicates that a compiled dotfile (one with multiple
-	// sources) does not have a consistent mode across all sources. In this
-	// case the lowest mode will be used.
-	SourceModesDiffer bool
-
-	// ModeDiffers represents the change in modes between the compiled source
-	// and the currently installed dotfile. Equal modes can be verified by
-	// calling ModeDiff.IsSame.
-	ModeDiff ModeDiff
-
-	// RemovedNull is a warning flag indicating that the removed dotfile does
-	// not exist in the install tree, though the dotfile is marked as removed.
-	RemovedNull bool
-
-	// OverwritesExisting is a warning flag that indicates that installing this
-	// dotfile is overwriting a dotfile that was not part of the lockfile.
-	OverwritesExisting bool
-
-	// PrepareError keeps track of errors while preparing the dotfile. Should
-	// this contain any errors, the PreparedDotfile is likely incomplete.
-	PrepareError error
-}
-
-// ModeDiff represents a change in file mode.
-type ModeDiff struct {
-	Old os.FileMode
-	New os.FileMode
+	// OverrideInstallPath specifies a path to install the dotfile at,
+	// overriding the configuration in the SourceConfig.
+	OverrideInstallPath string
 }
 
-// IsSame returns a boolean value indicating if the modes are equal.
-func (d ModeDiff) IsSame() bool {
-	return d.New == d.Old
-}
+func InstallDotfile(dotfile *PreparedDotfile, config InstallConfig) error {
+	installPath := config.SourceConfig.InstallPath + separator + dotfile.Path
 
-// PreparedDotfiles is a list of prepared dotfiles.
-type PreparedDotfiles []*PreparedDotfile
+	if config.OverrideInstallPath != "" {
+		installPath = config.OverrideInstallPath + separator + dotfile.Path
+	}
 
-// PrepareDotfiles iterates all passed dotfiles and creates an associated
-// PreparedDotfile, returning a list of all prepared dotfiles.
-func PrepareDotfiles(dotfiles resolver.Dotfiles, config config.SourceConfig) PreparedDotfiles {
-	preparedDotfiles := make(PreparedDotfiles, len(dotfiles))
+	if dotfile.SourcesAreIrregular {
+		return fmt.Errorf("Source files are not all regular files")
+	}
 
-	waitGroup := sync.WaitGroup{}
-	waitGroup.Add(len(dotfiles))
+	// No change
+	if !dotfile.IsNew && !dotfile.ContentsDiffer && dotfile.Permissions.IsSame() {
+		return nil
+	}
 
-	prepare := func(index int, dotfile *resolver.Dotfile) {
-		defer waitGroup.Done()
+	// Removed
+	if dotfile.Removed && !dotfile.RemovedNull {
+		return os.Remove(installPath)
+	}
 
-		installPath := config.InstallPath + separator + dotfile.Path
+	targetMode := dotfile.Permissions.New | dotfile.Mode
 
-		prepared := PreparedDotfile{
-			Dotfile:     dotfile,
-			InstallPath: installPath,
-		}
-		preparedDotfiles[index] = &prepared
+	// Only permissions differ
+	if !dotfile.IsNew && !dotfile.Permissions.IsSame() && !dotfile.ContentsDiffer {
+		return os.Chmod(installPath, targetMode)
+	}
 
-		targetStat, targetStatErr := os.Lstat(installPath)
+	if err := os.MkdirAll(path.Dir(installPath), directoryMode); err != nil {
+		return err
+	}
 
-		exists := !os.IsNotExist(targetStatErr)
+	targetOpts := os.O_CREATE | os.O_TRUNC | os.O_WRONLY
 
-		// If we're unable to stat our target installation file and the file
-		// exists there's likely a permissions issue.
-		if targetStatErr != nil && exists {
-			prepared.PrepareError = targetStatErr
-			return
-		}
+	target, err := os.OpenFile(installPath, targetOpts, targetMode)
+	if err != nil {
+		return err
+	}
+	defer target.Close()
 
-		// Nothing needs to be verified if the dotfile is simply being added
-		if dotfile.Added && !exists {
-			return
-		}
+	source, err := OpenDotfile(dotfile.Dotfile, *config.SourceConfig)
+	if err != nil {
+		return err
+	}
+	defer source.Close()
 
-		if dotfile.Added && exists {
-			prepared.OverwritesExisting = true
-		}
+	_, err = io.Copy(target, source)
 
-		if dotfile.Removed && !exists {
-			prepared.RemovedNull = true
-		}
+	return err
+}
 
-		sourceInfo := make([]os.FileInfo, len(dotfile.Sources))
+func InstallDotfiles(dotfiles PreparedDotfiles, config InstallConfig) []error {
+	waitGroup := sync.WaitGroup{}
+	waitGroup.Add(len(dotfiles))
 
-		for i, source := range dotfile.Sources {
-			path := config.SourcePath + separator + source.Path
+	errors := []error{}
 
-			info, err := os.Lstat(path)
+	for _, dotfile := range dotfiles {
+		go func(dotfile *PreparedDotfile) {
+			err := InstallDotfile(dotfile, config)
 			if err != nil {
-				prepared.PrepareError = err
-				return
+				errors = append(errors, err)
 			}
-			sourceInfo[i] = info
-		}
-
-		sourceMode, tookLowest := flattenModes(sourceInfo)
-
-		prepared.ModeDiff = ModeDiff{
-			Old: targetStat.Mode(),
-			New: sourceMode,
-		}
-		prepared.SourceModesDiffer = tookLowest
-
-		// If we are dealing with a dotfile with a single source we can quickly
-		// determine modification based on differing sizes, otherwise we will
-		// have to compare the compiled sources to the installed file.
-		if len(dotfile.Sources) == 1 && targetStat.Size() != sourceInfo[0].Size() {
-			prepared.ContentsDiffer = true
-			return
-		}
-
-		// Compare source and currently instlled dotfile
-		source, err := OpenDotfile(dotfile, config)
-		if err != nil {
-			prepared.PrepareError = err
-			return
-		}
-		defer source.Close()
-
-		target, err := os.Open(installPath)
-		if err != nil {
-			prepared.PrepareError = err
-			return
-		}
-		defer target.Close()
-
-		filesAreSame, err := compareReaders(source, target)
-		if err != nil {
-			prepared.PrepareError = err
-		}
-
-		prepared.ContentsDiffer = !filesAreSame
-	}
-
-	for i, dotfile := range dotfiles {
-		go prepare(i, dotfile)
+			waitGroup.Done()
+		}(dotfile)
 	}
 
 	waitGroup.Wait()
 
-	return preparedDotfiles
+	return errors
 }