mirror of https://github.com/Llewellynvdm/fzf.git
Merge branch 'devel'
This commit is contained in:
Junegunn Choi
commit
8ae604af67
13
README.md
13
README.md
|
|
@ -114,6 +114,19 @@ The following readline key bindings should also work as expected.
|
|||
If you enable multi-select mode with `-m` option, you can select multiple items
|
||||
with TAB or Shift-TAB key.
|
||||
|
||||
### Extended mode
|
||||
|
||||
With `-x` or `--extended` option, fzf will start in "extended mode".
|
||||
|
||||
In extended mode, you can specify multiple patterns delimited by spaces, such as: `^music .mp3$ sbtrkt !rmx`
|
||||
|
||||
| Token | Description | Match type |
|
||||
| -------- | ----------------------------- | -------------------- |
|
||||
| `^music` | Items that start with `music` | prefix-exact-match |
|
||||
| `.mp3$` | Items that end with `.mp3` | suffix-exact-match |
|
||||
| `sbtrkt` | Items that match `sbtrkt` | fuzzy-match |
|
||||
| `!rmx` | Items that do not match `rmx` | invert-fuzzy-match |
|
||||
|
||||
Usage as Vim plugin
|
||||
-------------------
|
||||
|
||||
|
|
|
|||
7
Rakefile
7
Rakefile
|
|
@ -1 +1,8 @@
|
|||
require "bundler/gem_tasks"
|
||||
require 'rake/testtask'
|
||||
|
||||
Rake::TestTask.new(:test) do |test|
|
||||
test.pattern = 'test/**/test_*.rb'
|
||||
test.verbose = true
|
||||
end
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
# coding: utf-8
|
||||
Gem::Specification.new do |spec|
|
||||
spec.name = 'fzf'
|
||||
spec.version = '0.3.1'
|
||||
spec.version = '0.4.0'
|
||||
spec.authors = ['Junegunn Choi']
|
||||
spec.email = ['junegunn.c@gmail.com']
|
||||
spec.description = %q{Fuzzy finder for your shell}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,297 @@
|
|||
#!/usr/bin/env ruby
|
||||
# encoding: utf-8
|
||||
|
||||
require 'minitest/autorun'
|
||||
$LOAD_PATH.unshift File.expand_path('../..', __FILE__)
|
||||
load 'fzf'
|
||||
|
||||
class TestFZF < MiniTest::Unit::TestCase
|
||||
def test_default_options
|
||||
fzf = FZF.new []
|
||||
assert_equal 500, fzf.sort
|
||||
assert_equal false, fzf.multi
|
||||
assert_equal true, fzf.color
|
||||
assert_equal Regexp::IGNORECASE, fzf.rxflag
|
||||
|
||||
begin
|
||||
ENV['FZF_DEFAULT_SORT'] = '1000'
|
||||
fzf = FZF.new []
|
||||
assert_equal 1000, fzf.sort
|
||||
ensure
|
||||
ENV.delete 'FZF_DEFAULT_SORT'
|
||||
end
|
||||
end
|
||||
|
||||
def test_option_parser
|
||||
# Long opts
|
||||
fzf = FZF.new %w[--sort=2000 --no-color --multi +i]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal 0, fzf.rxflag
|
||||
|
||||
# Short opts
|
||||
fzf = FZF.new %w[-s 2000 +c -m +i]
|
||||
assert_equal 2000, fzf.sort
|
||||
assert_equal true, fzf.multi
|
||||
assert_equal false, fzf.color
|
||||
assert_equal 0, fzf.rxflag
|
||||
end
|
||||
|
||||
def test_invalid_option
|
||||
[%w[-s 2000 +s], %w[yo dawg]].each do |argv|
|
||||
assert_raises(SystemExit) do
|
||||
fzf = FZF.new argv
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# FIXME Only on 1.9 or above
|
||||
def test_width
|
||||
fzf = FZF.new []
|
||||
assert_equal 5, fzf.width('abcde')
|
||||
assert_equal 4, fzf.width('한글')
|
||||
assert_equal 5, fzf.width('한글.')
|
||||
end
|
||||
|
||||
def test_trim
|
||||
fzf = FZF.new []
|
||||
assert_equal ['사.', 6], fzf.trim('가나다라마바사.', 4, true)
|
||||
assert_equal ['바사.', 5], fzf.trim('가나다라마바사.', 5, true)
|
||||
assert_equal ['바사.', 5], fzf.trim('가나다라마바사.', 6, true)
|
||||
assert_equal ['마바사.', 4], fzf.trim('가나다라마바사.', 7, true)
|
||||
assert_equal ['가나', 6], fzf.trim('가나다라마바사.', 4, false)
|
||||
assert_equal ['가나', 6], fzf.trim('가나다라마바사.', 5, false)
|
||||
assert_equal ['가나a', 6], fzf.trim('가나ab라마바사.', 5, false)
|
||||
assert_equal ['가나ab', 5], fzf.trim('가나ab라마바사.', 6, false)
|
||||
assert_equal ['가나ab', 5], fzf.trim('가나ab라마바사.', 7, false)
|
||||
end
|
||||
|
||||
def test_format
|
||||
fzf = FZF.new []
|
||||
assert_equal [['01234..', false]], fzf.format('0123456789', 7, [])
|
||||
assert_equal [['012', false], ['34', true], ['..', false]],
|
||||
fzf.format('0123456789', 7, [[3, 5]])
|
||||
assert_equal [['..56', false], ['789', true]],
|
||||
fzf.format('0123456789', 7, [[7, 10]])
|
||||
assert_equal [['..56', false], ['78', true], ['9', false]],
|
||||
fzf.format('0123456789', 7, [[7, 9]])
|
||||
|
||||
(3..5).each do |i|
|
||||
assert_equal [['..', false], ['567', true], ['89', false]],
|
||||
fzf.format('0123456789', 7, [[i, 8]])
|
||||
end
|
||||
|
||||
assert_equal [['..', false], ['345', true], ['..', false]],
|
||||
fzf.format('0123456789', 7, [[3, 6]])
|
||||
assert_equal [['012', false], ['34', true], ['..', false]],
|
||||
fzf.format('0123456789', 7, [[3, 5]])
|
||||
|
||||
# Multi-region
|
||||
assert_equal [["0", true], ["1", false], ["2", true], ["34..", false]],
|
||||
fzf.format('0123456789', 7, [[0, 1], [2, 3]])
|
||||
|
||||
assert_equal [["..", false], ["5", true], ["6", false], ["78", true], ["9", false]],
|
||||
fzf.format('0123456789', 7, [[3, 6], [7, 9]])
|
||||
|
||||
assert_equal [["..", false], ["3", true], ["4", false], ["5", true], ["..", false]],
|
||||
fzf.format('0123456789', 7, [[3, 4], [5, 6]])
|
||||
|
||||
# Multi-region Overlap
|
||||
assert_equal [["..", false], ["345", true], ["..", false]],
|
||||
fzf.format('0123456789', 7, [[4, 5], [3, 6]])
|
||||
end
|
||||
|
||||
def test_fuzzy_matcher
|
||||
matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
|
||||
list = %w[
|
||||
juice
|
||||
juiceful
|
||||
juiceless
|
||||
juicily
|
||||
juiciness
|
||||
juicy]
|
||||
assert matcher.caches.empty?
|
||||
assert_equal(
|
||||
[["juice", [[0, 1]]],
|
||||
["juiceful", [[0, 1]]],
|
||||
["juiceless", [[0, 1]]],
|
||||
["juicily", [[0, 1]]],
|
||||
["juiciness", [[0, 1]]],
|
||||
["juicy", [[0, 1]]]], matcher.match(list, 'j', '', '').sort)
|
||||
assert !matcher.caches.empty?
|
||||
assert_equal [list.object_id], matcher.caches.keys
|
||||
assert_equal 1, matcher.caches[list.object_id].length
|
||||
assert_equal 6, matcher.caches[list.object_id]['j'].length
|
||||
|
||||
assert_equal(
|
||||
[["juicily", [[0, 5]]],
|
||||
["juiciness", [[0, 5]]]], matcher.match(list, 'jii', '', '').sort)
|
||||
|
||||
assert_equal(
|
||||
[["juicily", [[2, 5]]],
|
||||
["juiciness", [[2, 5]]]], matcher.match(list, 'ii', '', '').sort)
|
||||
|
||||
assert_equal 3, matcher.caches[list.object_id].length
|
||||
assert_equal 2, matcher.caches[list.object_id]['ii'].length
|
||||
|
||||
# TODO : partial_cache
|
||||
end
|
||||
|
||||
def test_fuzzy_matcher_case_sensitive
|
||||
assert_equal [['Fruit', [[0, 5]]]],
|
||||
FZF::FuzzyMatcher.new(0).match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
|
||||
|
||||
assert_equal [["Fruit", [[0, 5]]], ["Grapefruit", [[5, 10]]]],
|
||||
FZF::FuzzyMatcher.new(Regexp::IGNORECASE).
|
||||
match(%w[Fruit Grapefruit], 'Fruit', '', '').sort
|
||||
end
|
||||
|
||||
def test_extended_fuzzy_matcher
|
||||
matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
|
||||
list = %w[
|
||||
juice
|
||||
juiceful
|
||||
juiceless
|
||||
juicily
|
||||
juiciness
|
||||
juicy
|
||||
_juice]
|
||||
match = proc { |q, prefix|
|
||||
matcher.match(list, q, prefix, '').sort.map { |p| [p.first, p.last.sort] }
|
||||
}
|
||||
|
||||
assert matcher.caches.empty?
|
||||
3.times do
|
||||
['y j', 'j y'].each do |pat|
|
||||
(0..pat.length - 1).each do |prefix_length|
|
||||
prefix = pat[0, prefix_length]
|
||||
assert_equal(
|
||||
[["juicily", [[0, 1], [6, 7]]],
|
||||
["juicy", [[0, 1], [4, 5]]]],
|
||||
match.call(pat, prefix))
|
||||
end
|
||||
end
|
||||
|
||||
# $
|
||||
assert_equal [["juiceful", [[7, 8]]]], match.call('l$', '')
|
||||
assert_equal [["juiceful", [[7, 8]]],
|
||||
["juiceless", [[5, 6]]],
|
||||
["juicily", [[5, 6]]]], match.call('l', '')
|
||||
|
||||
# ^
|
||||
assert_equal list.length, match.call('j', '').length
|
||||
assert_equal list.length - 1, match.call('^j', '').length
|
||||
|
||||
# !
|
||||
assert_equal 0, match.call('!j', '').length
|
||||
|
||||
# ! + ^
|
||||
assert_equal [["_juice", []]], match.call('!^j', '')
|
||||
|
||||
# ! + $
|
||||
assert_equal list.length - 1, match.call('!l$', '').length
|
||||
|
||||
# ! + f
|
||||
assert_equal [["juicy", [[4, 5]]]], match.call('y !l', '')
|
||||
end
|
||||
assert !matcher.caches.empty?
|
||||
end
|
||||
|
||||
def test_xfuzzy_matcher_prefix_cache
|
||||
matcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
|
||||
list = %w[
|
||||
a.java
|
||||
b.java
|
||||
java.jive
|
||||
c.java$
|
||||
d.java
|
||||
]
|
||||
2.times do
|
||||
assert_equal 5, matcher.match(list, 'java', 'java', '').length
|
||||
assert_equal 3, matcher.match(list, 'java$', 'java$', '').length
|
||||
assert_equal 1, matcher.match(list, 'java$$', 'java$$', '').length
|
||||
|
||||
assert_equal 0, matcher.match(list, '!java', '!java', '').length
|
||||
assert_equal 4, matcher.match(list, '!^jav', '!^jav', '').length
|
||||
assert_equal 4, matcher.match(list, '!^java', '!^java', '').length
|
||||
assert_equal 2, matcher.match(list, '!^java !b !c', '!^java', '').length
|
||||
end
|
||||
end
|
||||
|
||||
def test_sort_by_rank
|
||||
matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
|
||||
xmatcher = FZF::ExtendedFuzzyMatcher.new Regexp::IGNORECASE
|
||||
list = %w[
|
||||
0____1
|
||||
0_____1
|
||||
01
|
||||
____0_1
|
||||
01_
|
||||
_01_
|
||||
0______1
|
||||
___01___
|
||||
]
|
||||
assert_equal(
|
||||
[["01", [[0, 2]]],
|
||||
["01_", [[0, 2]]],
|
||||
["_01_", [[1, 3]]],
|
||||
["___01___", [[3, 5]]],
|
||||
["____0_1", [[4, 7]]],
|
||||
["0____1", [[0, 6]]],
|
||||
["0_____1", [[0, 7]]],
|
||||
["0______1", [[0, 8]]]],
|
||||
FZF.new([]).sort_by_rank(matcher.match(list, '01', '', '')))
|
||||
|
||||
assert_equal(
|
||||
[["01", [[0, 1], [1, 2]]],
|
||||
["01_", [[0, 1], [1, 2]]],
|
||||
["_01_", [[1, 2], [2, 3]]],
|
||||
["0____1", [[0, 1], [5, 6]]],
|
||||
["0_____1", [[0, 1], [6, 7]]],
|
||||
["____0_1", [[4, 5], [6, 7]]],
|
||||
["0______1", [[0, 1], [7, 8]]],
|
||||
["___01___", [[3, 4], [4, 5]]]],
|
||||
FZF.new([]).sort_by_rank(xmatcher.match(list, '0 1', '', '')))
|
||||
|
||||
assert_equal(
|
||||
[["_01_", [[1, 3], [0, 4]]],
|
||||
["0____1", [[0, 6], [1, 3]]],
|
||||
["0_____1", [[0, 7], [1, 3]]],
|
||||
["0______1", [[0, 8], [1, 3]]],
|
||||
["___01___", [[3, 5], [0, 2]]],
|
||||
["____0_1", [[4, 7], [0, 2]]]],
|
||||
FZF.new([]).sort_by_rank(xmatcher.match(list, '01 __', '', '')))
|
||||
end
|
||||
|
||||
if RUBY_PLATFORM =~ /darwin/
|
||||
NFD = '한글'
|
||||
def test_nfc
|
||||
assert_equal 6, NFD.length
|
||||
assert_equal ["한글", [[0, 1], [1, 2]]],
|
||||
FZF::UConv.nfc(NFD, [[0, 3], [3, 6]])
|
||||
|
||||
nfd2 = 'before' + NFD + 'after'
|
||||
assert_equal 6 + 6 + 5, nfd2.length
|
||||
|
||||
nfc, offsets = FZF::UConv.nfc(nfd2, [[4, 14], [9, 13]])
|
||||
o1, o2 = offsets
|
||||
assert_equal 'before한글after', nfc
|
||||
assert_equal 're한글af', nfc[(o1.first...o1.last)]
|
||||
assert_equal '글a', nfc[(o2.first...o2.last)]
|
||||
end
|
||||
|
||||
def test_nfd
|
||||
nfc = '한글'
|
||||
nfd = FZF::UConv.nfd(nfc)
|
||||
assert_equal 6, nfd.length
|
||||
assert_equal NFD, nfd
|
||||
end
|
||||
end
|
||||
|
||||
def test_split
|
||||
assert_equal ["a", "b", "c", "\xFF", "d", "e", "f"],
|
||||
FZF::UConv.split("abc\xFFdef")
|
||||
end
|
||||
end
|
||||
|
||||
Loading…
Reference in New Issue