chezmoi2: Factor out diffPatch and fix diffs of new files

chezmoi2/internal/chezmoi/actualstateentry.go

@@ -125,6 +125,10 @@ func (s *ActualStateDir) Remove(system System) error {
 
 // EntryState returns d's entry state.
 func (s *ActualStateFile) EntryState() (*EntryState, error) {
+	contents, err := s.Contents()
+	if err != nil {
+		return nil, err
+	}
 	contentsSHA256, err := s.ContentsSHA256()
 	if err != nil {
 		return nil, err
@@ -133,6 +137,7 @@ func (s *ActualStateFile) EntryState() (*EntryState, error) {
 		Type:           EntryStateTypeFile,
 		Mode:           s.perm,
 		ContentsSHA256: hexBytes(contentsSHA256),
+		contents:       contents,
 	}, nil
 }
 
@@ -148,13 +153,18 @@ func (s *ActualStateFile) Remove(system System) error {
 
 // EntryState returns d's entry state.
 func (s *ActualStateSymlink) EntryState() (*EntryState, error) {
-	contentsSHA256, err := s.LinknameSHA256()
+	linkname, err := s.Linkname()
+	if err != nil {
+		return nil, err
+	}
+	linknameSHA256, err := s.LinknameSHA256()
 	if err != nil {
 		return nil, err
 	}
 	return &EntryState{
 		Type:           EntryStateTypeSymlink,
-		ContentsSHA256: hexBytes(contentsSHA256),
+		ContentsSHA256: hexBytes(linknameSHA256),
+		contents:       []byte(linkname),
 	}, nil
 }
 

chezmoi2/internal/chezmoi/diff.go

@@ -0,0 +1,117 @@
+package chezmoi
+
+import (
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/filemode"
+	"github.com/go-git/go-git/v5/plumbing/format/diff"
+	"github.com/sergi/go-diff/diffmatchpatch"
+)
+
+var gitDiffOperation = map[diffmatchpatch.Operation]diff.Operation{
+	diffmatchpatch.DiffDelete: diff.Delete,
+	diffmatchpatch.DiffEqual:  diff.Equal,
+	diffmatchpatch.DiffInsert: diff.Add,
+}
+
+type gitDiffChunk struct {
+	content   string
+	operation diff.Operation
+}
+
+func (c *gitDiffChunk) Content() string      { return c.content }
+func (c *gitDiffChunk) Type() diff.Operation { return c.operation }
+
+type gitDiffFile struct {
+	hash     plumbing.Hash
+	fileMode filemode.FileMode
+	relPath  RelPath
+}
+
+func (f *gitDiffFile) Hash() plumbing.Hash     { return f.hash }
+func (f *gitDiffFile) Mode() filemode.FileMode { return f.fileMode }
+func (f *gitDiffFile) Path() string            { return string(f.relPath) }
+
+type gitDiffFilePatch struct {
+	isBinary bool
+	from, to diff.File
+	chunks   []diff.Chunk
+}
+
+func (fp *gitDiffFilePatch) IsBinary() bool                { return fp.isBinary }
+func (fp *gitDiffFilePatch) Files() (diff.File, diff.File) { return fp.from, fp.to }
+func (fp *gitDiffFilePatch) Chunks() []diff.Chunk          { return fp.chunks }
+
+type gitDiffPatch struct {
+	filePatches []diff.FilePatch
+	message     string
+}
+
+func (p *gitDiffPatch) FilePatches() []diff.FilePatch { return p.filePatches }
+func (p *gitDiffPatch) Message() string               { return p.message }
+
+func diffChunks(from, to string) []diff.Chunk {
+	dmp := diffmatchpatch.New()
+	dmp.DiffTimeout = time.Second
+	fromRunes, toRunes, runesToLines := dmp.DiffLinesToRunes(from, to)
+	diffs := dmp.DiffCharsToLines(dmp.DiffMainRunes(fromRunes, toRunes, false), runesToLines)
+	chunks := make([]diff.Chunk, 0, len(diffs))
+	for _, d := range diffs {
+		chunk := &gitDiffChunk{
+			content:   d.Text,
+			operation: gitDiffOperation[d.Type],
+		}
+		chunks = append(chunks, chunk)
+	}
+	return chunks
+}
+
+func diffPatch(path RelPath, fromData []byte, fromMode os.FileMode, toData []byte, toMode os.FileMode) (diff.Patch, error) {
+	isBinary := isBinary(fromData) || isBinary(toData)
+
+	var from diff.File
+	if fromData != nil || fromMode != 0 {
+		fromFileMode, err := filemode.NewFromOSFileMode(fromMode)
+		if err != nil {
+			return nil, err
+		}
+		from = &gitDiffFile{
+			fileMode: fromFileMode,
+			relPath:  path,
+			hash:     plumbing.ComputeHash(plumbing.BlobObject, fromData),
+		}
+	}
+
+	toFileMode, err := filemode.NewFromOSFileMode(toMode)
+	if err != nil {
+		return nil, err
+	}
+
+	var chunks []diff.Chunk
+	if !isBinary {
+		chunks = diffChunks(string(fromData), string(toData))
+	}
+
+	return &gitDiffPatch{
+		filePatches: []diff.FilePatch{
+			&gitDiffFilePatch{
+				isBinary: isBinary,
+				from:     from,
+				to: &gitDiffFile{
+					fileMode: toFileMode,
+					relPath:  path,
+					hash:     plumbing.ComputeHash(plumbing.BlobObject, toData),
+				},
+				chunks: chunks,
+			},
+		},
+	}, nil
+}
+
+func isBinary(data []byte) bool {
+	return len(data) != 0 && !strings.HasPrefix(http.DetectContentType(data), "text/")
+}

chezmoi2/internal/chezmoi/entrystate.go

@@ -24,6 +24,12 @@ type EntryState struct {
 	Type           EntryStateType `json:"type" toml:"type" yaml:"type"`
 	Mode           os.FileMode    `json:"mode,omitempty" toml:"mode,omitempty" yaml:"mode,omitempty"`
 	ContentsSHA256 hexBytes       `json:"contentsSHA256,omitempty" toml:"contentsSHA256,omitempty" yaml:"contentsSHA256,omitempty"`
+	contents       []byte
+}
+
+// Contents returns s's contents, if available.
+func (s *EntryState) Contents() []byte {
+	return s.contents
 }
 
 // Equal returns true if s is equal to other.

chezmoi2/internal/chezmoi/gitdiffsystem.go

@@ -2,36 +2,32 @@ package chezmoi
 
 import (
 	"io"
-	"net/http"
 	"os"
 	"os/exec"
-	"strings"
-	"time"
 
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/filemode"
 	"github.com/go-git/go-git/v5/plumbing/format/diff"
-	"github.com/sergi/go-diff/diffmatchpatch"
 	vfs "github.com/twpayne/go-vfs"
 )
 
 // A GitDiffSystem wraps a System and logs all of the actions executed as a git
 // diff.
 type GitDiffSystem struct {
 	system         System
-	dir            AbsPath
+	dirAbsPath     AbsPath
 	unifiedEncoder *diff.UnifiedEncoder
 }
 
 // NewGitDiffSystem returns a new GitDiffSystem.
-func NewGitDiffSystem(system System, w io.Writer, dir AbsPath, color bool) *GitDiffSystem {
+func NewGitDiffSystem(system System, w io.Writer, dirAbsPath AbsPath, color bool) *GitDiffSystem {
 	unifiedEncoder := diff.NewUnifiedEncoder(w, diff.DefaultContextLines)
 	if color {
 		unifiedEncoder.SetColor(diff.NewColorConfig())
 	}
 	return &GitDiffSystem{
 		system:         system,
-		dir:            dir,
+		dirAbsPath:     dirAbsPath,
 		unifiedEncoder: unifiedEncoder,
 	}
 }
@@ -221,53 +217,32 @@ func (s *GitDiffSystem) UnderlyingFS() vfs.FS {
 
 // WriteFile implements System.WriteFile.
 func (s *GitDiffSystem) WriteFile(filename AbsPath, data []byte, perm os.FileMode) error {
-	fromFileMode, _, err := s.fileMode(filename)
 	var fromData []byte
-	switch {
+	var fromMode os.FileMode
+	switch fromInfo, err := s.system.Stat(filename); {
 	case err == nil:
 		fromData, err = s.system.ReadFile(filename)
 		if err != nil {
 			return err
 		}
+		fromMode = fromInfo.Mode()
 	case os.IsNotExist(err):
 	default:
 		return err
 	}
-	toFileMode, err := filemode.NewFromOSFileMode(perm)
+	diffPatch, err := diffPatch(s.trimPrefix(filename), fromData, fromMode, data, perm)
 	if err != nil {
 		return err
 	}
-	path := s.trimPrefix(filename)
-	isBinary := isBinary(fromData) || isBinary(data)
-	var chunks []diff.Chunk
-	if !isBinary {
-		chunks = diffChunks(string(fromData), string(data))
-	}
-	if err := s.unifiedEncoder.Encode(&gitDiffPatch{
-		filePatches: []diff.FilePatch{
-			&gitDiffFilePatch{
-				isBinary: isBinary,
-				from: &gitDiffFile{
-					fileMode: fromFileMode,
-					relPath:  path,
-					hash:     plumbing.ComputeHash(plumbing.BlobObject, fromData),
-				},
-				to: &gitDiffFile{
-					fileMode: toFileMode,
-					relPath:  path,
-					hash:     plumbing.ComputeHash(plumbing.BlobObject, data),
-				},
-				chunks: chunks,
-			},
-		},
-	}); err != nil {
+	if err := s.unifiedEncoder.Encode(diffPatch); err != nil {
 		return err
 	}
 	return s.system.WriteFile(filename, data, perm)
 }
 
 // WriteSymlink implements System.WriteSymlink.
 func (s *GitDiffSystem) WriteSymlink(oldname string, newname AbsPath) error {
+	// FIXME if newname already exists then we should
 	if err := s.unifiedEncoder.Encode(&gitDiffPatch{
 		filePatches: []diff.FilePatch{
 			&gitDiffFilePatch{
@@ -300,67 +275,5 @@ func (s *GitDiffSystem) fileMode(name AbsPath) (filemode.FileMode, os.FileInfo,
 }
 
 func (s *GitDiffSystem) trimPrefix(absPath AbsPath) RelPath {
-	return absPath.MustTrimDirPrefix(s.dir)
-}
-
-var gitDiffOperation = map[diffmatchpatch.Operation]diff.Operation{
-	diffmatchpatch.DiffDelete: diff.Delete,
-	diffmatchpatch.DiffEqual:  diff.Equal,
-	diffmatchpatch.DiffInsert: diff.Add,
-}
-
-type gitDiffChunk struct {
-	content   string
-	operation diff.Operation
-}
-
-func (c *gitDiffChunk) Content() string      { return c.content }
-func (c *gitDiffChunk) Type() diff.Operation { return c.operation }
-
-type gitDiffFile struct {
-	hash     plumbing.Hash
-	fileMode filemode.FileMode
-	relPath  RelPath
-}
-
-func (f *gitDiffFile) Hash() plumbing.Hash     { return f.hash }
-func (f *gitDiffFile) Mode() filemode.FileMode { return f.fileMode }
-func (f *gitDiffFile) Path() string            { return string(f.relPath) }
-
-type gitDiffFilePatch struct {
-	isBinary bool
-	from, to diff.File
-	chunks   []diff.Chunk
-}
-
-func (fp *gitDiffFilePatch) IsBinary() bool                { return fp.isBinary }
-func (fp *gitDiffFilePatch) Files() (diff.File, diff.File) { return fp.from, fp.to }
-func (fp *gitDiffFilePatch) Chunks() []diff.Chunk          { return fp.chunks }
-
-type gitDiffPatch struct {
-	filePatches []diff.FilePatch
-	message     string
-}
-
-func (p *gitDiffPatch) FilePatches() []diff.FilePatch { return p.filePatches }
-func (p *gitDiffPatch) Message() string               { return p.message }
-
-func diffChunks(from, to string) []diff.Chunk {
-	dmp := diffmatchpatch.New()
-	dmp.DiffTimeout = time.Second
-	fromRunes, toRunes, runesToLines := dmp.DiffLinesToRunes(from, to)
-	diffs := dmp.DiffCharsToLines(dmp.DiffMainRunes(fromRunes, toRunes, false), runesToLines)
-	chunks := make([]diff.Chunk, 0, len(diffs))
-	for _, d := range diffs {
-		chunk := &gitDiffChunk{
-			content:   d.Text,
-			operation: gitDiffOperation[d.Type],
-		}
-		chunks = append(chunks, chunk)
-	}
-	return chunks
-}
-
-func isBinary(data []byte) bool {
-	return len(data) != 0 && !strings.HasPrefix(http.DetectContentType(data), "text/")
+	return absPath.MustTrimDirPrefix(s.dirAbsPath)
 }

chezmoi2/internal/chezmoi/targetstateentry.go

@@ -171,6 +171,10 @@ func (t *TargetStateFile) Apply(system System, persistentState PersistentState,
 
 // EntryState returns t's entry state.
 func (t *TargetStateFile) EntryState() (*EntryState, error) {
+	contents, err := t.Contents()
+	if err != nil {
+		return nil, err
+	}
 	contentsSHA256, err := t.ContentsSHA256()
 	if err != nil {
 		return nil, err
@@ -179,6 +183,7 @@ func (t *TargetStateFile) EntryState() (*EntryState, error) {
 		Type:           EntryStateTypeFile,
 		Mode:           t.perm,
 		ContentsSHA256: hexBytes(contentsSHA256),
+		contents:       contents,
 	}, nil
 }
 
@@ -391,13 +396,18 @@ func (t *TargetStateSymlink) Apply(system System, persistentState PersistentStat
 
 // EntryState returns t's entry state.
 func (t *TargetStateSymlink) EntryState() (*EntryState, error) {
+	linkname, err := t.Linkname()
+	if err != nil {
+		return nil, err
+	}
 	linknameSHA256, err := t.LinknameSHA256()
 	if err != nil {
 		return nil, err
 	}
 	return &EntryState{
 		Type:           EntryStateTypeSymlink,
 		ContentsSHA256: linknameSHA256,
+		contents:       []byte(linkname),
 	}, nil
 }