fzf/src/options.go

528 lines
14 KiB
Go
Raw Normal View History

2015-01-01 19:49:30 +00:00
package fzf
import (
"fmt"
"os"
"regexp"
"strings"
"unicode/utf8"
"github.com/junegunn/fzf/src/curses"
2015-01-12 03:56:17 +00:00
"github.com/junegunn/go-shellwords"
2015-01-01 19:49:30 +00:00
)
2015-01-11 18:01:24 +00:00
const usage = `usage: fzf [options]
2015-01-01 19:49:30 +00:00
Search mode
2015-01-01 19:49:30 +00:00
-x, --extended Extended-search mode
-e, --extended-exact Extended-search mode (exact match)
-i Case-insensitive match (default: smart-case match)
+i Case-sensitive match
-n, --nth=N[,..] Comma-separated list of field index expressions
for limiting search scope. Each can be a non-zero
integer or a range expression ([BEGIN]..[END])
--with-nth=N[,..] Transform the item using index expressions for search
-d, --delimiter=STR Field delimiter regex for --nth (default: AWK-style)
Search result
+s, --no-sort Do not sort the result
--tac Reverse the order of the input
--tiebreak=CRI Sort criterion when the scores are tied;
[length|begin|end|index] (default: length)
2015-01-01 19:49:30 +00:00
Interface
-m, --multi Enable multi-select with tab/shift-tab
2015-03-22 12:25:46 +00:00
--ansi Enable processing of ANSI color codes
2015-01-01 19:49:30 +00:00
--no-mouse Disable mouse
2015-04-18 01:38:12 +00:00
--color=COL Color scheme; [dark|light|16|bw]
(default: dark on 256-color terminal, otherwise 16)
2015-01-01 19:49:30 +00:00
--black Use black background
--reverse Reverse orientation
--no-hscroll Disable horizontal scroll
2015-04-21 14:50:53 +00:00
--inline-info Display finder info inline with the query
2015-01-01 19:49:30 +00:00
--prompt=STR Input prompt (default: '> ')
Scripting
-q, --query=STR Start the finder with the given query
-1, --select-1 Automatically select the only match
-0, --exit-0 Exit immediately when there's no match
-f, --filter=STR Filter mode. Do not start interactive finder.
--print-query Print query as the first line
--expect=KEYS Comma-separated list of keys to complete fzf
2015-03-31 13:05:02 +00:00
--toggle-sort=KEY Key to toggle sort
2015-05-20 12:25:15 +00:00
--bind=KEYBINDS Custom key bindings. Refer to the man page.
2015-02-13 03:25:19 +00:00
--sync Synchronous search for multi-staged filtering
2015-01-01 19:49:30 +00:00
Environment variables
FZF_DEFAULT_COMMAND Default command to use when input is tty
2015-02-13 03:25:19 +00:00
FZF_DEFAULT_OPTS Defaults options. (e.g. '-x -m')
2015-01-01 19:49:30 +00:00
`
2015-01-11 18:01:24 +00:00
// Mode denotes the current search mode
2015-01-01 19:49:30 +00:00
type Mode int
2015-01-11 18:01:24 +00:00
// Search modes
2015-01-01 19:49:30 +00:00
const (
2015-01-11 18:01:24 +00:00
ModeFuzzy Mode = iota
ModeExtended
ModeExtendedExact
2015-01-01 19:49:30 +00:00
)
2015-01-11 18:01:24 +00:00
// Case denotes case-sensitivity of search
2015-01-01 19:49:30 +00:00
type Case int
2015-01-11 18:01:24 +00:00
// Case-sensitivities
2015-01-01 19:49:30 +00:00
const (
2015-01-11 18:01:24 +00:00
CaseSmart Case = iota
CaseIgnore
CaseRespect
2015-01-01 19:49:30 +00:00
)
// Sort criteria
type tiebreak int
const (
byLength tiebreak = iota
byBegin
byEnd
byIndex
)
2015-01-11 18:01:24 +00:00
// Options stores the values of command-line options
2015-01-01 19:49:30 +00:00
type Options struct {
Mode Mode
Case Case
Nth []Range
WithNth []Range
Delimiter *regexp.Regexp
Sort int
Tac bool
Tiebreak tiebreak
2015-01-01 19:49:30 +00:00
Multi bool
2015-03-18 16:59:14 +00:00
Ansi bool
2015-01-01 19:49:30 +00:00
Mouse bool
Theme *curses.ColorTheme
2015-01-01 19:49:30 +00:00
Black bool
Reverse bool
Hscroll bool
2015-04-21 14:50:53 +00:00
InlineInfo bool
2015-01-01 19:49:30 +00:00
Prompt string
Query string
Select1 bool
Exit0 bool
Filter *string
2015-05-20 12:25:15 +00:00
ToggleSort bool
Expect []int
2015-05-20 12:25:15 +00:00
Keymap map[int]actionType
2015-01-01 19:49:30 +00:00
PrintQuery bool
2015-02-13 03:25:19 +00:00
Sync bool
2015-01-01 19:49:30 +00:00
Version bool
}
2015-01-11 18:01:24 +00:00
func defaultOptions() *Options {
var defaultTheme *curses.ColorTheme
if strings.Contains(os.Getenv("TERM"), "256") {
defaultTheme = curses.Dark256
} else {
defaultTheme = curses.Default16
}
2015-01-01 19:49:30 +00:00
return &Options{
2015-01-11 18:01:24 +00:00
Mode: ModeFuzzy,
Case: CaseSmart,
2015-01-01 19:49:30 +00:00
Nth: make([]Range, 0),
WithNth: make([]Range, 0),
Delimiter: nil,
Sort: 1000,
Tac: false,
Tiebreak: byLength,
2015-01-01 19:49:30 +00:00
Multi: false,
2015-03-18 16:59:14 +00:00
Ansi: false,
2015-01-01 19:49:30 +00:00
Mouse: true,
Theme: defaultTheme,
2015-01-01 19:49:30 +00:00
Black: false,
Reverse: false,
Hscroll: true,
2015-04-21 14:50:53 +00:00
InlineInfo: false,
2015-01-01 19:49:30 +00:00
Prompt: "> ",
Query: "",
Select1: false,
Exit0: false,
Filter: nil,
2015-05-20 12:25:15 +00:00
ToggleSort: false,
Expect: []int{},
2015-05-20 12:25:15 +00:00
Keymap: defaultKeymap(),
2015-01-01 19:49:30 +00:00
PrintQuery: false,
2015-02-13 03:25:19 +00:00
Sync: false,
2015-01-01 19:49:30 +00:00
Version: false}
}
func help(ok int) {
2015-01-11 18:01:24 +00:00
os.Stderr.WriteString(usage)
2015-01-01 19:49:30 +00:00
os.Exit(ok)
}
func errorExit(msg string) {
os.Stderr.WriteString(msg + "\n")
help(1)
}
func optString(arg string, prefix string) (bool, string) {
rx, _ := regexp.Compile(fmt.Sprintf("^(?:%s)(.*)$", prefix))
matches := rx.FindStringSubmatch(arg)
if len(matches) > 1 {
return true, matches[1]
}
2015-01-11 18:01:24 +00:00
return false, ""
2015-01-01 19:49:30 +00:00
}
func nextString(args []string, i *int, message string) string {
if len(args) > *i+1 {
*i++
} else {
errorExit(message)
}
return args[*i]
}
func optionalNumeric(args []string, i *int) int {
if len(args) > *i+1 {
if strings.IndexAny(args[*i+1], "0123456789") == 0 {
*i++
}
}
return 1 // Don't care
}
func splitNth(str string) []Range {
if match, _ := regexp.MatchString("^[0-9,-.]+$", str); !match {
errorExit("invalid format: " + str)
}
tokens := strings.Split(str, ",")
ranges := make([]Range, len(tokens))
for idx, s := range tokens {
r, ok := ParseRange(&s)
if !ok {
errorExit("invalid format: " + str)
}
ranges[idx] = r
}
return ranges
}
func delimiterRegexp(str string) *regexp.Regexp {
rx, e := regexp.Compile(str)
if e != nil {
str = regexp.QuoteMeta(str)
}
rx, e = regexp.Compile(fmt.Sprintf("(?:.*?%s)|(?:.+?$)", str))
if e != nil {
errorExit("invalid regular expression: " + e.Error())
}
return rx
}
func isAlphabet(char uint8) bool {
return char >= 'a' && char <= 'z'
}
2015-03-31 13:05:02 +00:00
func parseKeyChords(str string, message string) []int {
if len(str) == 0 {
errorExit(message)
}
tokens := strings.Split(str, ",")
if str == "," || strings.HasPrefix(str, ",,") || strings.HasSuffix(str, ",,") || strings.Index(str, ",,,") >= 0 {
tokens = append(tokens, ",")
}
var chords []int
2015-03-31 13:05:02 +00:00
for _, key := range tokens {
if len(key) == 0 {
continue // ignore
}
lkey := strings.ToLower(key)
if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) {
chords = append(chords, curses.CtrlA+int(lkey[5])-'a')
} else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isAlphabet(lkey[4]) {
chords = append(chords, curses.AltA+int(lkey[4])-'a')
} else if len(key) == 2 && strings.HasPrefix(lkey, "f") && key[1] >= '1' && key[1] <= '4' {
chords = append(chords, curses.F1+int(key[1])-'1')
} else if utf8.RuneCountInString(key) == 1 {
chords = append(chords, curses.AltZ+int([]rune(key)[0]))
} else {
errorExit("unsupported key: " + key)
}
}
return chords
}
func parseTiebreak(str string) tiebreak {
switch strings.ToLower(str) {
case "length":
return byLength
case "index":
return byIndex
case "begin":
return byBegin
case "end":
return byEnd
default:
errorExit("invalid sort criterion: " + str)
}
return byLength
}
func parseTheme(str string) *curses.ColorTheme {
switch strings.ToLower(str) {
case "dark":
return curses.Dark256
case "light":
return curses.Light256
case "16":
return curses.Default16
2015-04-18 01:38:12 +00:00
case "bw", "no":
return nil
default:
errorExit("invalid color scheme: " + str)
}
return nil
}
2015-05-20 12:25:15 +00:00
func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[int]actionType, bool) {
for _, pairStr := range strings.Split(str, ",") {
pair := strings.Split(pairStr, ":")
if len(pair) != 2 {
errorExit("invalid key binding: " + pairStr)
}
keys := parseKeyChords(pair[0], "key name required")
if len(keys) != 1 {
errorExit("invalid key binding: " + pairStr)
}
key := keys[0]
act := strings.ToLower(pair[1])
switch strings.ToLower(pair[1]) {
case "beginning-of-line":
keymap[key] = actBeginningOfLine
case "abort":
keymap[key] = actAbort
case "accept":
keymap[key] = actAccept
case "backward-char":
keymap[key] = actBackwardChar
case "backward-delete-char":
keymap[key] = actBackwardDeleteChar
case "backward-word":
keymap[key] = actBackwardWord
case "clear-screen":
keymap[key] = actClearScreen
case "delete-char":
keymap[key] = actDeleteChar
case "end-of-line":
keymap[key] = actEndOfLine
case "forward-char":
keymap[key] = actForwardChar
case "forward-word":
keymap[key] = actForwardWord
case "kill-line":
keymap[key] = actKillLine
case "kill-word":
keymap[key] = actKillWord
case "unix-line-discard", "line-discard":
keymap[key] = actUnixLineDiscard
case "unix-word-rubout", "word-rubout":
keymap[key] = actUnixWordRubout
case "yank":
keymap[key] = actYank
case "backward-kill-word":
keymap[key] = actBackwardKillWord
case "toggle-down":
keymap[key] = actToggleDown
case "toggle-up":
keymap[key] = actToggleUp
case "down":
keymap[key] = actDown
case "up":
keymap[key] = actUp
case "page-up":
keymap[key] = actPageUp
case "page-down":
keymap[key] = actPageDown
case "toggle-sort":
keymap[key] = actToggleSort
toggleSort = true
default:
errorExit("unknown action: " + act)
}
}
return keymap, toggleSort
}
func checkToggleSort(keymap map[int]actionType, str string) map[int]actionType {
2015-03-31 13:05:02 +00:00
keys := parseKeyChords(str, "key name required")
if len(keys) != 1 {
errorExit("multiple keys specified")
}
2015-05-20 12:25:15 +00:00
keymap[keys[0]] = actToggleSort
return keymap
2015-03-31 13:05:02 +00:00
}
2015-01-01 19:49:30 +00:00
func parseOptions(opts *Options, allArgs []string) {
for i := 0; i < len(allArgs); i++ {
arg := allArgs[i]
switch arg {
case "-h", "--help":
help(0)
case "-x", "--extended":
2015-01-11 18:01:24 +00:00
opts.Mode = ModeExtended
2015-01-01 19:49:30 +00:00
case "-e", "--extended-exact":
2015-01-11 18:01:24 +00:00
opts.Mode = ModeExtendedExact
2015-01-01 19:49:30 +00:00
case "+x", "--no-extended", "+e", "--no-extended-exact":
2015-01-11 18:01:24 +00:00
opts.Mode = ModeFuzzy
2015-01-01 19:49:30 +00:00
case "-q", "--query":
opts.Query = nextString(allArgs, &i, "query string required")
case "-f", "--filter":
filter := nextString(allArgs, &i, "query string required")
opts.Filter = &filter
case "--expect":
2015-03-31 13:05:02 +00:00
opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
case "--tiebreak":
opts.Tiebreak = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
2015-05-20 12:25:15 +00:00
case "--bind":
opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, nextString(allArgs, &i, "bind expression required"))
case "--color":
opts.Theme = parseTheme(nextString(allArgs, &i, "color scheme name required"))
2015-03-31 13:05:02 +00:00
case "--toggle-sort":
2015-05-20 12:25:15 +00:00
opts.Keymap = checkToggleSort(opts.Keymap, nextString(allArgs, &i, "key name required"))
opts.ToggleSort = true
2015-01-01 19:49:30 +00:00
case "-d", "--delimiter":
opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
case "-n", "--nth":
opts.Nth = splitNth(nextString(allArgs, &i, "nth expression required"))
case "--with-nth":
opts.WithNth = splitNth(nextString(allArgs, &i, "nth expression required"))
case "-s", "--sort":
opts.Sort = optionalNumeric(allArgs, &i)
case "+s", "--no-sort":
opts.Sort = 0
case "--tac":
opts.Tac = true
case "--no-tac":
opts.Tac = false
2015-01-01 19:49:30 +00:00
case "-i":
2015-01-11 18:01:24 +00:00
opts.Case = CaseIgnore
2015-01-01 19:49:30 +00:00
case "+i":
2015-01-11 18:01:24 +00:00
opts.Case = CaseRespect
2015-01-01 19:49:30 +00:00
case "-m", "--multi":
opts.Multi = true
case "+m", "--no-multi":
opts.Multi = false
2015-03-18 16:59:14 +00:00
case "--ansi":
opts.Ansi = true
case "--no-ansi":
opts.Ansi = false
2015-01-01 19:49:30 +00:00
case "--no-mouse":
opts.Mouse = false
case "+c", "--no-color":
opts.Theme = nil
2015-01-01 19:49:30 +00:00
case "+2", "--no-256":
opts.Theme = curses.Default16
2015-01-01 19:49:30 +00:00
case "--black":
opts.Black = true
case "--no-black":
opts.Black = false
case "--reverse":
opts.Reverse = true
case "--no-reverse":
opts.Reverse = false
case "--hscroll":
opts.Hscroll = true
case "--no-hscroll":
opts.Hscroll = false
2015-04-21 14:50:53 +00:00
case "--inline-info":
opts.InlineInfo = true
case "--no-inline-info":
opts.InlineInfo = false
2015-01-01 19:49:30 +00:00
case "-1", "--select-1":
opts.Select1 = true
case "+1", "--no-select-1":
opts.Select1 = false
case "-0", "--exit-0":
opts.Exit0 = true
case "+0", "--no-exit-0":
opts.Exit0 = false
case "--print-query":
opts.PrintQuery = true
case "--no-print-query":
opts.PrintQuery = false
case "--prompt":
opts.Prompt = nextString(allArgs, &i, "prompt string required")
2015-02-13 03:25:19 +00:00
case "--sync":
opts.Sync = true
case "--no-sync":
opts.Sync = false
case "--async":
opts.Sync = false
2015-01-01 19:49:30 +00:00
case "--version":
opts.Version = true
default:
if match, value := optString(arg, "-q|--query="); match {
opts.Query = value
} else if match, value := optString(arg, "-f|--filter="); match {
opts.Filter = &value
} else if match, value := optString(arg, "-d|--delimiter="); match {
opts.Delimiter = delimiterRegexp(value)
} else if match, value := optString(arg, "--prompt="); match {
opts.Prompt = value
} else if match, value := optString(arg, "-n|--nth="); match {
opts.Nth = splitNth(value)
} else if match, value := optString(arg, "--with-nth="); match {
opts.WithNth = splitNth(value)
} else if match, _ := optString(arg, "-s|--sort="); match {
opts.Sort = 1 // Don't care
2015-03-31 13:05:02 +00:00
} else if match, value := optString(arg, "--toggle-sort="); match {
2015-05-20 12:25:15 +00:00
opts.Keymap = checkToggleSort(opts.Keymap, value)
opts.ToggleSort = true
} else if match, value := optString(arg, "--expect="); match {
2015-03-31 13:05:02 +00:00
opts.Expect = parseKeyChords(value, "key names required")
} else if match, value := optString(arg, "--tiebreak="); match {
opts.Tiebreak = parseTiebreak(value)
} else if match, value := optString(arg, "--color="); match {
opts.Theme = parseTheme(value)
2015-05-20 12:25:15 +00:00
} else if match, value := optString(arg, "--bind="); match {
opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, value)
2015-01-01 19:49:30 +00:00
} else {
errorExit("unknown option: " + arg)
}
}
}
// If we're not using extended search mode, --nth option becomes irrelevant
// if it contains the whole range
if opts.Mode == ModeFuzzy || len(opts.Nth) == 1 {
for _, r := range opts.Nth {
if r.begin == rangeEllipsis && r.end == rangeEllipsis {
opts.Nth = make([]Range, 0)
return
}
}
}
2015-01-01 19:49:30 +00:00
}
2015-01-11 18:01:24 +00:00
// ParseOptions parses command-line options
2015-01-01 19:49:30 +00:00
func ParseOptions() *Options {
2015-01-11 18:01:24 +00:00
opts := defaultOptions()
2015-01-01 19:49:30 +00:00
// Options from Env var
words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
parseOptions(opts, words)
// Options from command-line arguments
parseOptions(opts, os.Args[1:])
return opts
}