git-evac/source/actions/Pull.go at master · cookiengineer/git-evac · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package actions

import "git-evac/structs"
import "bytes"
import "errors"
import "os/exec"
import "sort"
import "strings"

func Pull(profile *structs.Profile, owner_name string, repo_name string) error {

	if profile.HasRepositoryOwner(owner_name) {

		owner := profile.GetRepositoryOwner(owner_name)

		if owner != nil && owner.HasRepository(repo_name) {

			repository := owner.GetRepository(repo_name)
			folder := repository.Folder

			if strings.HasSuffix(folder, "/.git") {
				folder = folder[0:len(folder)-5]
			}

			// 1. git fetch --all
			var stdout_fetch bytes.Buffer
			var stderr_fetch bytes.Buffer

			cmd_fetch := exec.Command("git", "fetch", "--all")
			cmd_fetch.Dir = folder
			cmd_fetch.Stdout = &stdout_fetch
			cmd_fetch.Stderr = &stderr_fetch

			err_fetch := cmd_fetch.Run()

			if err_fetch == nil {

				// 2. git diff --name-status master..origin/master
				var stdout_diff bytes.Buffer
				var stderr_diff bytes.Buffer

				cmd_diff := exec.Command(
					"git",
					"diff",
					"--name-status",
					repository.CurrentBranch + "..origin/" + repository.CurrentBranch,
				)
				cmd_diff.Dir = folder
				cmd_diff.Stdout = &stdout_diff
				cmd_diff.Stderr = &stderr_diff

				err_diff := cmd_diff.Run()

				if err_diff == nil {

					diff_status := strings.TrimSpace(stdout_diff.String())

					if diff_status == "" {
						// No remote changes, no merge necessary
						return nil
					} else {

						// Remote changes could look like this:
						// M       CONFLICT.txt
						// TODO: M might be an indicator of potential merge conflict

						// 3. git merge --no-edit origin/master
						var stdout_merge bytes.Buffer
						var stderr_merge bytes.Buffer

						cmd_merge := exec.Command(
							"git",
							"merge",
							"--no-edit",
							"origin/" + repository.CurrentBranch,
						)
						cmd_merge.Dir = folder
						cmd_merge.Stdout = &stdout_merge
						cmd_merge.Stderr = &stderr_merge

						err_merge := cmd_merge.Run()

						if err_merge == nil {
							// Remote changes, no local changes, merge successful
							return nil
						} else {

							conflicts := make(map[string]bool)
							lines := strings.Split(strings.TrimSpace(stdout_merge.String()), "\n")

							for _, line := range lines {

								if strings.HasPrefix(line, "CONFLICT") && strings.Contains(line, "Merge conflict in ") {
									filepath := strings.TrimSpace(line[strings.Index(line, "Merge conflict in ")+18:])
									conflicts[filepath] = true
								}

							}

							if len(conflicts) == 0 {
								return nil
							} else {

								files := make([]string, 0)

								for file, _ := range conflicts {
									files = append(files, file)
								}

								sort.Strings(files)

								return errors.New("Repository \"" + owner_name + "/" + repo_name + "\" failed to merge changes for files \"" + strings.Join(files, "\", \"") + "\"")

							}

						}

					}

				} else {
					return errors.New("Repository \"" + owner_name + "/" + repo_name + "\" failed to diff against origin remote")
				}

			} else {
				return errors.New("Repository \"" + owner_name + "/" + repo_name + "\" failed to fetch all remotes")
			}

		} else {
			return errors.New("Repository \"" + owner_name + "/" + repo_name + "\" does not exist")
		}

	} else {
		return errors.New("Owner \"" + owner_name + "\" does not exist")
	}

}