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
|
package msg
import (
"encoding/base64"
"errors"
"fmt"
"io"
"mime/quotedprintable"
"os/exec"
"strings"
"time"
"git.sr.ht/~sircmpwn/aerc/commands"
"git.sr.ht/~sircmpwn/aerc/widgets"
"git.sr.ht/~sircmpwn/getopt"
"github.com/gdamore/tcell"
)
type Pipe struct{}
func init() {
register(Pipe{})
}
func (_ Pipe) Aliases() []string {
return []string{"pipe"}
}
func (_ Pipe) Complete(aerc *widgets.Aerc, args []string) []string {
return nil
}
func (_ Pipe) Execute(aerc *widgets.Aerc, args []string) error {
var (
background bool
pipeFull bool
pipePart bool
)
// TODO: let user specify part by index or preferred mimetype
opts, optind, err := getopt.Getopts(args, "bmp")
if err != nil {
return err
}
for _, opt := range opts {
switch opt.Option {
case 'b':
background = true
case 'm':
if pipePart {
return errors.New("-m and -p are mutually exclusive")
}
pipeFull = true
case 'p':
if pipeFull {
return errors.New("-m and -p are mutually exclusive")
}
pipePart = true
}
}
cmd := args[optind:]
if len(cmd) == 0 {
return errors.New("Usage: pipe [-mp] <cmd> [args...]")
}
provider := aerc.SelectedTab().(widgets.ProvidesMessage)
if !pipeFull && !pipePart {
if _, ok := provider.(*widgets.MessageViewer); ok {
pipePart = true
} else if _, ok := provider.(*widgets.AccountView); ok {
pipeFull = true
} else {
return errors.New(
"Neither -m nor -p specified and cannot infer default")
}
}
doTerm := func(reader io.Reader, name string) {
term, err := commands.QuickTerm(aerc, cmd, reader)
if err != nil {
aerc.PushError(" " + err.Error())
return
}
aerc.NewTab(term, name)
}
doExec := func(reader io.Reader) {
ecmd := exec.Command(cmd[0], cmd[1:]...)
err := ecmd.Run()
if err != nil {
aerc.PushStatus(" "+err.Error(), 10*time.Second).
Color(tcell.ColorDefault, tcell.ColorRed)
} else {
aerc.PushStatus(fmt.Sprintf(
"%s: completed with status %d", args[0],
ecmd.ProcessState.ExitCode()), 10*time.Second).
Color(tcell.ColorDefault, tcell.ColorDefault)
}
}
if pipeFull {
store := provider.Store()
msg := provider.SelectedMessage()
store.FetchFull([]uint32{msg.Uid}, func(reader io.Reader) {
if background {
doExec(reader)
} else {
doTerm(reader, fmt.Sprintf(
"%s <%s", cmd[0], msg.Envelope.Subject))
}
})
} else if pipePart {
p := provider.SelectedMessagePart()
p.Store.FetchBodyPart(p.Msg.Uid, p.Index, func(reader io.Reader) {
// email parts are encoded as 7bit (plaintext), quoted-printable, or base64
if strings.EqualFold(p.Part.Encoding, "base64") {
reader = base64.NewDecoder(base64.StdEncoding, reader)
} else if strings.EqualFold(p.Part.Encoding, "quoted-printable") {
reader = quotedprintable.NewReader(reader)
}
if background {
doExec(reader)
} else {
name := fmt.Sprintf("%s <%s/[%d]",
cmd[0], p.Msg.Envelope.Subject, p.Index)
doTerm(reader, name)
}
})
}
return nil
}
|
