Refactoring for test

fzf

@@ -10,7 +10,7 @@
 # URL:         https://github.com/junegunn/fzf
 # Author:      Junegunn Choi
 # License:     MIT
-# Last update: November 10, 2013
+# Last update: November 15, 2013
 #
 # Copyright (c) 2013 Junegunn Choi
 #
@@ -35,8 +35,78 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-def usage x
+require 'thread'
-  puts %[usage: fzf [options]
+require 'curses'
+
+class FZF
+  C = Curses
+  attr_reader :rxflag, :sort, :color, :multi
+
+  class AtomicVar
+    def initialize value
+      @value = value
+      @mutex = Mutex.new
+    end
+
+    def get
+      @mutex.synchronize { @value }
+    end
+
+    def set value = nil
+      if block_given?
+        @mutex.synchronize { @value = yield @value }
+      else
+        @mutex.synchronize { @value = value }
+      end
+    end
+
+    def method_missing sym, *args, &blk
+      @mutex.synchronize { @value.send(sym, *args, &blk) }
+    end
+  end
+
+  def initialize argv, source = $stdin
+    usage 0 unless (%w[--help -h] & argv).empty?
+    @rxflag = argv.delete('+i') ? 0 : Regexp::IGNORECASE
+    @sort   = %w[+s --no-sort].map  { |e| argv.delete e }.compact.empty? ?
+      ENV.fetch('FZF_DEFAULT_SORT', 500).to_i : nil
+    @color  = %w[+c --no-color].map { |e| argv.delete e }.compact.empty?
+    @multi  = !%w[-m --multi].map   { |e| argv.delete e }.compact.empty?
+    rest    = argv.join ' '
+    if sort = rest.match(/(-s|--sort=?) ?([0-9]+)/)
+      usage 1 unless @sort
+      @sort = sort[2].to_i
+      rest  = rest.delete sort[0]
+    end
+    usage 1 unless rest.empty?
+
+    @source   = source
+    @mtx      = Mutex.new
+    @cv       = ConditionVariable.new
+    @events   = {}
+    @new      = []
+    @smtx     = Mutex.new
+    @cursor_x = AtomicVar.new(0)
+    @query    = AtomicVar.new('')
+    @matches  = AtomicVar.new([])
+    @count    = AtomicVar.new(0)
+    @vcursor  = AtomicVar.new(0)
+    @fan      = AtomicVar.new('-\|/-\|/'.split(//))
+    @selects  = AtomicVar.new({}) # ordered >= 1.9
+  end
+
+  def start
+    @stdout = $stdout.clone
+    $stdout.reopen($stderr)
+
+    init_screen
+    start_reader
+    start_search
+    start_loop
+  end
+
+  def usage x
+    $stderr.puts %[usage: fzf [options]
 
     -m, --multi      Enable multi-select
     -s, --sort=MAX   Maximum number of matched items to sort. Default: 500.
@@ -44,43 +114,10 @@ def usage x
     +i               Case-sensitive match
     +c, --no-color   Disable colors]
     exit x
-end
+  end
 
-stdout = $stdout.clone
+  case RUBY_PLATFORM
-$stdout.reopen($stderr)
+  when /darwin/
-
-usage 0 unless (%w[--help -h] & ARGV).empty?
-@rxflag = ARGV.delete('+i') ? 0 : Regexp::IGNORECASE
-@sort   = %w[+s --no-sort].map  { |e| ARGV.delete e }.compact.empty? ?
-  ENV.fetch('FZF_DEFAULT_SORT', 500).to_i : nil
-@color  = %w[+c --no-color].map { |e| ARGV.delete e }.compact.empty?
-@multi  = !%w[-m --multi].map   { |e| ARGV.delete e }.compact.empty?
-rest    = ARGV.join ' '
-if sort = rest.match(/(-s|--sort=?) ?([0-9]+)/)
-  usage 1 unless @sort
-  @sort = sort[2].to_i
-  rest  = rest.delete sort[0]
-end
-usage 1 unless rest.empty?
-
-require 'thread'
-require 'curses'
-
-@mtx      = Mutex.new
-@smtx     = Mutex.new
-@cv       = ConditionVariable.new
-@lists    = []
-@new      = []
-@query    = ''
-@matches  = []
-@count    = 0
-@cursor_x = 0
-@vcursor  = 0
-@events   = {}
-@selects  = {} # ordered >= 1.9
-
-case RUBY_PLATFORM
-when /darwin/
     module UConv
       CHOSUNG   = 0x1100
       JUNGSUNG  = 0x1161
@@ -145,50 +182,52 @@ when /darwin/
       end
     end
 
-  def convert_query q
-    UConv.nfd(q).split(//)
-  end
-
     def convert_item item
       UConv.nfc(*item)
     end
-else
-  def convert_query q
-    q.split(//)
-  end
 
+    class Matcher
+      def convert_query q
+        UConv.nfd(q).split(//)
+      end
+    end
+  else
     def convert_item item
       item
     end
-end
 
-def emit event
+    class Matcher
+      def convert_query q
+        q.split(//)
+      end
+    end
+  end
+
+  def emit event
     @mtx.synchronize do
       @events[event] = yield
       @cv.broadcast
     end
-end
+  end
 
-C = Curses
+  def max_items; C.lines - 2; end
-def max_items; C.lines - 2; end
+  def cursor_y;  C.lines - 1; end
-def cursor_y;  C.lines - 1; end
+  def cprint str, col
-def cprint str, col
     C.attron(col) do
       C.addstr str.gsub("\0", '')
     end if str
-end
+  end
 
-def print_input
+  def print_input
     C.setpos cursor_y, 0
     C.clrtoeol
     cprint '> ', color(:blue, true)
     C.attron(C::A_BOLD) do
-    C.addstr @query
+      C.addstr @query.get
+    end
   end
-end
 
-def print_info selected, msg = nil
+  def print_info msg = nil
-  @fan ||= '-\|/-\|/'.split(//)
     C.setpos cursor_y - 1, 0
     C.clrtoeol
     prefix =
@@ -200,22 +239,24 @@ def print_info selected, msg = nil
         '  '
       end
     C.attron color(:info, false) do
-    C.addstr "#{prefix}#{@matches.length}/#{@count}"
+      C.addstr "#{prefix}#{@matches.length}/#{@count.get}"
-    C.addstr " (#{selected})" if selected > 0
+      if (selected = @selects.length) > 0
+        C.addstr " (#{selected})"
+      end
       C.addstr msg if msg
     end
-end
+  end
 
-def refresh
+  def refresh
-  C.setpos cursor_y, 2 + width(@query[0, @cursor_x])
+    C.setpos cursor_y, 2 + width(@query[0, @cursor_x.get])
     C.refresh
-end
+  end
 
-def ctrl char
+  def ctrl char
     char.to_s.ord - 'a'.ord + 1
-end
+  end
 
-def format line, limit, offsets
+  def format line, limit, offsets
     offsets ||= []
     maxe = offsets.map { |e| e.last }.max || 0
 
@@ -253,9 +294,9 @@ def format line, limit, offsets
     end
     tokens << [line[index..-1], false]
     tokens.reject { |pair| pair.first.empty? }
-end
+  end
 
-def print_item row, tokens, chosen, selected
+  def print_item row, tokens, chosen, selected
     # Cursor
     C.setpos row, 0
     C.clrtoeol
@@ -276,25 +317,34 @@ def print_item row, tokens, chosen, selected
       end
     end
     C.attroff color(:chosen, true) if chosen
-end
+  end
 
-if RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join > '001009'
+  def sort_by_rank list
-  @wrx = Regexp.new '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
+    list.sort_by { |tuple|
+      line, offsets = tuple
+      matchlen = (offsets.map { |pair| pair.last  }.max || 0) -
+                 (offsets.map { |pair| pair.first }.min || 0)
+      [matchlen, line.length, line]
+    }
+  end
+
+  if RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join > '001009'
+    @@wrx = Regexp.new '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
     def width str
-    str.gsub(@wrx, '  ').length
+      str.gsub(@@wrx, '  ').length
     end
 
     def trim str, len, left
       width = width str
       diff  = 0
       while width > len
-      width -= (left ? str[0, 1] : str[-1, 1]) =~ @wrx ? 2 : 1
+        width -= (left ? str[0, 1] : str[-1, 1]) =~ @@wrx ? 2 : 1
         str    = left ? str[1..-1] : str[0...-1]
         diff  += 1
       end
       [str, diff]
     end
-else
+  else
     def width str
       str.length
     end
@@ -308,32 +358,33 @@ else
       end
     end
 
-  class String
+    class ::String
       def ord
         self.unpack('c').first
       end
     end
 
-  class Fixnum
+    class ::Fixnum
       def ord
         self
       end
     end
-end
+  end
 
-C.init_screen
+  def init_screen
-C.start_color
+    C.init_screen
-dbg =
+    C.start_color
+    dbg =
       if C.respond_to?(:use_default_colors)
         C.use_default_colors
         -1
       else
         C::COLOR_BLACK
       end
-C.raw
+    C.raw
-C.noecho
+    C.noecho
 
-if @color
+    if @color
       if C.can_change_color?
         fg = ENV.fetch('FZF_FG', 252).to_i
         bg = ENV.fetch('FZF_BG', 236).to_i
@@ -354,13 +405,13 @@ if @color
         C.init_pair 7, C::COLOR_RED,    C::COLOR_BLACK
       end
 
-  def color sym, bold = false
+      def self.color sym, bold = false
         C.color_pair([:blue, :match, :chosen,
                       :match!, :fan, :info, :red].index(sym) + 1) |
           (bold ? C::A_BOLD : 0)
       end
-else
+    else
-  def color sym, bold = false
+      def self.color sym, bold = false
         case sym
         when :chosen
           bold ? C::A_REVERSE : 0
@@ -372,10 +423,12 @@ else
           0
         end | (bold ? C::A_BOLD : 0)
       end
-end
+    end
+  end
 
-@read =
+  def start_reader
-  if $stdin.tty?
+    stream =
+      if @source.tty?
         if default_command = ENV['FZF_DEFAULT_COMMAND']
           IO.popen(default_command)
         elsif !`which find`.empty?
@@ -384,27 +437,28 @@ end
           exit 1
         end
       else
-    $stdin
+        @source
       end
 
-reader = Thread.new {
+    Thread.new do
-  while line = @read.gets
+      while line = stream.gets
         emit(:new) { @new << line.chomp }
       end
       emit(:loaded) { true }
-  @smtx.synchronize { @fan = [] }
+      @fan.clear
-}
+    end
+  end
 
-main     = Thread.current
+  def start_search
-searcher = Thread.new {
+    main     = Thread.current
+    matcher  = FuzzyMatcher.new @rxflag
+    searcher = Thread.new {
+      lists   = []
       events  = {}
       fcache  = {}
-  matches = []
-  selects = {}
       mcount  = 0  # match count
       plcount = 0  # prev list count
       q       = ''
-  vcursor = 0
       delay   = -5
 
       begin
@@ -422,15 +476,11 @@ searcher = Thread.new {
             end
 
             if events[:new]
-          @lists << [@new, {}]
+              lists << @new
-          @count += @new.length
+              @count.set { |c| c + @new.length }
               @new    = []
               fcache  = {}
             end
-
-        if events[:select]
-          selects = @selects.dup
-        end
           end#mtx
 
           new_search = events[:key] || events.delete(:new)
@@ -438,71 +488,38 @@ searcher = Thread.new {
           progress   = 0
           started_at = Time.now
 
-      if new_search && !@lists.empty?
+          if new_search && !lists.empty?
-        q = events.delete(:key) || q
+            q, cx = events.delete(:key) || [q, 0]
 
-        unless q.empty?
+            plcount = [@matches.length, max_items].min
-          q = q.downcase if @rxflag != 0
+            @matches.set(fcache[q] ||=
-          regexp = Regexp.new(convert_query(q).inject('') { |sum, e|
-            e = Regexp.escape e
-            sum << "#{e}[^#{e}]*?"
-          }, @rxflag)
-        end
-
-        matches = fcache[q] ||=
               begin
                 found = []
                 skip  = false
                 cnt   = 0
-            @lists.each do |pair|
+                lists.each do |list|
-              list, cache = pair
                   cnt += list.length
-
+                  skip = @mtx.synchronize { @events[:key] }
-              @mtx.synchronize {
-                skip = @events[:key]
-                progress = (100 * cnt / @count)
-              }
                   break if skip
 
-              found.concat(cache[q] ||= q.empty? ? list : begin
+                  progress = (100 * cnt / @count.get)
-                if progress < 100 && Time.now - started_at > 0.5
+                  if progress < 100 && Time.now - started_at > 0.5 && !q.empty?
                     @smtx.synchronize do
-                    print_info selects.length, " (#{progress}%)"
+                      print_info " (#{progress}%)"
                       refresh
                     end
                   end
 
-                prefix, suffix = @query[0, @cursor_x], @query[@cursor_x..-1] || ''
+                  found.concat(q.empty? ? list :
-                prefix_cache = suffix_cache = nil
+                               matcher.match(list, q, q[0, cx], q[cx..-1]))
-
-                (prefix.length - 1).downto(1) do |len|
-                  break if prefix_cache = cache[prefix[0, len]]
-                end
-
-                0.upto(suffix.length - 1) do |idx|
-                  break if suffix_cache = cache[suffix[idx..-1]]
-                end unless suffix.empty?
-
-                partial_cache = [prefix_cache, suffix_cache].compact.sort_by { |e| e.length }.first
-                (partial_cache ? partial_cache.map { |e| e.first } : list).map { |line|
-                  # Ignore errors: e.g. invalid byte sequence in UTF-8
-                  md = line.match(regexp) rescue nil
-                  md && [line, [md.offset(0)]]
-                }.compact
-              end)
                 end
                 next if skip
                 @sort ? found : found.reverse
-          end
+              end)
 
-        mcount = matches.length
+            mcount = @matches.length
             if @sort && mcount <= @sort && !q.empty?
-          matches.replace matches.sort_by { |tuple|
+              @matches.set { |m| sort_by_rank m }
-            line, offsets = tuple
-            matchlen = offsets.map { |pair| pair.last }.max || 0 -
-                       offsets.map { |pair| pair.first }.min || 0
-            [matchlen, line.length, line]
-          }
             end
           end#new_search
 
@@ -510,11 +527,7 @@ searcher = Thread.new {
           sleep((delay = [20, delay + 5].min) * 0.01) unless user_input
 
           if events.delete(:vcursor) || new_search
-        @mtx.synchronize do
+            @vcursor.set { |v| [0, [v, mcount - 1, max_items - 1].min].max }
-          plcount  = [@matches.length, max_items].min
-          @matches = matches
-          vcursor  = @vcursor = [0, [@vcursor, mcount - 1, max_items - 1].min].max
-        end
           end
 
           # Output
@@ -528,27 +541,30 @@ searcher = Thread.new {
             end
 
             maxc    = C.cols - 3
-        matches[0, max_items].each_with_index do |item, idx|
+            vcursor = @vcursor.get
+            @matches[0, max_items].each_with_index do |item, idx|
               next if !new_search && !((vcursor-1)..(vcursor+1)).include?(idx)
               row           = cursor_y - idx - 2
               chosen        = idx == vcursor
-          selected = selects.include?([*item][0])
+              selected      = @selects.include?([*item][0])
               line, offsets = convert_item item
               tokens        = format line, maxc, offsets
               print_item row, tokens, chosen, selected
             end
 
-        print_info selects.length if !@lists.empty? || events[:loaded]
+            print_info if !lists.empty? || events[:loaded]
             refresh
           end
         end#while
       rescue Exception => e
         main.raise e
       end
-}
+    }
+  end
 
-got = nil
+  def start_loop
-begin
+    got = nil
+    begin
       tty     = IO.open(IO.sysopen('/dev/tty'), 'r')
       input   = ''
       cursor  = 0
@@ -557,16 +573,14 @@ begin
         ctrl(:c) => proc { exit 1 },
         ctrl(:d) => proc { exit 1 if input.empty? },
         ctrl(:m) => proc {
-      @mtx.synchronize do
+          got = [*@matches.fetch(@vcursor.get, [])][0]
-        got = [*@matches.fetch(@vcursor, [])][0]
-      end
           exit 0
         },
         ctrl(:u) => proc { input = input[cursor..-1]; cursor = 0 },
         ctrl(:a) => proc { cursor = 0 },
         ctrl(:e) => proc { cursor = input.length },
-    ctrl(:j) => proc { emit(:vcursor) { @vcursor -= 1 } },
+        ctrl(:j) => proc { emit(:vcursor) { @vcursor.set { |v| v - 1 } } },
-    ctrl(:k) => proc { emit(:vcursor) { @vcursor += 1 } },
+        ctrl(:k) => proc { emit(:vcursor) { @vcursor.set { |v| v + 1 } } },
         ctrl(:w) => proc {
           ridx   = (input[0...cursor - 1].rindex(/\S\s/) || -2) + 2
           input  = input[0...ridx] + input[cursor..-1]
@@ -575,13 +589,13 @@ begin
         127 => proc { input[cursor -= 1] = '' if cursor > 0 },
         9   => proc { |o|
           emit(:select) {
-        if sel = [*@matches.fetch(@vcursor, [])][0]
+            if sel = [*@matches.fetch(@vcursor.get, [])][0]
               if @selects.has_key? sel
                 @selects.delete sel
               else
                 @selects[sel] = 1
               end
-          @vcursor = [0, @vcursor + (o == :stab ? 1 : -1)].max
+              @vcursor.set { |v| [0, v + (o == :stab ? 1 : -1)].max }
             end
           } if @multi
         },
@@ -596,9 +610,9 @@ begin
       actions[:stab]    = actions[9]
 
       while true
+        @cursor_x.set cursor
         # Update user input
         @smtx.synchronize do
-      @cursor_x = cursor
           print_input
           refresh
         end
@@ -627,16 +641,62 @@ begin
         }).call(ord)
 
         # Dispatch key event
-    emit(:key) { @query = input.dup }
+        emit(:key) { [@query.set(input.dup), cursor] }
       end
-ensure
+    ensure
       C.close_screen
       if got
         @selects.delete got
         @selects.each do |sel, _|
-      stdout.puts sel
+          @stdout.puts sel
+        end
+        @stdout.puts got
+      end
+      exit 0
     end
-    stdout.puts got
   end
-end
+
+  class FuzzyMatcher < Matcher
+    attr_reader :cache
+
+    def initialize rxflag
+      @cache  = Hash.new { |h, k| h[k] = {} }
+      @regexp = {}
+      @rxflag = rxflag
+    end
+
+    def match list, q, prefix, suffix
+      regexp = @regexp[q] ||= begin
+        q = q.downcase if @rxflag != 0
+        Regexp.new(convert_query(q).inject('') { |sum, e|
+          e = Regexp.escape e
+          sum << "#{e}[^#{e}]*?"
+        }, @rxflag)
+      end
+
+      cache = @cache[list.object_id]
+
+      prefix_cache = nil
+      (prefix.length - 1).downto(1) do |len|
+        break if prefix_cache = cache[prefix[0, len]]
+      end
+
+      suffix_cache = nil
+      0.upto(suffix.length - 1) do |idx|
+        break if suffix_cache = cache[suffix[idx..-1]]
+      end unless suffix.empty?
+
+      partial_cache = [prefix_cache,
+                       suffix_cache].compact.sort_by { |e| e.length }.first
+      cache[q] ||= (partial_cache ?
+                    partial_cache.map { |e| e.first } : list).map { |line|
+        # Ignore errors: e.g. invalid byte sequence in UTF-8
+        md = line.match(regexp) rescue nil
+        md && [line, [md.offset(0)]]
+      }.compact
+    end
+  end
+end#FZF
+
+FZF.new(ARGV, $stdin).start if $0 == __FILE__
 

fzf.gemspec

@@ -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}

test/test_fzf.rb

@@ -0,0 +1,152 @@
+#!/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 ['가나',  6], fzf.trim('가나다라마바사.', 4, false)
+    assert_equal ['가나',  6], fzf.trim('가나다라마바사.', 5, false)
+    assert_equal ['가나a', 6], fzf.trim('가나ab라마바사.', 5, 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.cache.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.cache.empty?
+    assert_equal [list.object_id], matcher.cache.keys
+    assert_equal 1, matcher.cache[list.object_id].length
+    assert_equal 6, matcher.cache[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.cache[list.object_id].length
+    assert_equal 2, matcher.cache[list.object_id]['ii'].length
+
+    # TODO : partial_cache
+  end
+
+  def test_sort_by_rank
+    matcher = FZF::FuzzyMatcher.new Regexp::IGNORECASE
+    list = %w[
+      0____1
+      0_____1
+      01
+      ____0_1
+      01_
+      _01_
+      0______1
+      ___01___
+    ]
+    assert_equal %w[01 01_ _01_ ___01___ ____0_1 0____1 0_____1 0______1],
+        FZF.new([]).sort_by_rank(matcher.match(list, '01', '', '')).map(&:first)
+  end
+end