1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101

package git

import (
	"bytes"
	"fmt"
	"log"
	"os/exec"
	"strings"

	"github.com/bluekeyes/go-gitdiff/gitdiff"
	"github.com/go-git/go-git/v5/plumbing/object"

	"github.com/pocka/legit/git/exe"
)

// SystemDiff generates diff lines using system git.
func SystemDiff(repoPath string, commit *object.Commit) (*NiceDiff, error) {
	var err error
	var parent *object.Commit
	if parent, err = commit.Parent(0); err != nil {
		if err != object.ErrParentNotFound {
			return nil, fmt.Errorf("unable to read parent of %s: %w", commit.Hash, err)
		}
	}

	nd := NiceDiff{}
	nd.Commit = commit
	nd.Parent = parent
	if parent == nil {
		nd.Parent = &object.Commit{}
	}

	diffs, err := getSystemGitDiff(repoPath, commit)
	if err == nil {
		nd.Files = diffs

		for _, d := range diffs {
			for _, tf := range d.TextFragments {
				for _, l := range tf.Lines {
					switch l.Op {
					case gitdiff.OpAdd:
						nd.Stat.Insertions += 1
					case gitdiff.OpDelete:
						nd.Stat.Deletions += 1
					}
				}
			}
		}

		nd.Stat.FilesChanged = len(diffs)
	} else {
		log.Printf("diff generation failed: %s", err)
	}

	return &nd, nil
}

func getSystemGitDiff(repoPath string, commit *object.Commit) ([]*gitdiff.File, error) {
	cmd := exec.Command(exe.GitBin(), []string{
		// repo.scanPath is trusted directory, thus g.path (inside repo.scanPath) is
		// trusted too.
		// https://git-scm.com/docs/git-config#Documentation/git-config.txt-safedirectory
		"-c", fmt.Sprintf("safe.directory=%s", repoPath),
		"-C", repoPath,
		"show", commit.Hash.String(),
		"--no-ext-diff",
	}...)

	cmd.Env = []string{
		// By default, system git tries to read from various places.
		// We want deterministic, configuration independent behavior here.
		"GIT_CONFIG_GLOBAL=/dev/null",
		"GIT_CONFIG_SYSTEM=/dev/null",
		"GIT_CONFIG_NOSYSTEM=1",
		fmt.Sprintf("GIT_CEILING_DIRECTORIES=%s", repoPath),
	}
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return nil, fmt.Errorf("stdout pipe init failure: %w", err)
	}
	defer stdout.Close()
	stderr := strings.Builder{}
	cmd.Stderr = &stderr
	cmd.Stdin = &bytes.Reader{}

	if err := cmd.Start(); err != nil {
		return nil, fmt.Errorf("unable to start system git-diff: %w", err)
	}

	diffs, _, err := gitdiff.Parse(stdout)
	if err != nil {
		return nil, fmt.Errorf("unable to parse git diff: %w", err)
	}

	if err := cmd.Wait(); err != nil {
		log.Print(stderr.String())
		return nil, fmt.Errorf("unable to run system git-diff: %w", err)
	}

	return diffs, nil
}