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
|
// Inspired by the git-appraise project
// Package input contains helpers to use a text editor as an input for
// various field of a bug
package input
import (
"bufio"
"bytes"
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"github.com/go-git/go-billy/v5/util"
"github.com/MichaelMure/git-bug/repository"
)
// LaunchEditorWithTemplate will launch an editor as LaunchEditor do, but with a
// provided template.
func LaunchEditorWithTemplate(repo repository.RepoCommonStorage, fileName string, template string) (string, error) {
err := util.WriteFile(repo.LocalStorage(), fileName, []byte(template), 0644)
if err != nil {
return "", err
}
return LaunchEditor(repo, fileName)
}
// LaunchEditor launches the default editor configured for the given repo. This
// method blocks until the editor command has returned.
//
// The specified filename should be a temporary file and provided as a relative path
// from the repo (e.g. "FILENAME" will be converted to "[<reporoot>/].git/git-bug/FILENAME"). This file
// will be deleted after the editor is closed and its contents have been read.
//
// This method returns the text that was read from the temporary file, or
// an error if any step in the process failed.
func LaunchEditor(repo repository.RepoCommonStorage, fileName string) (string, error) {
defer repo.LocalStorage().Remove(fileName)
editor, err := repo.GetCoreEditor()
if err != nil {
return "", fmt.Errorf("Unable to detect default git editor: %v\n", err)
}
repo.LocalStorage().Root()
// bypass the interface but that's ok: we need that because we are communicating
// the absolute path to an external program
path := filepath.Join(repo.LocalStorage().Root(), fileName)
cmd, err := startInlineCommand(editor, path)
if err != nil {
// Running the editor directly did not work. This might mean that
// the editor string is not a path to an executable, but rather
// a shell command (e.g. "emacsclient --tty"). As such, we'll try
// to run the command through bash, and if that fails, try with sh
args := []string{"-c", fmt.Sprintf("%s %q", editor, path)}
cmd, err = startInlineCommand("bash", args...)
if err != nil {
cmd, err = startInlineCommand("sh", args...)
}
}
if err != nil {
return "", fmt.Errorf("Unable to start editor: %v\n", err)
}
if err := cmd.Wait(); err != nil {
return "", fmt.Errorf("Editing finished with error: %v\n", err)
}
output, err := ioutil.ReadFile(path)
if err != nil {
return "", fmt.Errorf("Error reading edited file: %v\n", err)
}
return string(output), err
}
// FromFile loads and returns the contents of a given file. If - is passed
// through, much like git, it will read from stdin. This can be piped data,
// unless there is a tty in which case the user will be prompted to enter a
// message.
func FromFile(fileName string) (string, error) {
if fileName == "-" {
stat, err := os.Stdin.Stat()
if err != nil {
return "", fmt.Errorf("Error reading from stdin: %v\n", err)
}
if (stat.Mode() & os.ModeCharDevice) == 0 {
// There is no tty. This will allow us to read piped data instead.
output, err := ioutil.ReadAll(os.Stdin)
if err != nil {
return "", fmt.Errorf("Error reading from stdin: %v\n", err)
}
return string(output), err
}
fmt.Printf("(reading comment from standard input)\n")
var output bytes.Buffer
s := bufio.NewScanner(os.Stdin)
for s.Scan() {
output.Write(s.Bytes())
output.WriteRune('\n')
}
return output.String(), nil
}
output, err := ioutil.ReadFile(fileName)
if err != nil {
return "", fmt.Errorf("Error reading file: %v\n", err)
}
return string(output), err
}
func startInlineCommand(command string, args ...string) (*exec.Cmd, error) {
cmd := exec.Command(command, args...)
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Start()
return cmd, err
}
|
