Repository: haya14busa/incsearch-fuzzy.vim
Branch: master
Commit: b08fa8fbfd63
Files: 10
Total size: 21.4 KB

Directory structure:
gitextract_gqyze73z/

├── README.md
├── autoload/
│   ├── incsearch/
│   │   └── config/
│   │       ├── fuzzy.vim
│   │       ├── fuzzyspell.vim
│   │       └── fuzzyword.vim
│   ├── vital/
│   │   ├── _incsearch_fuzzy/
│   │   │   └── Data/
│   │   │       └── String/
│   │   │           └── Converter.vim
│   │   ├── _incsearch_fuzzy.vim
│   │   ├── incsearch_fuzzy.vim
│   │   └── incsearch_fuzzy.vital
│   └── vital.vim
└── plugin/
    └── incsearch/
        └── fuzzy.vim

================================================
FILE CONTENTS
================================================

================================================
FILE: README.md
================================================
incsearch-fuzzy.vim
===================

incremantal fuzzy search extension for [incsearch.vim](https://github.com/haya14busa/incsearch.vim)

![incsearch-fuzzy.gif](https://raw.githubusercontent.com/haya14busa/i/master/incsearch.vim/extensions/incsearch-fuzzy.gif)

### Dependencies
- https://github.com/haya14busa/incsearch.vim

### Installtaion

[Neobundle](https://github.com/Shougo/neobundle.vim) / [Vundle](https://github.com/gmarik/Vundle.vim) / [vim-plug](https://github.com/junegunn/vim-plug)

```vim
NeoBundle 'haya14busa/incsearch.vim'
Plugin 'haya14busa/incsearch.vim'
Plug 'haya14busa/incsearch.vim'

NeoBundle 'haya14busa/incsearch-fuzzy.vim'
Plugin 'haya14busa/incsearch-fuzzy.vim'
Plug 'haya14busa/incsearch-fuzzy.vim'
```

[pathogen](https://github.com/tpope/vim-pathogen)

```
git clone https://github.com/haya14busa/incsearch.vim ~/.vim/bundle/incsearch.vim
git clone https://github.com/haya14busa/incsearch-fuzzy.vim ~/.vim/bundle/incsearch-fuzzy.vim
```

### Usage

#### fuzzy search

**Give it a shot!** :gun: `:call incsearch#call(incsearch#config#fuzzy#make()) `

```vim
map z/ <Plug>(incsearch-fuzzy-/)
map z? <Plug>(incsearch-fuzzy-?)
map zg/ <Plug>(incsearch-fuzzy-stay)
```

#### fuzzyspell search

It use `spell` feature in Vim

![incsearch-fuzzyspell.gif](https://raw.githubusercontent.com/haya14busa/i/master/incsearch.vim/extensions/incsearch-fuzzyspell.gif)

```vim
map z/ <Plug>(incsearch-fuzzyspell-/)
map z? <Plug>(incsearch-fuzzyspell-?)
map zg/ <Plug>(incsearch-fuzzyspell-stay)
```

### API

#### fuzzy
- `incsearch#config#fuzzy#converter()`: return fuzzy converter function
- `incsearch#config#fuzzy#make()`: return default config for fuzzy command

#### fuzzyspell
- `incsearch#config#fuzzyspell#converter()`: return fuzzyspell converter function
- `incsearch#config#fuzzyspell#make`: return default config for fuzzyspell command

#### Example: Use both fuzzy & fuzzyspell feature

```vim
function! s:config_fuzzyall(...) abort
  return extend(copy({
  \   'converters': [
  \     incsearch#config#fuzzy#converter(),
  \     incsearch#config#fuzzyspell#converter()
  \   ],
  \ }), get(a:, 1, {}))
endfunction

noremap <silent><expr> z/ incsearch#go(<SID>config_fuzzyall())
noremap <silent><expr> z? incsearch#go(<SID>config_fuzzyall({'command': '?'}))
noremap <silent><expr> zg? incsearch#go(<SID>config_fuzzyall({'is_stay': 1}))
```


================================================
FILE: autoload/incsearch/config/fuzzy.vim
================================================
"=============================================================================
" FILE: autoload/incsearch/config/fuzzy.vim
" AUTHOR: haya14busa
" License: MIT license
"=============================================================================
scriptencoding utf-8
let s:save_cpo = &cpo
set cpo&vim

let s:C = vital#incsearch_fuzzy#import('Data.String.Converter')

function! incsearch#config#fuzzy#converter() abort
  return s:C.fuzzy
endfunction

function! incsearch#config#fuzzy#make(...) abort
  return incsearch#util#deepextend(deepcopy({
  \   'converters': [incsearch#config#fuzzy#converter()]
  \ }), get(a:, 1, {}))
endfunction

let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: expandtab softtabstop=2 shiftwidth=2 foldmethod=marker


================================================
FILE: autoload/incsearch/config/fuzzyspell.vim
================================================
"=============================================================================
" FILE: autoload/incsearch/config/fuzzyspell.vim
" AUTHOR: haya14busa
" License: MIT license
"=============================================================================
scriptencoding utf-8
let s:save_cpo = &cpo
set cpo&vim

let s:C = vital#incsearch_fuzzy#import('Data.String.Converter')

function! incsearch#config#fuzzyspell#converter() abort
  return s:C.fuzzyspell
endfunction

function! incsearch#config#fuzzyspell#make(...) abort
  return incsearch#util#deepextend(deepcopy({
  \   'converters': [incsearch#config#fuzzyspell#converter()]
  \ }), get(a:, 1, {}))
endfunction

let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: expandtab softtabstop=2 shiftwidth=2 foldmethod=marker


================================================
FILE: autoload/incsearch/config/fuzzyword.vim
================================================
"=============================================================================
" FILE: autoload/incsearch/config/fuzzy.vim
" AUTHOR: haya14busa
" License: MIT license
"=============================================================================
scriptencoding utf-8
let s:save_cpo = &cpo
set cpo&vim

let s:C = vital#incsearch_fuzzy#import('Data.String.Converter')

function! incsearch#config#fuzzyword#converter() abort
  return s:C.fuzzyword
endfunction

function! incsearch#config#fuzzyword#make(...) abort
  return incsearch#util#deepextend(deepcopy({
  \   'converters': [incsearch#config#fuzzyword#converter()]
  \ }), get(a:, 1, {}))
endfunction

let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: expandtab softtabstop=2 shiftwidth=2 foldmethod=marker



================================================
FILE: autoload/vital/_incsearch_fuzzy/Data/String/Converter.vim
================================================
" ___vital___
" NOTE: lines between '" ___vital___' is generated by :Vitalize.
" Do not mofidify the code nor insert new lines before '" ___vital___'
if v:version > 703 || v:version == 703 && has('patch1170')
  function! vital#_incsearch_fuzzy#Data#String#Converter#import() abort
    return map({'smartsign_char': '', 'fuzzyspell': '', 'fuzzyword': '', 'get_smartsign_table': '', 'fuzzy': '', 'smartsign': ''},  'function("s:" . v:key)')
  endfunction
else
  function! s:_SID() abort
    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
  endfunction
  execute join(['function! vital#_incsearch_fuzzy#Data#String#Converter#import() abort', printf("return map({'smartsign_char': '', 'fuzzyspell': '', 'fuzzyword': '', 'get_smartsign_table': '', 'fuzzy': '', 'smartsign': ''}, \"function('<SNR>%s_' . v:key)\")", s:_SID()), 'endfunction'], "\n")
  delfunction s:_SID
endif
" ___vital___
"=============================================================================
" FILE: autoload/vital/__latest__/Data/String/Converter.vim
" AUTHOR: haya14busa
" License: MIT license
"=============================================================================
scriptencoding utf-8
let s:save_cpo = &cpo
set cpo&vim

let s:TRUE = !0
let s:FALSE = 0
let s:escaped_backslash = '\m\%(^\|[^\\]\)\%(\\\\\)*'
let s:non_escaped_backslash = '\m\%(\%(^\|[^\\]\)\%(\\\\\)*\)\@1<=\\'

function! s:_throw(message) abort
  throw printf('vital: Data.String.Converter: %s', a:message)
endfunction

" fuzzy --
function! s:fuzzy(pattern) abort
  if a:pattern is# '' | return '' | endif
  let pattern = substitute(a:pattern, s:non_escaped_backslash . '[mMvV]', '', 'g')
  let pattern = substitute(pattern, s:escaped_backslash . '\([mMvV]\)', '\1', 'g')
  let chars = map(split(pattern, '\zs'), "escape(v:val, '\\')")
  let p =  '\c\V' .
  \   join(map(chars[0:-2], "
  \       printf('%s\\[^%s]\\{-}', v:val, v:val)
  \   "), '') . chars[-1]
  return p
endfunction

let s:nonwords = join([
\   '[:space:]',
\ ], '')

" fuzzy word --
function! s:fuzzyword(pattern) abort
  if a:pattern is# '' | return '' | endif
  let pattern = substitute(a:pattern, s:non_escaped_backslash . '[mMvV]', '', 'g')
  let pattern = substitute(pattern, s:escaped_backslash . '\([mMvV]\)', '\1', 'g')
  let chars = map(split(pattern, '\zs'), "escape(v:val, '\\')")
  let p =  '\c\V\<\=' .
  \   join(map(chars[0:-2], "
  \       printf('%s\\[^%s%s]\\{-}', v:val, s:nonwords, v:val)
  \   "), '') . chars[-1]
  return p
endfunction

" smartsign --
let s:sign_table = {}
let s:sign_table.us = {
\  ',' : '<', '.' : '>', '/' : '?',
\  '1' : '!', '2' : '@', '3' : '#', '4' : '$', '5' : '%',
\  '6' : '^', '7' : '&', '8' : '*', '9' : '(', '0' : ')', '-' : '_', '=' : '+',
\  ';' : ':', '[' : '{', ']' : '}', '`' : '~', "'" : "\"", '\' : '|',
\  }

let s:sign_table.ja = {
\  ',' : '<', '.' : '>', '/' : '?',
\  '1' : '!', '2' : '"', '3' : '#', '4' : '$', '5' : '%',
\  '6' : '&', '7' : "'", '8' : '(', '9' : ')', '0' : '_', '-' : '=', '^' : '~',
\  ';' : '+', ':' : '*', '[' : '{', ']' : '}', '@' : '`', '\' : '|',
\  }

" characters which should be escaped in rectangle ([]) of regular expressions
let s:escape_in_rec = '\]^-/?'

function! s:get_smartsign_table(...) abort
  let table = get(a:, 1, s:sign_table.us)
  if type(table) is# type('')
    if !has_key(s:sign_table, table)
      call s:_throw(printf('table named %s does not exist', table))
    else
      let tmp = s:sign_table[table]
      unlet table
      let table = tmp
    endif
  endif
  return table
endfunction

" assume '\V'
function! s:smartsign_char(sign, ...) abort
  let table = call(function('s:get_smartsign_table'), a:000)
  return has_key(table, a:sign) ?
  \     printf('\[%s%s]',
  \         escape(a:sign, s:escape_in_rec),
  \         escape(table[a:sign], s:escape_in_rec))
  \   : a:sign
endfunction

function! s:smartsign(pattern, ...) abort
  let table = call(function('s:get_smartsign_table'), a:000)
  let signs = '\m[' . escape(join(keys(table), ''), s:escape_in_rec) . ']'
  return '\V' . substitute(a:pattern, signs, '\=
  \                        s:smartsign_char(submatch(0), table)', 'g')
endfunction

" fuzzyspell --
function! s:fuzzyspell(pattern) abort
  let spell_save = &spell
  let &spell = s:TRUE
  try
    return substitute(a:pattern, '\k\+', '\=s:_make_fuzzy_spell(submatch(0))', 'g')
  finally
    let &spell = spell_save
  endtry
endfunction

function! s:_spellsuggest(word, ...) abort
  let max = get(a:, 1, 25)
  return [a:word] + spellsuggest(a:word, max)
endfunction

function! s:_make_fuzzy_spell(word) abort
  return printf('\m\(%s\)', join(s:_spellsuggest(a:word), '\|'))
endfunction


let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: expandtab softtabstop=2 shiftwidth=2 foldmethod=marker


================================================
FILE: autoload/vital/_incsearch_fuzzy.vim
================================================
let s:_plugin_name = expand('<sfile>:t:r')

function! vital#{s:_plugin_name}#new() abort
  return vital#{s:_plugin_name[1:]}#new()
endfunction


================================================
FILE: autoload/vital/incsearch_fuzzy.vim
================================================
let s:plugin_name = expand('<sfile>:t:r')
let s:vital_base_dir = expand('<sfile>:h')
let s:project_root = expand('<sfile>:h:h:h')
let s:is_vital_vim = s:plugin_name is# 'vital'

let s:loaded = {}
let s:cache_sid = {}

" function() wrapper
if v:version > 703 || v:version == 703 && has('patch1170')
  function! s:_function(fstr) abort
    return function(a:fstr)
  endfunction
else
  function! s:_SID() abort
    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze__SID$')
  endfunction
  let s:_s = '<SNR>' . s:_SID() . '_'
  function! s:_function(fstr) abort
    return function(substitute(a:fstr, 's:', s:_s, 'g'))
  endfunction
endif

function! vital#{s:plugin_name}#new() abort
  return s:new(s:plugin_name)
endfunction

function! vital#{s:plugin_name}#import(...) abort
  if !exists('s:V')
    let s:V = s:new(s:plugin_name)
  endif
  return call(s:V.import, a:000, s:V)
endfunction

let s:Vital = {}

function! s:new(plugin_name) abort
  let base = deepcopy(s:Vital)
  let base._plugin_name = a:plugin_name
  return base
endfunction

function! s:vital_files() abort
  if !exists('s:vital_files')
    let s:vital_files = map(
    \   s:is_vital_vim ? s:_global_vital_files() : s:_self_vital_files(),
    \   'fnamemodify(v:val, ":p:gs?[\\\\/]?/?")')
  endif
  return copy(s:vital_files)
endfunction
let s:Vital.vital_files = s:_function('s:vital_files')

function! s:import(name, ...) abort dict
  let target = {}
  let functions = []
  for a in a:000
    if type(a) == type({})
      let target = a
    elseif type(a) == type([])
      let functions = a
    endif
    unlet a
  endfor
  let module = self._import(a:name)
  if empty(functions)
    call extend(target, module, 'keep')
  else
    for f in functions
      if has_key(module, f) && !has_key(target, f)
        let target[f] = module[f]
      endif
    endfor
  endif
  return target
endfunction
let s:Vital.import = s:_function('s:import')

function! s:load(...) abort dict
  for arg in a:000
    let [name; as] = type(arg) == type([]) ? arg[: 1] : [arg, arg]
    let target = split(join(as, ''), '\W\+')
    let dict = self
    let dict_type = type({})
    while !empty(target)
      let ns = remove(target, 0)
      if !has_key(dict, ns)
        let dict[ns] = {}
      endif
      if type(dict[ns]) == dict_type
        let dict = dict[ns]
      else
        unlet dict
        break
      endif
    endwhile
    if exists('dict')
      call extend(dict, self._import(name))
    endif
    unlet arg
  endfor
  return self
endfunction
let s:Vital.load = s:_function('s:load')

function! s:unload() abort dict
  let s:loaded = {}
  let s:cache_sid = {}
  unlet! s:vital_files
endfunction
let s:Vital.unload = s:_function('s:unload')

function! s:exists(name) abort dict
  if a:name !~# '\v^\u\w*%(\.\u\w*)*$'
    throw 'vital: Invalid module name: ' . a:name
  endif
  return s:_module_path(a:name) isnot# ''
endfunction
let s:Vital.exists = s:_function('s:exists')

function! s:search(pattern) abort dict
  let paths = s:_extract_files(a:pattern, self.vital_files())
  let modules = sort(map(paths, 's:_file2module(v:val)'))
  return s:_uniq(modules)
endfunction
let s:Vital.search = s:_function('s:search')

function! s:plugin_name() abort dict
  return self._plugin_name
endfunction
let s:Vital.plugin_name = s:_function('s:plugin_name')

function! s:_self_vital_files() abort
  let builtin = printf('%s/__%s__/', s:vital_base_dir, s:plugin_name)
  let installed = printf('%s/_%s/', s:vital_base_dir, s:plugin_name)
  let base = builtin . ',' . installed
  return split(globpath(base, '**/*.vim', 1), "\n")
endfunction

function! s:_global_vital_files() abort
  let pattern = 'autoload/vital/__*__/**/*.vim'
  return split(globpath(&runtimepath, pattern, 1), "\n")
endfunction

function! s:_extract_files(pattern, files) abort
  let tr = {'.': '/', '*': '[^/]*', '**': '.*'}
  let target = substitute(a:pattern, '\.\|\*\*\?', '\=tr[submatch(0)]', 'g')
  let regexp = printf('autoload/vital/[^/]\+/%s.vim$', target)
  return filter(a:files, 'v:val =~# regexp')
endfunction

function! s:_file2module(file) abort
  let filename = fnamemodify(a:file, ':p:gs?[\\/]?/?')
  let tail = matchstr(filename, 'autoload/vital/_\w\+/\zs.*\ze\.vim$')
  return join(split(tail, '[\\/]\+'), '.')
endfunction

" @param {string} name e.g. Data.List
function! s:_import(name) abort dict
  if has_key(s:loaded, a:name)
    return copy(s:loaded[a:name])
  endif
  let module = self._get_module(a:name)
  if has_key(module, '_vital_created')
    call module._vital_created(module)
  endif
  let export_module = filter(copy(module), 'v:key =~# "^\\a"')
  " Cache module before calling module.vital_loaded() to avoid cyclic
  " dependences but remove the cache if module._vital_loaded() fails.
  " let s:loaded[a:name] = export_module
  let s:loaded[a:name] = export_module
  if has_key(module, '_vital_loaded')
    try
      call module._vital_loaded(vital#{s:plugin_name}#new())
    catch
      unlet s:loaded[a:name]
      throw 'vital: fail to call ._vital_loaded(): ' . v:exception
    endtry
  endif
  return copy(s:loaded[a:name])
endfunction
let s:Vital._import = s:_function('s:_import')

" s:_get_module() returns module object wihch has all script local functions.
function! s:_get_module(name) abort dict
  let funcname = s:_import_func_name(self.plugin_name(), a:name)
  if s:_exists_autoload_func_with_source(funcname)
    return call(funcname, [])
  else
    return s:_get_builtin_module(a:name)
  endif
endfunction

function! s:_get_builtin_module(name) abort
 return s:sid2sfuncs(s:_module_sid(a:name))
endfunction

if s:is_vital_vim
  " For vital.vim, we can use s:_get_builtin_module directly
  let s:Vital._get_module = s:_function('s:_get_builtin_module')
else
  let s:Vital._get_module = s:_function('s:_get_module')
endif

function! s:_import_func_name(plugin_name, module_name) abort
  return printf('vital#_%s#%s#import', a:plugin_name, s:_dot_to_sharp(a:module_name))
endfunction

function! s:_module_sid(name) abort
  let path = s:_module_path(a:name)
  if !filereadable(path)
    throw 'vital: module not found: ' . a:name
  endif
  let vital_dir = s:is_vital_vim ? '__\w\+__' : printf('_\{1,2}%s\%%(__\)\?', s:plugin_name)
  let base = join([vital_dir, ''], '[/\\]\+')
  let p = base . substitute('' . a:name, '\.', '[/\\\\]\\+', 'g')
  let sid = s:_sid(path, p)
  if !sid
    call s:_source(path)
    let sid = s:_sid(path, p)
    if !sid
      throw printf('vital: cannot get <SID> from path: %s', path)
    endif
  endif
  return sid
endfunction

function! s:_module_path(name) abort
  return get(s:_extract_files(a:name, s:vital_files()), 0, '')
endfunction

function! s:_module_sid_base_dir() abort
  return s:is_vital_vim ? &rtp : s:project_root
endfunction

function! s:_dot_to_sharp(name) abort
  return substitute(a:name, '\.', '#', 'g')
endfunction

" It will sources autoload file if a given func is not already defined.
function! s:_exists_autoload_func_with_source(funcname) abort
  if exists('*' . a:funcname)
    " Return true if a given func is already defined
    return 1
  endif
  " source a file which may include a given func definition and try again.
  let path = 'autoload/' . substitute(substitute(a:funcname, '#[^#]*$', '.vim', ''), '#', '/', 'g')
  call s:_runtime(path)
  return exists('*' . a:funcname)
endfunction

function! s:_runtime(path) abort
  execute 'runtime' fnameescape(a:path)
endfunction

function! s:_source(path) abort
  execute 'source' fnameescape(a:path)
endfunction

" @vimlint(EVL102, 1, l:_)
" @vimlint(EVL102, 1, l:__)
function! s:_sid(path, filter_pattern) abort
  let unified_path = s:_unify_path(a:path)
  if has_key(s:cache_sid, unified_path)
    return s:cache_sid[unified_path]
  endif
  for line in filter(split(s:_redir(':scriptnames'), "\n"), 'v:val =~# a:filter_pattern')
    let [_, sid, path; __] = matchlist(line, '^\s*\(\d\+\):\s\+\(.\+\)\s*$')
    if s:_unify_path(path) is# unified_path
      let s:cache_sid[unified_path] = sid
      return s:cache_sid[unified_path]
    endif
  endfor
  return 0
endfunction

function! s:_redir(cmd) abort
  let [save_verbose, save_verbosefile] = [&verbose, &verbosefile]
  set verbose=0 verbosefile=
  redir => res
    silent! execute a:cmd
  redir END
  let [&verbose, &verbosefile] = [save_verbose, save_verbosefile]
  return res
endfunction

if filereadable(expand('<sfile>:r') . '.VIM') " is case-insensitive or not
  let s:_unify_path_cache = {}
  " resolve() is slow, so we cache results.
  " Note: On windows, vim can't expand path names from 8.3 formats.
  " So if getting full path via <sfile> and $HOME was set as 8.3 format,
  " vital load duplicated scripts. Below's :~ avoid this issue.
  function! s:_unify_path(path) abort
    if has_key(s:_unify_path_cache, a:path)
      return s:_unify_path_cache[a:path]
    endif
    let value = tolower(fnamemodify(resolve(fnamemodify(
    \                   a:path, ':p')), ':~:gs?[\\/]?/?'))
    let s:_unify_path_cache[a:path] = value
    return value
  endfunction
else
  function! s:_unify_path(path) abort
    return resolve(fnamemodify(a:path, ':p:gs?[\\/]?/?'))
  endfunction
endif

" copied and modified from Vim.ScriptLocal
let s:SNR = join(map(range(len("\<SNR>")), '"[\\x" . printf("%0x", char2nr("\<SNR>"[v:val])) . "]"'), '')
function! s:sid2sfuncs(sid) abort
  let fs = split(s:_redir(printf(':function /^%s%s_', s:SNR, a:sid)), "\n")
  let r = {}
  let pattern = printf('\m^function\s<SNR>%d_\zs\w\{-}\ze(', a:sid)
  for fname in map(fs, 'matchstr(v:val, pattern)')
    let r[fname] = function(s:_sfuncname(a:sid, fname))
  endfor
  return r
endfunction

"" Return funcname of script local functions with SID
function! s:_sfuncname(sid, funcname) abort
  return printf('<SNR>%s_%s', a:sid, a:funcname)
endfunction

if exists('*uniq')
  function! s:_uniq(list) abort
    return uniq(a:list)
  endfunction
else
  function! s:_uniq(list) abort
    let i = len(a:list) - 1
    while 0 < i
      if a:list[i] ==# a:list[i - 1]
        call remove(a:list, i)
      endif
      let i -= 1
    endwhile
    return a:list
  endfunction
endif


================================================
FILE: autoload/vital/incsearch_fuzzy.vital
================================================
incsearch_fuzzy
6e682fce672da9da08aee5db517d227be5ef663f

Data.String.Converter


================================================
FILE: autoload/vital.vim
================================================
function! vital#of(name) abort
  let files = globpath(&runtimepath, 'autoload/vital/' . a:name . '.vital', 1)
  let file = split(files, "\n")
  if empty(file)
    throw 'vital: version file not found: ' . a:name
  endif
  let ver = readfile(file[0], 'b')
  if empty(ver)
    throw 'vital: invalid version file: ' . a:name
  endif
  return vital#_{substitute(ver[0], '\W', '', 'g')}#new()
endfunction


================================================
FILE: plugin/incsearch/fuzzy.vim
================================================
"=============================================================================
" FILE: plugin/incsearch/fuzzy.vim
" AUTHOR: haya14busa
" License: MIT license
"=============================================================================
scriptencoding utf-8
if expand('%:p') ==# expand('<sfile>:p')
  unlet! g:loaded_incsearch_fuzzy
endif
if exists('g:loaded_incsearch_fuzzy')
  finish
endif
let g:loaded_incsearch_fuzzy = 1
let s:save_cpo = &cpo
set cpo&vim

function! s:config_fuzzy(...) abort
  return incsearch#config#fuzzy#make(get(a:, 1, {}))
endfunction

function! s:config_fuzzyword(...) abort
  return incsearch#config#fuzzyword#make(get(a:, 1, {}))
endfunction

function! s:config_fuzzyspell(...) abort
  return incsearch#config#fuzzyspell#make(get(a:, 1, {}))
endfunction

noremap <silent><expr> <Plug>(incsearch-fuzzy-/) incsearch#go(<SID>config_fuzzy())
noremap <silent><expr> <Plug>(incsearch-fuzzy-?) incsearch#go(<SID>config_fuzzy({'command': '?'}))
noremap <silent><expr> <Plug>(incsearch-fuzzy-stay) incsearch#go(<SID>config_fuzzy({'is_stay': 1}))

noremap <silent><expr> <Plug>(incsearch-fuzzyword-/) incsearch#go(<SID>config_fuzzyword())
noremap <silent><expr> <Plug>(incsearch-fuzzyword-?) incsearch#go(<SID>config_fuzzyword({'command': '?'}))
noremap <silent><expr> <Plug>(incsearch-fuzzyword-stay) incsearch#go(<SID>config_fuzzyword({'is_stay': 1}))

noremap <silent><expr> <Plug>(incsearch-fuzzyspell-/) incsearch#go(<SID>config_fuzzyspell())
noremap <silent><expr> <Plug>(incsearch-fuzzyspell-?) incsearch#go(<SID>config_fuzzyspell({'command': '?'}))
noremap <silent><expr> <Plug>(incsearch-fuzzyspell-stay) incsearch#go(<SID>config_fuzzyspell({'is_stay': 1}))

let &cpo = s:save_cpo
unlet s:save_cpo
" __END__
" vim: expandtab softtabstop=2 shiftwidth=2 foldmethod=marker