FilesExpand file tree

main

/

completion_installer.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

145 lines (119 loc) · 3.76 KB

main

/

completion_installer.go

Copy path

Top

File metadata and controls

• Code
• Blame

145 lines (119 loc) · 3.76 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

137

138

139

140

141

142

143

144

145

//go:build darwin || linux || freebsd || openbsd

package console

import (

"bytes"

"embed"

"fmt"

"os"

"path"

"strings"

"text/template"

"github.com/pkg/errors"

"github.com/posener/complete"

"github.com/symfony-cli/terminal"

)

// CompletionTemplates holds our shell completions templates.

//

//go:embed resources/completion.*

var CompletionTemplates embed.FS

var shellAutoCompleteInstallCommand = &Command{

Category: "self",

Name: "completion",

Aliases: []*Alias{

{Name: "completion"},

},

Usage: "Dumps the completion script for the current shell",

ShellComplete: func(context *Context, c complete.Args) []string {

return []string{"bash", "zsh", "fish"}

},

Description: `The <info>{{.HelpName}}</> command dumps the shell completion script required

to use shell autocompletion (currently, bash, zsh and fish completion are supported).

<comment>Static installation

-------------------</>

Dump the script to a global completion file and restart your shell:

<info>{{.HelpName}} {{ call .Shell }} | sudo tee {{ call .CompletionFile }}</>

Or dump the script to a local file and source it:

<info>{{.HelpName}} {{ call .Shell }} > completion.sh</>

<comment># source the file whenever you use the project</>

<info>source completion.sh</>

<comment># or add this line at the end of your "{{ call .RcFile }}" file:</>

<info>source /path/to/completion.sh</>

<comment>Dynamic installation

--------------------</>

Add this to the end of your shell configuration file (e.g. <info>"{{ call .RcFile }}"</>):

<info>eval "$({{.HelpName}} {{ call .Shell }})"</>`,

DescriptionFunc: func(command *Command, application *Application) string {

var buf bytes.Buffer

tpl := template.Must(template.New("description").Parse(command.Description))

if err := tpl.Execute(&buf, struct {

// allows to directly access any field from the command inside the template

*Command

Shell func() string

RcFile func() string

CompletionFile func() string

}{

Command: command,

Shell: GuessShell,

RcFile: func() string {

switch GuessShell() {

case "fish":

return "~/.config/fish/config.fish"

case "zsh":

return "~/.zshrc"

default:

return "~/.bashrc"

}

},

CompletionFile: func() string {

switch GuessShell() {

case "fish":

return fmt.Sprintf("/etc/fish/completions/%s.fish", application.HelpName)

case "zsh":

return fmt.Sprintf("$fpath[1]/_%s", application.HelpName)

default:

return fmt.Sprintf("/etc/bash_completion.d/%s", application.HelpName)

}

},

}); err != nil {

panic(err)

}

return buf.String()

},

Args: []*Arg{

{

Name: "shell",

Description: `The shell type (e.g. "bash"), the value of the "$SHELL" env var will be used if this is not given`,

Optional: true,

},

},

Action: func(c *Context) error {

shell := c.Args().Get("shell")

if shell == "" {

shell = GuessShell()

}

templates, err := template.ParseFS(CompletionTemplates, "resources/*")

if err != nil {

return errors.WithStack(err)

}

if tpl := templates.Lookup(fmt.Sprintf("completion.%s", shell)); tpl != nil {

return errors.WithStack(tpl.Execute(terminal.Stdout, c))

}

var supportedShell []string

for _, tmpl := range templates.Templates() {

if tmpl.Tree == nil || tmpl.Root == nil {

continue

}

supportedShell = append(supportedShell, strings.TrimLeft(path.Ext(tmpl.Name()), "."))

}

if shell == "" {

return errors.Errorf(`shell not detected, supported shells: "%s"`, strings.Join(supportedShell, ", "))

}

return errors.Errorf(`shell "%s" is not supported, supported shells: "%s"`, shell, strings.Join(supportedShell, ", "))

},

}

func GuessShell() string {

if shell := os.Getenv("SHELL"); shell != "" {

return path.Base(shell)

}

return ""

}