ohmyzsh/vim_plugins/yaifa.vim

" YAIFA: Yet Another Indent Finder, Almost...
" Version: 1.3
" Modified: 2010-08-17
" Author: Israel Chauca F. <israelchauca@gmail.com>
"
" This plug-in will try to detect the kind of indentation in your file and set
" Vim's options to keep it that way. It recognizes three types of indentation:
"
" 1.- Space: Only spaces are used to indent.
"
" 2.- Tab: Only tabs are used.
"
" 3.- Mixed: A combination of tabs and space is used. e.g.: a tab stands for 8
"     spaces, but each indentation level is 4 spaces.
"
" Use :YAIFAMagic to manually set the indenting settings for the current file.
"
" Depending on the system set-up and the file size scanning too many lines can
" be painfully slow, so YAIFA processes 2048 lines by default, that value can
" be changed with the following line in your .vimrc:
"
"    let yaifa_max_lines = 4096
"
" This script is a port to VimL from Philippe Fremy's Python script Indent
" Finder, hence the "Almost" part of the name.

if exists('g:loaded_yaifa')
        finish
endif

let g:loaded_yaifa = 1

" Depending on your system and file size, scanning too many lines can be
" painfully slow.
if exists('g:yaifa_max_lines')
        let s:max_lines = g:yaifa_max_lines
else
        let s:max_lines = 1024*2
endif

redir => redir | silent verbose set sw? | redir END
let s:swset = len(split(redir,"\n")) > 1

if &expandtab
        let s:default_indent = 'space'
        let s:default_tab_width = s:swset ? &sw : 2
else
        let s:default_indent = 'tab'
        let s:default_tab_width = s:swset ? &sw : 4
endif


let s:verbose_quiet = 0
let s:verbose_info  = 1
let s:verbose_debug = 2
let s:verbose_deep  = 3
if exists('g:yaifa_verbosity')
        let s:verbosity = g:yaifa_verbosity
else
        let s:default_verbosity = s:verbose_quiet
        let s:verbosity = s:default_verbosity
endif

let s:default_result = [s:default_indent, s:default_tab_width]
let s:nb_processed_lines = 0

let s:NoIndent = "NoIndent"
let s:SpaceOnly = "SpaceOnly"
let s:TabOnly = "TabOnly"
let s:Mixed = "Mixed"
let s:BeginSpace = "BeginSpace"
let s:indent_re = '\m^\(\s\+\)\(\S.\+\)$'
let s:mixed_re = '\m^\(\t\)\+\( \+\)$'

function! s:log(level, s)
        if a:level <= s:verbosity
                echomsg s:nb_processed_lines . ':' . a:s
        endif
endfunction

function! s:info(s)
        call s:log(s:verbose_info, 'info:' . a:s)
endfunction

function! s:dbg(s)
        call s:log(s:verbose_debug, 'dbg:' . a:s)
endfunction

function! s:deepdbg(s)
        call s:log(s:verbose_deep, 'deep:' . a:s)
endfunction

function! s:clear()
        let s:lines = {}
        for i in range(2,9)
                let s:lines[i] = 0
                let s:lines[-1 * i ] = 0
        endfor
        let s:lines.tab = 0

        let s:nb_processed_lines = 0
        let s:nb_indent_hint = 0
        let s:skip_next_line = 0
        let s:previous_line_info = []
endfunction

function! s:parse_file()
        "let nb_lines = line('$') < s:max_lines ? line('$') : s:max_lines
        let nb_lines = line('$')
        let i = 1
        "while i <= nb_lines
        while i <= nb_lines && s:nb_processed_lines < s:max_lines
                call s:analyse_line(getline(i))
                let i += 1
        endw
endf

function! s:analyse_line(line)
        let line = substitute(a:line, '\m\n', '', '')
        call s:deepdbg('analyse_line: ' . substitute(substitute(line, '\m\t', '\\t', 'g'), '\m ', '·','g'))
        let s:nb_processed_lines += 1
        let skip_current_line = s:skip_next_line
        let s:skip_next_line = 0
        if line =~ '\m\\$'
                call s:deepdbg('analyse_line: Ignoring next line!')
                let s:skip_next_line = 1
        endif

        if skip_current_line
                call s:deepdbg('analyse_line: Ignoring next line!')
                return
        endif
        let ret = s:analyse_line_indentation(line)
        if ret
                let s:nb_indent_hint += 1
                call s:deepdbg('analyse_line: Result of line analysis: ' . ret)
        endif
        return ret
endfunction

function! s:analyse_line_type(line)
        let mixed_mode = 0
        let tab_part = ""
        let space_part = ""

        if a:line !~ '\m^$' && a:line !~ '\m^\s'
                cal s:deepdbg('analyse_line_type: line is not empty and not indented: ')
                return [s:NoIndent, '']
        endif

        if a:line !~ s:indent_re
                cal s:deepdbg('analyse_line_type: line is not indented')
                return []
        else
                let indent_part = substitute(a:line, s:indent_re, '\1', '')
                let text_part = substitute(a:line, s:indent_re, '\2', '')
        endif
        call s:deepdbg('analyse_line_type: indent_part="' . substitute(substitute(substitute(indent_part, '\m\n', '\\n', 'g'), '\m\t', '\\t', 'g'), ' ', '·', 'g') . '"')

        if text_part =~ '\m^\*'
                " continuation of a C/C++ comment, unlikely to be indented correctly
                return []
        endif

        if a:line =~ '\m^(/\*\|#)'
                " python, C/C++ comment, might not be indented correctly
                return []
        endif

        if indent_part =~ '\m\t' && indent_part =~ '\m '
                "Mixed mode
                "let mo = indent_part =~ s:mixed_re
                if indent_part !~ s:mixed_re
                        " Line is not composed of "\t\t\t   "
                        return []
                endif
                let mixed_mode = 1
                let tab_part = substitute(indent_part, s:mixed_re, '\1','')
                let space_part = substitute(indent_part, s:mixed_re, '\2','')
        endif

        if mixed_mode
                if len(space_part) >= 8
                        "this is not mixed mode, this is garbage !
                        return []
                endif
                return [s:Mixed, tab_part, space_part]
        endif"

        if indent_part =~ '\m\t'
                return [s:TabOnly, indent_part]
        endif

        if indent_part =~ '\m '
                if len(indent_part) < 8
                        " this could be mixed mode too
                        return [s:BeginSpace, indent_part]
                else
                        " this is really a line indented with spaces
                        return [s:SpaceOnly, indent_part]
                endif
        endif
        echoerr 'We should never get here!'
endfunction

function! s:analyse_line_indentation(line)
        let previous_line_info = s:previous_line_info
        let current_line_info = s:analyse_line_type(a:line)
        let s:previous_line_info = current_line_info

        if len(current_line_info) == 0 || len(previous_line_info) == 0
                "call s:deepdbg('analyse_line_indentation: Not enough info to analyse line : ' . string(previous_line_info) . ':' . string(current_line_info))
                return 0
        endif

        let t = [previous_line_info[0], current_line_info[0]]
        call s:deepdbg('analyse_line_indentation: Indent analysis: ' . string(t))

        if t == [s:TabOnly, s:TabOnly]
                                \ || t == [s:NoIndent, s:TabOnly]
                if len(current_line_info[1]) - len(previous_line_info[1]) == 1
                        let s:lines['tab'] += 1
                        return 'tab'
                endif
        elseif t == [s:SpaceOnly, s:SpaceOnly]
                                \ || t == [s:BeginSpace, s:SpaceOnly]
                                \ || t == [s:NoIndent, s:SpaceOnly]
                let nb_space = len(current_line_info[1]) - len(previous_line_info[1])
                if 1 < nb_space && nb_space <= 8
                        "execute 'let key = "space' . nb_space . '"'
                        let key = nb_space
                        let s:lines[key] += 1
                        return key
                endif
        elseif t == [s:BeginSpace, s:BeginSpace]
                                \ || t == [s:NoIndent, s:BeginSpace]
                let nb_space = len(current_line_info[1]) - len(previous_line_info[1])
                if 1 < nb_space && nb_space <= 8
                        "execute 'let key1 = "space' . nb_space . '"'
                        "execute 'let key2 = "mixed' . nb_space . '"'
                        let key1 = nb_space
                        let key2 = -1 * nb_space
                        let s:lines[key1] += 1
                        let s:lines[key2] += 1
                        return key1
                endif
        elseif t == [s:BeginSpace, s:TabOnly]
                " We assume that mixed indentation used 8 chars tabs
                if len(current_line_info[1]) == 1
                        let nb_space = len(current_line_info[1]) - len(previous_line_info[1])
                        if 1 < nb_space && nb_space <= 8
                                "execute 'let key = "mixed' . nb_space . '"'
                                let key = -1 * nb_space
                                let s:lines[key] += 1
                                return key
                        endif
                endif
        elseif t == [s:TabOnly, s:Mixed]
                let tab_part = current_line_info[1]
                let space_part = current_line_info[2]
                if len(previous_line_info[1]) == len(tab_part)
                        let nb_space = len(space_part)
                        if 1 < nb_space && nb_space <= 8
                                "execute 'let key = "mixed' . nb_space . '"'
                                let key = -1 * nb_space
                                let s:lines[key] += 1
                                return key
                        endif
                endif
        elseif t == [s:Mixed, s:TabOnly]
                let tab_part = previous_line_info[1]
                let space_part = previous_line_info[2]
                if len(tab_part) + 1 == len(current_line_info[1])
                        let nb_space = 8 - len(space_part)
                        if 1 < nb_space && nb_space <= 8
                                "execute 'let key = "mixed' . nb_space . '"'
                                let key = -1 * nb_space
                                let s:lines[key] += 1
                                return key
                        endif
                endif
        endif
        return 0
endfunction

function! s:results()
        call s:dbg( "Nb of scanned lines : " . s:nb_processed_lines)
        call s:dbg( "Nb of indent hint : " . s:nb_indent_hint)
        "call s:dbg( "Collected data:")
        for key in keys(s:lines)
                if s:lines[key] > 0
                        call s:dbg( '    Key ' . key . ' => ' . s:lines[key])
                endif
        endfor
        let spaces = []
        let mixed = []
        for i in range(2,9)
                "execute 'let spaces = add(spaces, s:lines.space' . i . ')'
                let spaces = add(spaces, s:lines[i])
                "execute 'let mixed = add(mixed, s:lines.mixed' . i . ')'
                let mixed = add(mixed, s:lines[-1 * i])
        endfor
        let max_line_space = max(spaces)
        let max_line_mixed = max(mixed)
        let max_line_tab = s:lines.tab

        call s:dbg( 'max_line_space: ' . max_line_space )
        call s:dbg( 'max_line_mixed: ' . max_line_mixed )
        call s:dbg( 'max_line_tab: ' . max_line_tab )


        """ Result analysis
        "
        " 1. Space indented file
        "    - lines indented with less than 8 space will fill mixed and space array
        "    - lines indented with 8 space or more will fill only the space array
        "    - almost no lines indented with tab
        "
        " => more lines with space than lines with mixed
        " => more a lot more lines with space than tab
        "
        " 2. Tab indented file
        "    - most lines will be tab only
        "    - very few lines as mixed
        "    - very few lines as space only
        "
        " => a lot more lines with tab than lines with mixed
        " => a lot more lines with tab than lines with space
        "
        " 3. Mixed tab/space indented file
        "    - some lines are tab-only (lines with exactly 8 step indentation)
        "    - some lines are space only (less than 8 space)
        "    - all other lines are mixed
        "
        " If mixed is tab + 2 space indentation:
        "     - a lot more lines with mixed than with tab
        " If mixed is tab + 4 space indentation
        "     - as many lines with mixed than with tab
        "
        " If no lines exceed 8 space, there will be only lines with space
        " and tab but no lines with mixed. Impossible to detect mixed indentation
        " in this case, the file looks like it's actually indented as space only
        " and will be detected so.
        "
        " => same or more lines with mixed than lines with tab only
        " => same or more lines with mixed than lines with space only
        "

        let result = []
        " Detect space indented file
        if max_line_space >= max_line_mixed && max_line_space > max_line_tab
                let nb = 0
                let indent_value = 0
                for i in range(8,2,-1)
                        "execute 'let m = s:lines.space' . i . ' > floor(nb * 1.1)'
                        "if s:lines[i] > floor(nb * 1.1)
                        if s:lines[i] * 10 > nb * 11
                                let indent_value = i
                                "execute 'let nb = s:lines.space' . i
                                let nb = s:lines[i]
                        endif
                endfor

                if indent_value == 0
                        let result = s:default_result
                else
                        let result = ['space', indent_value]
                endif

        " Detect tab files
        elseif max_line_tab > max_line_mixed && max_line_tab > max_line_space
                let result = ['tab', s:default_tab_width]

        " Detect mixed files
        elseif max_line_mixed >= max_line_tab && max_line_mixed > max_line_space
                let nb = 0
                let indent_value = 0
                for i in range(-8,-2)
                        "execute 'let m = s:lines.mixed' . i . ' > floor(nb * 1.1)'
                        "let m = s:lines[i] > floor(nb * 1.1)
                        "if s:lines[i] > floor(nb * 1.1)
                        if s:lines[i] * 10 > nb * 11
                                let indent_value = -1 * i
                                "execute 'let nb = s:lines.mixed' . i
                                let nb = s:lines[i]
                        endif
                endfor

                if indent_value == 0
                        let result = s:default_result
                else
                        let result = ['mixed', [8, indent_value]]
                endif

        " Not enough information to make a decision
        else
                let result = s:default_result
        endif
        call s:info('Result: ' . string(result))
        return result
endfunction

function! YAIFA(...)

        " The magic starts here
        call s:clear()
        call s:parse_file()

        let result = s:results()

        if result[0] == 'space'
                call s:info('space')
                "spaces:
                " => set sts to the number of spaces
                " => set tabstop to 8
                " => expand tabs to spaces
                " => set shiftwidth to the number of spaces
                let cmd = 'set sts=' . result[1] . ' | set tabstop=8 | set expandtab | set shiftwidth=' . result[1]
        elseif result[0] == 'tab'
                call s:info('tab')
                "tab:
                " => set sts to 0
                " => set tabstop to preferred value
                " => set expandtab to false
                " => set shiftwidth to tabstop
                let cmd = 'set sts=0 | set tabstop=' . s:default_tab_width . ' | set noexpandtab | set shiftwidth=' . s:default_tab_width
        elseif result[0] == 'mixed'
                call s:info('mixed')
                "tab:
                " => set sts to 0
                " => set tabstop to tab_indent
                " => set expandtab to false
                " => set shiftwidth to space_indent
                let s:ts = result[1][0]
                let s:sw = result[1][1]
                "echom "s:sw: " . s:sw
                "if s:sw == "" && (s:ts - (2*(s:ts/2))) == 0 " l mod 2
                if s:sw == "" && s:ts > 2
                        let s:sw = s:ts/2
                elseif s:sw == ""
                        let s:sw = s:ts
                endif

                let cmd = 'set sts=' . s:sw . ' | set tabstop=' . s:ts . ' | set noexpandtab | set shiftwidth=' . s:sw
        endif
        execute cmd
        let b:yaifa_set = 1
        if a:0 > 0
                if a:1 == 2
                        if result[0] == "space"
                                return "space" . result[1]
                        elseif result[0] == "tab"
                                return "tab"
                        else
                                return "mixed" . s:sw
                        endif
                endif
        else
                echom cmd
        endif
endfunction

function! YAIFAGetVar(var)
        exec "return s:".a:var
endfunction

augroup YAIFA
        au! YAIFA
        au BufRead * call YAIFA(1)
augroup End

command -nargs=0 -bar YAIFAMagic call YAIFA()