From 212dcd0bf753f08c0127a26a71b673c734b45c02 Mon Sep 17 00:00:00 2001 From: Yaroslav Date: Thu, 5 Sep 2019 19:35:38 +0300 Subject: init commit, extracted vim config from i3rice --- .vim/autoload/neomake/makers/cabal.vim | 15 + .vim/autoload/neomake/makers/clippy.vim | 39 ++ .vim/autoload/neomake/makers/ft/ada.vim | 14 + .vim/autoload/neomake/makers/ft/angular.vim | 9 + .vim/autoload/neomake/makers/ft/ansible.vim | 17 + .vim/autoload/neomake/makers/ft/apiblueprint.vim | 16 + .vim/autoload/neomake/makers/ft/applescript.vim | 11 + .vim/autoload/neomake/makers/ft/asciidoc.vim | 28 ++ .vim/autoload/neomake/makers/ft/beancount.vim | 12 + .vim/autoload/neomake/makers/ft/bib.vim | 16 + .vim/autoload/neomake/makers/ft/c.vim | 110 ++++++ .vim/autoload/neomake/makers/ft/cf3.vim | 14 + .vim/autoload/neomake/makers/ft/chef.vim | 23 ++ .vim/autoload/neomake/makers/ft/coffee.vim | 15 + .vim/autoload/neomake/makers/ft/cpp.vim | 50 +++ .vim/autoload/neomake/makers/ft/crystal.vim | 25 ++ .vim/autoload/neomake/makers/ft/cs.vim | 22 ++ .vim/autoload/neomake/makers/ft/css.vim | 35 ++ .vim/autoload/neomake/makers/ft/cuda.vim | 15 + .vim/autoload/neomake/makers/ft/d.vim | 92 +++++ .vim/autoload/neomake/makers/ft/docbk.vim | 8 + .vim/autoload/neomake/makers/ft/dockerfile.vim | 13 + .vim/autoload/neomake/makers/ft/elixir.vim | 72 ++++ .vim/autoload/neomake/makers/ft/elm.vim | 53 +++ .vim/autoload/neomake/makers/ft/erlang.vim | 72 ++++ .vim/autoload/neomake/makers/ft/fish.vim | 16 + .vim/autoload/neomake/makers/ft/fortran.vim | 32 ++ .vim/autoload/neomake/makers/ft/go.vim | 84 +++++ .vim/autoload/neomake/makers/ft/haml.vim | 13 + .vim/autoload/neomake/makers/ft/haskell.vim | 169 +++++++++ .vim/autoload/neomake/makers/ft/haxe.vim | 11 + .vim/autoload/neomake/makers/ft/help.vim | 40 ++ .vim/autoload/neomake/makers/ft/html.vim | 20 + .vim/autoload/neomake/makers/ft/idris.vim | 25 ++ .vim/autoload/neomake/makers/ft/jade.vim | 13 + .vim/autoload/neomake/makers/ft/jasmine.vim | 9 + .vim/autoload/neomake/makers/ft/java.vim | 396 +++++++++++++++++++ .../neomake/makers/ft/java/classpath.gradle | 46 +++ .vim/autoload/neomake/makers/ft/java/classpath.py | 15 + .vim/autoload/neomake/makers/ft/javascript.vim | 119 ++++++ .vim/autoload/neomake/makers/ft/json.vim | 38 ++ .vim/autoload/neomake/makers/ft/jsx.vim | 17 + .vim/autoload/neomake/makers/ft/julia.vim | 24 ++ .vim/autoload/neomake/makers/ft/kotlin.vim | 12 + .vim/autoload/neomake/makers/ft/less.vim | 19 + .vim/autoload/neomake/makers/ft/lex.vim | 11 + .vim/autoload/neomake/makers/ft/lua.vim | 33 ++ .vim/autoload/neomake/makers/ft/mail.vim | 8 + .vim/autoload/neomake/makers/ft/markdown.vim | 97 +++++ .vim/autoload/neomake/makers/ft/matlab.vim | 15 + .vim/autoload/neomake/makers/ft/moon.vim | 15 + .vim/autoload/neomake/makers/ft/neomake_tests.vim | 58 +++ .vim/autoload/neomake/makers/ft/nim.vim | 16 + .vim/autoload/neomake/makers/ft/nix.vim | 14 + .vim/autoload/neomake/makers/ft/node.vim | 9 + .vim/autoload/neomake/makers/ft/objc.vim | 55 +++ .vim/autoload/neomake/makers/ft/pandoc.vim | 8 + .vim/autoload/neomake/makers/ft/perl.vim | 34 ++ .vim/autoload/neomake/makers/ft/php.vim | 72 ++++ .vim/autoload/neomake/makers/ft/proto.vim | 12 + .vim/autoload/neomake/makers/ft/pug.vim | 13 + .vim/autoload/neomake/makers/ft/puppet.vim | 29 ++ .vim/autoload/neomake/makers/ft/purescript.vim | 63 ++++ .vim/autoload/neomake/makers/ft/python.vim | 419 +++++++++++++++++++++ .vim/autoload/neomake/makers/ft/python/compile.py | 14 + .vim/autoload/neomake/makers/ft/r.vim | 17 + .vim/autoload/neomake/makers/ft/racket.vim | 32 ++ .vim/autoload/neomake/makers/ft/rst.vim | 89 +++++ .vim/autoload/neomake/makers/ft/ruby.vim | 90 +++++ .vim/autoload/neomake/makers/ft/rust.vim | 233 ++++++++++++ .vim/autoload/neomake/makers/ft/scala.vim | 40 ++ .vim/autoload/neomake/makers/ft/scss.vim | 25 ++ .vim/autoload/neomake/makers/ft/serpent.vim | 13 + .vim/autoload/neomake/makers/ft/sh.vim | 86 +++++ .vim/autoload/neomake/makers/ft/slim.vim | 13 + .vim/autoload/neomake/makers/ft/sml.vim | 19 + .vim/autoload/neomake/makers/ft/solidity.vim | 16 + .vim/autoload/neomake/makers/ft/spar.vim | 13 + .vim/autoload/neomake/makers/ft/spec.vim | 16 + .vim/autoload/neomake/makers/ft/sql.vim | 13 + .vim/autoload/neomake/makers/ft/stylus.vim | 16 + .vim/autoload/neomake/makers/ft/swift.vim | 54 +++ .vim/autoload/neomake/makers/ft/tcl.vim | 15 + .vim/autoload/neomake/makers/ft/tex.vim | 69 ++++ .vim/autoload/neomake/makers/ft/text.vim | 30 ++ .vim/autoload/neomake/makers/ft/toml.vim | 15 + .vim/autoload/neomake/makers/ft/tsx.vim | 15 + .vim/autoload/neomake/makers/ft/typescript.vim | 45 +++ .vim/autoload/neomake/makers/ft/verilog.vim | 16 + .vim/autoload/neomake/makers/ft/vhdl.vim | 12 + .vim/autoload/neomake/makers/ft/vim.vim | 87 +++++ .vim/autoload/neomake/makers/ft/vue.vim | 28 ++ .vim/autoload/neomake/makers/ft/xml.vim | 25 ++ .vim/autoload/neomake/makers/ft/xslt.vim | 8 + .vim/autoload/neomake/makers/ft/yacc.vim | 17 + .vim/autoload/neomake/makers/ft/yaml.vim | 12 + .vim/autoload/neomake/makers/ft/zsh.vim | 19 + .vim/autoload/neomake/makers/gradle.vim | 28 ++ .vim/autoload/neomake/makers/mvn.vim | 9 + .vim/autoload/neomake/makers/sbt.vim | 13 + 100 files changed, 4157 insertions(+) create mode 100644 .vim/autoload/neomake/makers/cabal.vim create mode 100644 .vim/autoload/neomake/makers/clippy.vim create mode 100644 .vim/autoload/neomake/makers/ft/ada.vim create mode 100644 .vim/autoload/neomake/makers/ft/angular.vim create mode 100644 .vim/autoload/neomake/makers/ft/ansible.vim create mode 100644 .vim/autoload/neomake/makers/ft/apiblueprint.vim create mode 100644 .vim/autoload/neomake/makers/ft/applescript.vim create mode 100644 .vim/autoload/neomake/makers/ft/asciidoc.vim create mode 100644 .vim/autoload/neomake/makers/ft/beancount.vim create mode 100644 .vim/autoload/neomake/makers/ft/bib.vim create mode 100644 .vim/autoload/neomake/makers/ft/c.vim create mode 100644 .vim/autoload/neomake/makers/ft/cf3.vim create mode 100644 .vim/autoload/neomake/makers/ft/chef.vim create mode 100644 .vim/autoload/neomake/makers/ft/coffee.vim create mode 100644 .vim/autoload/neomake/makers/ft/cpp.vim create mode 100644 .vim/autoload/neomake/makers/ft/crystal.vim create mode 100644 .vim/autoload/neomake/makers/ft/cs.vim create mode 100644 .vim/autoload/neomake/makers/ft/css.vim create mode 100644 .vim/autoload/neomake/makers/ft/cuda.vim create mode 100644 .vim/autoload/neomake/makers/ft/d.vim create mode 100644 .vim/autoload/neomake/makers/ft/docbk.vim create mode 100644 .vim/autoload/neomake/makers/ft/dockerfile.vim create mode 100644 .vim/autoload/neomake/makers/ft/elixir.vim create mode 100644 .vim/autoload/neomake/makers/ft/elm.vim create mode 100644 .vim/autoload/neomake/makers/ft/erlang.vim create mode 100644 .vim/autoload/neomake/makers/ft/fish.vim create mode 100644 .vim/autoload/neomake/makers/ft/fortran.vim create mode 100644 .vim/autoload/neomake/makers/ft/go.vim create mode 100644 .vim/autoload/neomake/makers/ft/haml.vim create mode 100644 .vim/autoload/neomake/makers/ft/haskell.vim create mode 100644 .vim/autoload/neomake/makers/ft/haxe.vim create mode 100644 .vim/autoload/neomake/makers/ft/help.vim create mode 100644 .vim/autoload/neomake/makers/ft/html.vim create mode 100644 .vim/autoload/neomake/makers/ft/idris.vim create mode 100644 .vim/autoload/neomake/makers/ft/jade.vim create mode 100644 .vim/autoload/neomake/makers/ft/jasmine.vim create mode 100644 .vim/autoload/neomake/makers/ft/java.vim create mode 100644 .vim/autoload/neomake/makers/ft/java/classpath.gradle create mode 100644 .vim/autoload/neomake/makers/ft/java/classpath.py create mode 100644 .vim/autoload/neomake/makers/ft/javascript.vim create mode 100644 .vim/autoload/neomake/makers/ft/json.vim create mode 100644 .vim/autoload/neomake/makers/ft/jsx.vim create mode 100644 .vim/autoload/neomake/makers/ft/julia.vim create mode 100644 .vim/autoload/neomake/makers/ft/kotlin.vim create mode 100644 .vim/autoload/neomake/makers/ft/less.vim create mode 100644 .vim/autoload/neomake/makers/ft/lex.vim create mode 100644 .vim/autoload/neomake/makers/ft/lua.vim create mode 100644 .vim/autoload/neomake/makers/ft/mail.vim create mode 100644 .vim/autoload/neomake/makers/ft/markdown.vim create mode 100644 .vim/autoload/neomake/makers/ft/matlab.vim create mode 100644 .vim/autoload/neomake/makers/ft/moon.vim create mode 100644 .vim/autoload/neomake/makers/ft/neomake_tests.vim create mode 100644 .vim/autoload/neomake/makers/ft/nim.vim create mode 100644 .vim/autoload/neomake/makers/ft/nix.vim create mode 100644 .vim/autoload/neomake/makers/ft/node.vim create mode 100644 .vim/autoload/neomake/makers/ft/objc.vim create mode 100644 .vim/autoload/neomake/makers/ft/pandoc.vim create mode 100644 .vim/autoload/neomake/makers/ft/perl.vim create mode 100644 .vim/autoload/neomake/makers/ft/php.vim create mode 100644 .vim/autoload/neomake/makers/ft/proto.vim create mode 100644 .vim/autoload/neomake/makers/ft/pug.vim create mode 100644 .vim/autoload/neomake/makers/ft/puppet.vim create mode 100644 .vim/autoload/neomake/makers/ft/purescript.vim create mode 100644 .vim/autoload/neomake/makers/ft/python.vim create mode 100755 .vim/autoload/neomake/makers/ft/python/compile.py create mode 100644 .vim/autoload/neomake/makers/ft/r.vim create mode 100644 .vim/autoload/neomake/makers/ft/racket.vim create mode 100644 .vim/autoload/neomake/makers/ft/rst.vim create mode 100644 .vim/autoload/neomake/makers/ft/ruby.vim create mode 100644 .vim/autoload/neomake/makers/ft/rust.vim create mode 100644 .vim/autoload/neomake/makers/ft/scala.vim create mode 100644 .vim/autoload/neomake/makers/ft/scss.vim create mode 100644 .vim/autoload/neomake/makers/ft/serpent.vim create mode 100644 .vim/autoload/neomake/makers/ft/sh.vim create mode 100644 .vim/autoload/neomake/makers/ft/slim.vim create mode 100644 .vim/autoload/neomake/makers/ft/sml.vim create mode 100644 .vim/autoload/neomake/makers/ft/solidity.vim create mode 100644 .vim/autoload/neomake/makers/ft/spar.vim create mode 100644 .vim/autoload/neomake/makers/ft/spec.vim create mode 100644 .vim/autoload/neomake/makers/ft/sql.vim create mode 100644 .vim/autoload/neomake/makers/ft/stylus.vim create mode 100644 .vim/autoload/neomake/makers/ft/swift.vim create mode 100644 .vim/autoload/neomake/makers/ft/tcl.vim create mode 100644 .vim/autoload/neomake/makers/ft/tex.vim create mode 100644 .vim/autoload/neomake/makers/ft/text.vim create mode 100644 .vim/autoload/neomake/makers/ft/toml.vim create mode 100644 .vim/autoload/neomake/makers/ft/tsx.vim create mode 100644 .vim/autoload/neomake/makers/ft/typescript.vim create mode 100644 .vim/autoload/neomake/makers/ft/verilog.vim create mode 100644 .vim/autoload/neomake/makers/ft/vhdl.vim create mode 100644 .vim/autoload/neomake/makers/ft/vim.vim create mode 100644 .vim/autoload/neomake/makers/ft/vue.vim create mode 100644 .vim/autoload/neomake/makers/ft/xml.vim create mode 100644 .vim/autoload/neomake/makers/ft/xslt.vim create mode 100644 .vim/autoload/neomake/makers/ft/yacc.vim create mode 100644 .vim/autoload/neomake/makers/ft/yaml.vim create mode 100644 .vim/autoload/neomake/makers/ft/zsh.vim create mode 100644 .vim/autoload/neomake/makers/gradle.vim create mode 100644 .vim/autoload/neomake/makers/mvn.vim create mode 100644 .vim/autoload/neomake/makers/sbt.vim (limited to '.vim/autoload/neomake/makers') diff --git a/.vim/autoload/neomake/makers/cabal.vim b/.vim/autoload/neomake/makers/cabal.vim new file mode 100644 index 0000000..070b2a5 --- /dev/null +++ b/.vim/autoload/neomake/makers/cabal.vim @@ -0,0 +1,15 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#cabal#cabal() abort + let errorformat = join([ + \ '%A%f:%l:%c:', + \ '%A%f:%l:%c: %m', + \ '%+C %m', + \ '%-Z%[%^ ]', + \ ], ',') + return { + \ 'exe': 'cabal', + \ 'args': ['build'], + \ 'errorformat': errorformat + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/clippy.vim b/.vim/autoload/neomake/makers/clippy.vim new file mode 100644 index 0000000..6f2a8a3 --- /dev/null +++ b/.vim/autoload/neomake/makers/clippy.vim @@ -0,0 +1,39 @@ +" vim: ts=4 sw=4 et + +" Yet to be determined +let s:rustup_has_nightly = get(g:, 'neomake_clippy_rustup_has_nightly', -1) + +function! neomake#makers#clippy#clippy() abort + " When rustup and a nightly toolchain is installed, that is used. + " Otherwise, the default cargo exectuable is used. If this is not part + " of a nightly rust, this will fail. + if s:rustup_has_nightly == -1 + if !executable('rustup') + let s:rustup_has_nightly = 0 + call system('rustc --version | grep -q "\-nightly"') + if v:shell_error + call neomake#log#warning('Clippy requires a nightly rust installation.') + endif + else + call system('rustup show | grep -q "^nightly-"') + let s:rustup_has_nightly = !v:shell_error + endif + endif + + let cargo_maker = neomake#makers#ft#rust#cargo() + let json_args = ['--message-format=json', '--quiet'] + + if s:rustup_has_nightly + return { + \ 'exe': 'rustup', + \ 'args': ['run', 'nightly', 'cargo', 'clippy'] + json_args, + \ 'process_output': cargo_maker.process_output, + \ } + else + return { + \ 'exe': 'cargo', + \ 'args': ['clippy'] + json_args, + \ 'process_output': cargo_maker.process_output, + \ } + endif +endfunction diff --git a/.vim/autoload/neomake/makers/ft/ada.vim b/.vim/autoload/neomake/makers/ft/ada.vim new file mode 100644 index 0000000..822da3c --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/ada.vim @@ -0,0 +1,14 @@ +function! neomake#makers#ft#ada#EnabledMakers() abort + return ['gcc'] +endfunction + +function! neomake#makers#ft#ada#gcc() abort + return { + \ 'args': ['-c', '-x', 'ada', '-gnatc'], + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %m' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/angular.vim b/.vim/autoload/neomake/makers/ft/angular.vim new file mode 100644 index 0000000..8c2f2d9 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/angular.vim @@ -0,0 +1,9 @@ +function! neomake#makers#ft#angular#SupersetOf() abort + return 'javascript' +endfunction + +function! neomake#makers#ft#angular#EnabledMakers() abort + return ['jshint', 'eslint', 'jscs'] +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/ansible.vim b/.vim/autoload/neomake/makers/ft/ansible.vim new file mode 100644 index 0000000..a1a001f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/ansible.vim @@ -0,0 +1,17 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#ansible#EnabledMakers() abort + return ['ansiblelint', 'yamllint'] +endfunction + +function! neomake#makers#ft#ansible#yamllint() abort + return neomake#makers#ft#yaml#yamllint() +endfunction + +function! neomake#makers#ft#ansible#ansiblelint() abort + return { + \ 'exe': 'ansible-lint', + \ 'args': ['-p', '--nocolor'], + \ 'errorformat': '%f:%l: [%tANSIBLE%n] %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/apiblueprint.vim b/.vim/autoload/neomake/makers/ft/apiblueprint.vim new file mode 100644 index 0000000..2e91b42 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/apiblueprint.vim @@ -0,0 +1,16 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#apiblueprint#EnabledMakers() abort + return executable('drafter') ? ['drafter'] : [] +endfunction + +function! neomake#makers#ft#apiblueprint#drafter() abort + " Drafter only operates on a single file at a time, and therefore doesn't + " bother to print out a file name with each error. We need to attach this + " so that the quickfix list can function properly. + return { + \ 'args': ['-l', '-u'], + \ 'errorformat': '%f: %t%[%^:]\\+: (%n) %m; line %l\, column %c%.%#', + \ 'mapexpr': 'neomake_bufname . ": " . v:val' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/applescript.vim b/.vim/autoload/neomake/makers/ft/applescript.vim new file mode 100644 index 0000000..71a00f1 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/applescript.vim @@ -0,0 +1,11 @@ +function! neomake#makers#ft#applescript#EnabledMakers() abort + return ['osacompile'] +endfunction + +function! neomake#makers#ft#applescript#osacompile() abort + return { + \ 'args': ['-o', g:neomake#compat#dev_null], + \ 'errorformat': '%f:%l: %trror: %m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/asciidoc.vim b/.vim/autoload/neomake/makers/ft/asciidoc.vim new file mode 100644 index 0000000..4d53751 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/asciidoc.vim @@ -0,0 +1,28 @@ +function! neomake#makers#ft#asciidoc#SupersetOf() abort + return 'text' +endfunction + +function! neomake#makers#ft#asciidoc#EnabledMakers() abort + let makers = executable('asciidoctor') ? ['asciidoctor'] : ['asciidoc'] + return makers + neomake#makers#ft#text#EnabledMakers() +endfunction + +function! neomake#makers#ft#asciidoc#asciidoc() abort + return { + \ 'errorformat': + \ '%E%\w%\+: %tRROR: %f: line %l: %m,' . + \ '%E%\w%\+: %tRROR: %f: %m,' . + \ '%E%\w%\+: FAILED: %f: line %l: %m,' . + \ '%E%\w%\+: FAILED: %f: %m,' . + \ '%W%\w%\+: %tARNING: %f: line %l: %m,' . + \ '%W%\w%\+: %tARNING: %f: %m,' . + \ '%W%\w%\+: DEPRECATED: %f: line %l: %m,' . + \ '%W%\w%\+: DEPRECATED: %f: %m', + \ 'args': ['-o', g:neomake#compat#dev_null], + \ } +endfunction + +function! neomake#makers#ft#asciidoc#asciidoctor() abort + return neomake#makers#ft#asciidoc#asciidoc() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/beancount.vim b/.vim/autoload/neomake/makers/ft/beancount.vim new file mode 100644 index 0000000..95eb31a --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/beancount.vim @@ -0,0 +1,12 @@ +function! neomake#makers#ft#beancount#EnabledMakers() abort + return ['bean_check'] +endfunction + +function! neomake#makers#ft#beancount#bean_check() abort + return { + \ 'exe': 'bean-check', + \ 'errorformat': '%E%f:%l:%m', + \ 'postprocess': function('neomake#postprocess#compress_whitespace'), + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/bib.vim b/.vim/autoload/neomake/makers/ft/bib.vim new file mode 100644 index 0000000..e3a9602 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/bib.vim @@ -0,0 +1,16 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#bib#EnabledMakers() abort + return [] +endfunction + +function! neomake#makers#ft#bib#bibtex() abort + return { + \ 'exe': 'bibtex', + \ 'args': ['-terse', '%:r'], + \ 'append_file': 0, + \ 'uses_filename': 0, + \ 'errorformat': '%E%m---line %l of file %f', + \ 'cwd': '%:p:h' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/c.vim b/.vim/autoload/neomake/makers/ft/c.vim new file mode 100644 index 0000000..1d0cda8 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/c.vim @@ -0,0 +1,110 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#c#EnabledMakers() abort + let makers = executable('clang') ? ['clang', 'clangtidy', 'clangcheck'] : ['gcc'] + call add(makers, 'checkpatch') + call add(makers, 'cppcheck') + return makers +endfunction + +let g:neomake#makers#ft#c#project_root_files = ['configure', 'CMakeLists.txt'] + +function! neomake#makers#ft#c#clang() abort + " as a single-file maker, include the current directory in the default + " search path + return { + \ 'args': ['-fsyntax-only', '-Wall', '-Wextra', '-I./'], + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%I%f:%l:%c: note: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%I%f:%l: note: %m,'. + \ '%f:%l: %m' + \ } +endfunction + +function! neomake#makers#ft#c#clangcheck() abort + return { + \ 'exe': 'clang-check', + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%I%f:%l:%c: note: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%I%f:%l: note: %m,'. + \ '%f:%l: %m', + \ } +endfunction + +function! neomake#makers#ft#c#gcc() abort + " as a single-file maker, include the current directory in the default + " search path + return { + \ 'args': ['-fsyntax-only', '-Wall', '-Wextra', '-I./'], + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%I%f:%l:%c: note: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%I%f:%l: note: %m,'. + \ '%f:%l: %m', + \ } +endfunction + +" The -p option followed by the path to the build directory should be set in +" the maker's arguments. That directory should contain the compile command +" database (compile_commands.json). +function! neomake#makers#ft#c#clangtidy() abort + return { + \ 'exe': 'clang-tidy', + \ 'errorformat': + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' . + \ '%E%m', + \ 'short_name': 'ctdy', + \ } +endfunction + +function! neomake#makers#ft#c#checkpatch() abort + return { + \ 'exe': 'checkpatch.pl', + \ 'args': ['--no-summary', '--no-tree', '--terse', '--file'], + \ 'errorformat': + \ '%f:%l: %tARNING: %m,' . + \ '%f:%l: %tRROR: %m', + \ } +endfunction + +function! neomake#makers#ft#c#cppcheck() abort + " Uses --force to avoid: + " nofile:0:0:information:Too many #ifdef configurations - cppcheck only checks 12 configurations. + " NOTE: '--language=c' should be the first args, it gets replaced in + " neomake#makers#ft#cpp#cppcheck. + return { + \ 'args': ['--language=c', '--quiet', '--enable=warning', '--force', + \ '--template="{file}:{line}:{column}:{severity}:{message}"'], + \ 'errorformat': + \ 'nofile:0:0:%trror:%m,' . + \ '%f:%l:%c:%trror:%m,' . + \ 'nofile:0:0:%tarning:%m,'. + \ '%f:%l:%c:%tarning:%m,'. + \ 'nofile:0:0:%tnformation:%m,'. + \ '%f:%l:%c:%tnformation:%m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/cf3.vim b/.vim/autoload/neomake/makers/ft/cf3.vim new file mode 100644 index 0000000..7826fc6 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/cf3.vim @@ -0,0 +1,14 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#cf3#EnabledMakers() abort + return ['cfpromises'] +endfunction + +function! neomake#makers#ft#cf3#cfpromises() abort + return { + \ 'exe': 'cf-promises', + \ 'args': ['-cf'], + \ 'errorformat': + \ '%E%f:%l:%c: error: %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/chef.vim b/.vim/autoload/neomake/makers/ft/chef.vim new file mode 100644 index 0000000..805a070 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/chef.vim @@ -0,0 +1,23 @@ +function! neomake#makers#ft#chef#SupersetOf() abort + return 'ruby' +endfunction + +function! neomake#makers#ft#chef#EnabledMakers() abort + let ruby_makers = neomake#makers#ft#ruby#EnabledMakers() + return ruby_makers + ['foodcritic', 'cookstyle'] +endfunction + +function! neomake#makers#ft#chef#foodcritic() abort + return { + \ 'errorformat': '%WFC%n: %m: %f:%l', + \ } +endfunction + +function! neomake#makers#ft#chef#cookstyle() abort + return { + \ 'args': ['-f', 'emacs'], + \ 'errorformat': '%f:%l:%c: %t: %m', + \ 'postprocess': function('neomake#makers#ft#ruby#RubocopEntryProcess'), + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/coffee.vim b/.vim/autoload/neomake/makers/ft/coffee.vim new file mode 100644 index 0000000..67c6cc3 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/coffee.vim @@ -0,0 +1,15 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#coffee#EnabledMakers() abort + return ['coffeelint'] +endfunction + +function! neomake#makers#ft#coffee#coffeelint() abort + return { + \ 'args': ['--reporter=csv'], + \ 'errorformat': '%f\,%l\,%\d%#\,%trror\,%m,' . + \ '%f\,%l\,%trror\,%m,' . + \ '%f\,%l\,%\d%#\,%tarn\,%m,' . + \ '%f\,%l\,%tarn\,%m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/cpp.vim b/.vim/autoload/neomake/makers/ft/cpp.vim new file mode 100644 index 0000000..0cfa877 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/cpp.vim @@ -0,0 +1,50 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#cpp#EnabledMakers() abort + let makers = executable('clang++') ? ['clang', 'clangtidy', 'clangcheck'] : ['gcc'] + call add(makers, 'cppcheck') + return makers +endfunction + +function! neomake#makers#ft#cpp#clang() abort + let maker = neomake#makers#ft#c#clang() + let maker.exe = 'clang++' + let maker.args += ['-std=c++1z'] + return maker +endfunction + +function! neomake#makers#ft#cpp#gcc() abort + let maker = neomake#makers#ft#c#gcc() + let maker.exe = 'g++' + let maker.args += ['-std=c++1z'] + return maker +endfunction + +function! neomake#makers#ft#cpp#clangtidy() abort + return neomake#makers#ft#c#clangtidy() +endfunction + +function! neomake#makers#ft#cpp#clangcheck() abort + return neomake#makers#ft#c#clangcheck() +endfunction + +function! neomake#makers#ft#cpp#cppcheck() abort + let maker = neomake#makers#ft#c#cppcheck() + let maker.args[0] = '--language=c++' + return maker +endfunction + +function! neomake#makers#ft#cpp#cpplint() abort + return { + \ 'exe': executable('cpplint') ? 'cpplint' : 'cpplint.py', + \ 'args': ['--verbose=3'], + \ 'errorformat': + \ '%A%f:%l: %m [%t],' . + \ '%-G%.%#', + \ 'postprocess': function('neomake#makers#ft#cpp#CpplintEntryProcess') + \ } +endfunction + +function! neomake#makers#ft#cpp#CpplintEntryProcess(entry) abort + let a:entry.type = str2nr(a:entry.type) < 5 ? 'W' : 'E' +endfunction diff --git a/.vim/autoload/neomake/makers/ft/crystal.vim b/.vim/autoload/neomake/makers/ft/crystal.vim new file mode 100644 index 0000000..b570c74 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/crystal.vim @@ -0,0 +1,25 @@ +function! neomake#makers#ft#crystal#EnabledMakers() abort + return ['crystal', 'ameba'] +endfunction + +function! neomake#makers#ft#crystal#crystal() abort + " from vim-crystal + return { + \ 'args': ['run', '--no-color', '--no-codegen'], + \ 'errorformat': + \ '%ESyntax error in line %l: %m,'. + \ '%ESyntax error in %f:%l: %m,'. + \ '%EError in %f:%l: %m,'. + \ '%C%p^,'. + \ '%-C%.%#' + \ } +endfunction + +function! neomake#makers#ft#crystal#ameba() abort + " from vim-crystal + return { + \ 'args': ['--format', 'flycheck'], + \ 'errorformat': '%f:%l:%c: %t: %m' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/cs.vim b/.vim/autoload/neomake/makers/ft/cs.vim new file mode 100644 index 0000000..6457cff --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/cs.vim @@ -0,0 +1,22 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#cs#EnabledMakers() abort + return ['mcs'] +endfunction + +function! neomake#makers#ft#cs#mcs() abort + return { + \ 'args': ['--parse', '--unsafe'], + \ 'errorformat': '%f(%l\,%c): %trror %m', + \ } +endfunction + +function! neomake#makers#ft#cs#msbuild() abort + return { + \ 'exe': 'msbuild', + \ 'args': ['-nologo', '-v:q', '-property:GenerateFullPaths=true', neomake#utils#FindGlobFile('*.sln')], + \ 'errorformat': '%E%f(%l\,%c): error CS%n: %m [%.%#],'. + \ '%W%f(%l\,%c): warning CS%n: %m [%.%#]', + \ 'append_file' : 0, + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/css.vim b/.vim/autoload/neomake/makers/ft/css.vim new file mode 100644 index 0000000..3afbccd --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/css.vim @@ -0,0 +1,35 @@ +scriptencoding utf8 + +function! neomake#makers#ft#css#EnabledMakers() abort + return ['csslint', 'stylelint'] +endfunction + +function! neomake#makers#ft#css#csslint() abort + return { + \ 'args': ['--format=compact'], + \ 'errorformat': + \ '%-G,'. + \ '%-G%f: lint free!,'. + \ '%f: line %l\, col %c\, %trror - %m,'. + \ '%f: line %l\, col %c\, %tarning - %m,'. + \ '%f: line %l\, col %c\, %m,'. + \ '%f: %tarning - %m' + \ } +endfunction + +function! neomake#makers#ft#css#stylelint() abort + let maker = { + \ 'errorformat': + \ '%-P%f,'. + \ '%W%*\s%l:%c%*\s✖ %m,'. + \ '%-Q,'. + \ '%+EError: No configuration provided for %f,%-C %.%#' + \ } + + function! maker.postprocess(entry) abort + let a:entry.text = substitute(a:entry.text, '\v\s\s+(.{-})\s*$', ' [\1]', 'g') + endfunction + + return maker +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/cuda.vim b/.vim/autoload/neomake/makers/ft/cuda.vim new file mode 100644 index 0000000..0fbf6c9 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/cuda.vim @@ -0,0 +1,15 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#cuda#EnabledMakers() abort + return ['nvcc'] +endfunction + +function! neomake#makers#ft#cuda#nvcc() abort + return { + \ 'exe': 'nvcc', + \ 'errorformat': + \ '%f\(%l\): %trror: %m,'. + \ '%f\(%l\): %tarning: %m,'. + \ '%f\(%l\): %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/d.vim b/.vim/autoload/neomake/makers/ft/d.vim new file mode 100644 index 0000000..5206a8d --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/d.vim @@ -0,0 +1,92 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#d#EnabledMakers() abort + " dmd, ldmd, and gdmd all share a common CLI. + " Ordered in efficiency of compiler + for m in ['dmd', 'ldmd', 'gdmd'] + if executable(m) + return [m] + endif + endfor + return [] +endfunction + +function! s:findDubRoot() abort + "Look upwards for a dub.json or dub.sdl to find the root + "I did it like this because it's the only cross platform way I know of + let tmp_file = findfile('dub.json', '.;') + if empty(tmp_file) + let tmp_file = findfile('dub.sdl', '.;') + endif + return tmp_file +endfunction + +function! s:UpdateDub() abort + "Add dub directories + let s:dubImports = [] + let tmp_file = s:findDubRoot() + if executable('dub') && !empty(tmp_file) + let tmp_dir = fnamemodify(tmp_file,':p:h') + let dubCmd = 'dub describe --data=import-paths --annotate ' + \ .'--skip-registry=all --vquiet --data-list --root=' + let output = system(dubCmd . tmp_dir) + if(v:shell_error == 0 && !empty(output)) + " Is \n portable? + let s:dubImports = split(output, '\n') + call map(s:dubImports, "'-I' . v:val") + endif + endif +endfunction + +"GDMD does not adhere to dmd's flags or output, but to GCC's. +"This is for LDMD and dmd only. +function! s:DmdStyleMaker(args) abort + "Updating dub paths each make might be slow? + call s:UpdateDub() + let args = ['-w', '-wi', '-c', '-o-', '-vcolumns'] + a:args + s:dubImports + return { + \ 'args': args, + \ 'errorformat': + \ '%f(%l\,%c): %trror: %m,' . + \ '%f(%l): %trror: %m,' . + \ '%f(%l\,%c): %tarning: %m,' . + \ '%f(%l): %tarning: %m,' . + \ '%f(%l\,%c): Deprecation: %m,' . + \ '%f(%l): Deprecation: %m,', + \ } +endfunction + +function! neomake#makers#ft#d#dmd() abort + let args = [] + if exists('g:neomake_d_dmd_args_conf') + call add(args, '-conf=' . expand(g:neomake_d_dmd_args_conf)) + endif + return s:DmdStyleMaker(args) +endfunction + +function! neomake#makers#ft#d#ldmd() abort + let args = [] + if exists('g:neomake_d_ldmd_args_conf') + call add(args, '-conf=' . expand(g:neomake_d_ldmd_args_conf)) + endif + return s:DmdStyleMaker(args) +endfunction + +function! neomake#makers#ft#d#gdmd() abort + let args = ['-c', '-o-', '-fsyntax-only', s:UpdateDub()] + return { + \ 'args': args, + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%-G%f:%l: %#error: %#(Each undeclared identifier is reported only%.%#,' . + \ '%-G%f:%l: %#error: %#for each function it appears%.%#,' . + \ '%-GIn file included%.%#,' . + \ '%-G %#from %f:%l\,,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%f:%l:%c: %m,' . + \ '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,'. + \ '%f:%l: %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/docbk.vim b/.vim/autoload/neomake/makers/ft/docbk.vim new file mode 100644 index 0000000..dceffac --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/docbk.vim @@ -0,0 +1,8 @@ +function! neomake#makers#ft#docbk#EnabledMakers() abort + return ['xmllint'] +endfunction + +function! neomake#makers#ft#docbk#xmllint() abort + return neomake#makers#ft#xml#xmllint() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/dockerfile.vim b/.vim/autoload/neomake/makers/ft/dockerfile.vim new file mode 100644 index 0000000..a6d767f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/dockerfile.vim @@ -0,0 +1,13 @@ +function! neomake#makers#ft#dockerfile#EnabledMakers() abort + return ['hadolint'] +endfunction + +function! neomake#makers#ft#dockerfile#hadolint() abort + return { + \ 'output_stream': 'stdout', + \ 'uses_stdin': 1, + \ 'args': ['--format', 'tty'], + \ 'errorformat': '%f:%l %m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/elixir.vim b/.vim/autoload/neomake/makers/ft/elixir.vim new file mode 100644 index 0000000..4de652e --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/elixir.vim @@ -0,0 +1,72 @@ +" vim: ts=4 sw=4 et + +" Credo error types. +" F -> Refactoring opportunities +" W -> Warnings +" C -> Convention violation +" D -> Software design suggestions +" R -> Readability suggestions +" Map structure {CredoError: NeomakeType, ...} +let s:neomake_elixir_credo_config_typemap = { + \ 'F': 'W', + \ 'C': 'W', + \ 'D': 'I', + \ 'R': 'I'} + +function! neomake#makers#ft#elixir#PostprocessEnforceMaxBufferLine(entry) abort + let buffer_lines = str2nr(line('$')) + if (buffer_lines < a:entry.lnum) + let a:entry.lnum = buffer_lines + endif +endfunction + +function! neomake#makers#ft#elixir#PostprocessCredo(entry) abort + let type = toupper(a:entry.type) + let type_map = extend(s:neomake_elixir_credo_config_typemap, + \ get(g:, 'neomake_elixir_credo_config_typemap', {})) + if has_key(type_map, type) + let a:entry.type = type_map[type] + endif +endfunction + +function! neomake#makers#ft#elixir#EnabledMakers() abort + return ['mix'] +endfunction + +function! neomake#makers#ft#elixir#elixir() abort + return { + \ 'errorformat': + \ '%E** %s %f:%l: %m,'. + \ '%W%f:%l: warning: %m' + \ } +endfunction + +function! neomake#makers#ft#elixir#credo() abort + return { + \ 'exe': 'mix', + \ 'args': ['credo', 'list', '--format=oneline'], + \ 'postprocess': function('neomake#makers#ft#elixir#PostprocessCredo'), + \ 'errorformat': + \'[%t] %. %f:%l:%c %m,' . + \'[%t] %. %f:%l %m' + \ } +endfunction + +function! neomake#makers#ft#elixir#mix() abort + return { + \ 'exe' : 'mix', + \ 'args': ['compile', '--warnings-as-errors'], + \ 'postprocess': function('neomake#makers#ft#elixir#PostprocessEnforceMaxBufferLine'), + \ 'errorformat': + \ '** %s %f:%l: %m,'. + \ '%Ewarning: %m,%C %f:%l,%Z' + \ } +endfunction + +function! neomake#makers#ft#elixir#dogma() abort + return { + \ 'exe': 'mix', + \ 'args': ['dogma', '--format=flycheck'], + \ 'errorformat': '%E%f:%l:%c: %.: %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/elm.vim b/.vim/autoload/neomake/makers/ft/elm.vim new file mode 100644 index 0000000..fe1d2f6 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/elm.vim @@ -0,0 +1,53 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#elm#EnabledMakers() abort + return ['elmMake'] +endfunction + +function! neomake#makers#ft#elm#elmMake() abort + return { + \ 'exe': 'elm-make', + \ 'args': ['--report=json', '--output=' . g:neomake#compat#dev_null], + \ 'process_output': function('neomake#makers#ft#elm#ElmMakeProcessOutput') + \ } +endfunction + +function! neomake#makers#ft#elm#ElmMakeProcessOutput(context) abort + let errors = [] + " output will be a List, containing either: + " 1) A success message + " 2) A string holding a JSON array for both warnings and errors + + for line in a:context.output + if line[0] ==# '[' + let decoded = neomake#compat#json_decode(line) + for item in decoded + if get(item, 'type', '') ==# 'warning' + let code = 'W' + else + let code = 'E' + endif + + let compiler_error = item['tag'] + let message = item['overview'] + let filename = item['file'] + let region_start = item['region']['start'] + let region_end = item['region']['end'] + let row = region_start['line'] + let col = region_start['column'] + let length = region_end['column'] - region_start['column'] + + let error = { + \ 'text': compiler_error . ' : ' . message, + \ 'type': code, + \ 'lnum': row, + \ 'col': col, + \ 'length': length, + \ 'filename': filename, + \ } + call add(errors, error) + endfor + endif + endfor + return errors +endfunction diff --git a/.vim/autoload/neomake/makers/ft/erlang.vim b/.vim/autoload/neomake/makers/ft/erlang.vim new file mode 100644 index 0000000..a554098 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/erlang.vim @@ -0,0 +1,72 @@ + +function! neomake#makers#ft#erlang#EnabledMakers() abort + return ['erlc'] +endfunction + +function! neomake#makers#ft#erlang#erlc() abort + let maker = { + \ 'errorformat': + \ '%W%f:%l: Warning: %m,' . + \ '%E%f:%l: %m' + \ } + function! maker.InitForJob(_jobinfo) abort + let self.args = neomake#makers#ft#erlang#GlobPaths() + endfunction + return maker +endfunction + +if !exists('g:neomake_erlang_erlc_target_dir') + let g:neomake_erlang_erlc_target_dir = tempname() +endif + +function! neomake#makers#ft#erlang#GlobPaths() abort + " Find project root directory. + let rebar_config = neomake#utils#FindGlobFile('rebar.config') + if !empty(rebar_config) + let root = fnamemodify(rebar_config, ':h') + else + " At least try with CWD + let root = getcwd() + endif + let root = fnamemodify(root, ':p') + let build_dir = root . '_build' + let ebins = [] + if isdirectory(build_dir) + " Pick the rebar3 profile to use + let default_profile = expand('%') =~# '_SUITE.erl$' ? 'test' : 'default' + let profile = get(b:, 'neomake_erlang_erlc_rebar3_profile', default_profile) + let ebins += neomake#compat#glob_list(build_dir . '/' . profile . '/lib/*/ebin') + let target_dir = build_dir . '/neomake' + else + let target_dir = get(b:, 'neomake_erlang_erlc_target_dir', + \ get(g:, 'neomake_erlang_erlc_target_dir')) + endif + " If /_build doesn't exist it might be a rebar2/erlang.mk project + if isdirectory(root . 'deps') + let ebins += neomake#compat#glob_list(root . 'deps/*/ebin') + endif + " Set g:neomake_erlang_erlc_extra_deps in a project-local .vimrc, e.g.: + " let g:neomake_erlang_erlc_extra_deps = ['deps.local'] + " Or just b:neomake_erlang_erlc_extra_deps in a specific buffer. + let extra_deps_dirs = get(b:, 'neomake_erlang_erlc_extra_deps', + \ get(g:, 'neomake_erlang_erlc_extra_deps')) + if !empty(extra_deps_dirs) + for extra_deps in extra_deps_dirs + if extra_deps[-1] !=# '/' + let extra_deps .= '/' + endif + let ebins += neomake#compat#glob_list(extra_deps . '*/ebin') + endfor + endif + let args = ['-pa', 'ebin', '-I', 'include', '-I', 'src'] + for ebin in ebins + let args += [ '-pa', ebin, + \ '-I', substitute(ebin, 'ebin$', 'include', '') ] + endfor + if !isdirectory(target_dir) + call mkdir(target_dir, 'p') + endif + let args += ['-o', target_dir] + return args +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/fish.vim b/.vim/autoload/neomake/makers/ft/fish.vim new file mode 100644 index 0000000..429afcc --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/fish.vim @@ -0,0 +1,16 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#fish#EnabledMakers() abort + return ['fish'] +endfunction + +function! neomake#makers#ft#fish#fish() abort + return { + \ 'args': ['-n'], + \ 'errorformat': + \ '%C%f (line %l): %s,'. + \ '%-Gfish: %.%#,'. + \ '%Z%p^,'. + \ '%E%m' + \} +endfunction diff --git a/.vim/autoload/neomake/makers/ft/fortran.vim b/.vim/autoload/neomake/makers/ft/fortran.vim new file mode 100644 index 0000000..828bba9 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/fortran.vim @@ -0,0 +1,32 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#fortran#EnabledMakers() abort + return ['gfortran'] +endfunction + +" Using the errorformat from syntastic +function! neomake#makers#ft#fortran#ifort() abort + return { + \ 'args': ['-syntax-only', '-warn'], + \ 'errorformat': + \ '%E%f(%l): error #%n: %m,'. + \ '%W%f(%l): warning #%n: %m,'. + \ '%W%f(%l): remark #%n: %m,'. + \ '%-Z%p^,'. + \ '%-G%.%#', + \ } +endfunction + +" Using the errorformat from syntastic +function! neomake#makers#ft#fortran#gfortran() abort + return { + \ 'args': ['-fsyntax-only', '-Wall', '-Wextra'], + \ 'errorformat': + \ '%-C %#,'. + \ '%-C %#%.%#,'. + \ '%A%f:%l%[.:]%c:,'. + \ '%Z%\m%\%%(Fatal %\)%\?%trror: %m,'. + \ '%Z%tarning: %m,'. + \ '%-G%.%#', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/go.vim b/.vim/autoload/neomake/makers/ft/go.vim new file mode 100644 index 0000000..ac53730 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/go.vim @@ -0,0 +1,84 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#go#EnabledMakers() abort + let makers = ['go'] + if executable('golangci-lint') + call add(makers, 'golangci_lint') + elseif executable('gometalinter') + call add(makers, 'gometalinter') + else + call extend(makers, ['golint', 'govet']) + endif + return makers +endfunction + +function! neomake#makers#ft#go#go() abort + return { + \ 'args': [ + \ 'test', '-c', + \ '-o', g:neomake#compat#dev_null, + \ ], + \ 'append_file': 0, + \ 'cwd': '%:h', + \ 'serialize': 1, + \ 'serialize_abort_on_error': 1, + \ 'errorformat': + \ '%W%f:%l: warning: %m,' . + \ '%E%f:%l:%c:%m,' . + \ '%E%f:%l:%m,' . + \ '%C%\s%\+%m,' . + \ '%-G%.%#\\\[no test files],' . + \ '%-G#%.%#', + \ 'postprocess': function('neomake#postprocess#compress_whitespace'), + \ 'version_arg': 'version', + \ } +endfunction + +function! neomake#makers#ft#go#golint() abort + " golint's issues are informational, as they're stylistic (not bugs) + return { + \ 'errorformat': + \ '%I%f:%l:%c: %m,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#go#govet() abort + return { + \ 'exe': 'go', + \ 'args': ['vet'], + \ 'append_file': 0, + \ 'cwd': '%:h', + \ 'errorformat': + \ '%Evet: %.%\+: %f:%l:%c: %m,' . + \ '%W%f:%l: %m,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#go#gometalinter() abort + " Only run a subset of gometalinter for speed, users can override with: + " let g:neomake_go_gometalinter_args = ['--disable-all', '--enable=X', ...] + " + " All linters are only warnings, the go compiler will report errors + return { + \ 'args': ['--disable-all', '--enable=errcheck', '--enable=megacheck', '--vendor'], + \ 'append_file': 0, + \ 'cwd': '%:h', + \ 'errorformat': + \ '%f:%l:%c:%t%*[^:]: %m,' . + \ '%f:%l::%t%*[^:]: %m' + \ } +endfunction + +function! neomake#makers#ft#go#golangci_lint() abort + return { + \ 'exe': 'golangci-lint', + \ 'args': ['run', '--out-format=line-number', '--print-issued-lines=false'], + \ 'output_stream': 'stdout', + \ 'append_file': 0, + \ 'cwd': '%:h', + \ 'errorformat': + \ '%f:%l:%c: %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/haml.vim b/.vim/autoload/neomake/makers/ft/haml.vim new file mode 100644 index 0000000..df79b38 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/haml.vim @@ -0,0 +1,13 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#haml#EnabledMakers() abort + return ['hamllint'] +endfunction + +function! neomake#makers#ft#haml#hamllint() abort + return { + \ 'exe': 'haml-lint', + \ 'args': ['--no-color'], + \ 'errorformat': '%f:%l [%t] %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/haskell.vim b/.vim/autoload/neomake/makers/ft/haskell.vim new file mode 100644 index 0000000..64a5227 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/haskell.vim @@ -0,0 +1,169 @@ +unlet! s:makers +unlet! s:uses_cabal + +function! neomake#makers#ft#haskell#EnabledMakers() abort + if !exists('s:makers') + " cache whether each maker is available, to avoid lots of (UI blocking) + " system calls + " TODO: figure out how to do all this configuration async instead of + " caching it--that would allow the user to change directories from + " within vim and recalculate maker availability without restarting vim + let commands = ['ghc-mod', 'hdevtools', 'hlint', 'liquid'] + let s:makers = [] + let s:jobs = [] + for command in commands + " stack may be able to find a maker binary that's not on the normal + " path so check for that first + if executable('stack') + " run the maker command using stack to see whether stack can + " find it use the help flag to run the maker command without + " doing anything + let stack_command = [ + \ 'stack' + \ , 'exec' + \ , '--' + \ , command + \ , '--help' + \ ] + if has('nvim') + let job_id = jobstart( + \ stack_command, + \ { 'command': command + \ , 'on_exit': function('s:CheckStackMakerAsync') + \ }) + if job_id > 0 + call add(s:jobs, job_id) + endif + else + call extend(stack_command, ['> /dev/null 2>&1;', 'echo $?']) + if system(join(stack_command, ' ')) == 0 + call add(s:makers, substitute(command, '-', '', 'g')) + endif + endif + elseif executable(command) " no stack bin so check for maker bin + call add(s:makers, substitute(command, '-', '', 'g')) + endif + endfor + if has('nvim') + call jobwait(s:jobs) + endif + endif + return s:makers +endfunction + +function! neomake#makers#ft#haskell#hdevtools() abort + let params = { + \ 'exe': 'hdevtools', + \ 'args': ['check', '-g-Wall'], + \ 'mapexpr': s:CleanUpSpaceAndBackticks(), + \ 'errorformat': + \ '%-Z %#,'. + \ '%W%f:%l:%v: Warning: %m,'. + \ '%W%f:%l:%v: Warning:,'. + \ '%E%f:%l:%v: %m,'. + \ '%E%>%f:%l:%v:,'. + \ '%+C %#%m,'. + \ '%W%>%f:%l:%v:,'. + \ '%+C %#%tarning: %m,' + \ } + " hdevtools needs the GHC-PACKAGE-PATH environment variable to exist + " when running on a project WITHOUT a cabal file, but it needs the + " GHC-PACKAGE-PATH to NOT exist when running on a with a project WITH + " a cabal file + if !exists('s:uses_cabal') + let s:uses_cabal = 0 + if executable('stack') + let output = neomake#compat#systemlist(['stack', '--verbosity', 'silent', 'path', '--project-root']) + if !empty(output) + let rootdir = output[0] + if !empty(glob(rootdir . '/*.cabal')) + let s:uses_cabal = 1 + endif + endif + endif + endif + if s:uses_cabal + let params['stackexecargs'] = ['--no-ghc-package-path'] + endif + return s:TryStack(params) +endfunction + +function! neomake#makers#ft#haskell#ghcmod() abort + " This filters out newlines, which is what neovim gives us instead of the + " null bytes that ghc-mod sometimes spits out. + let mapexpr = 'substitute(v:val, "\n", "", "g")' + return s:TryStack({ + \ 'exe': 'ghc-mod', + \ 'args': ['check'], + \ 'mapexpr': mapexpr, + \ 'errorformat': + \ '%-G%\s%#,' . + \ '%f:%l:%c:%trror: %m,' . + \ '%f:%l:%c:%tarning: %m,'. + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%E%f:%l:%c:%m,' . + \ '%E%f:%l:%c:,' . + \ '%Z%m' + \ }) +endfunction + +function! neomake#makers#ft#haskell#HlintEntryProcess(entry) abort + " Postprocess hlint output to make it more readable as a single line + let a:entry.text = substitute(a:entry.text, '\v(Found:)\s*\n', ' | \1', 'g') + let a:entry.text = substitute(a:entry.text, '\v(Why not:)\s*\n', ' | \1', 'g') + let a:entry.text = substitute(a:entry.text, '^No hints$', '', 'g') + call neomake#postprocess#compress_whitespace(a:entry) +endfunction + +function! neomake#makers#ft#haskell#hlint() abort + return s:TryStack({ + \ 'exe': 'hlint', + \ 'postprocess': function('neomake#makers#ft#haskell#HlintEntryProcess'), + \ 'args': [], + \ 'errorformat': + \ '%E%f:%l:%v: Error: %m,' . + \ '%W%f:%l:%v: Warning: %m,' . + \ '%I%f:%l:%v: Suggestion: %m,' . + \ '%C%m' + \ }) +endfunction + +function! neomake#makers#ft#haskell#liquid() abort + return s:TryStack({ + \ 'exe': 'liquid', + \ 'args': [], + \ 'mapexpr': s:CleanUpSpaceAndBackticks(), + \ 'errorformat': + \ '%E %f:%l:%c-%.%#Error: %m,' . + \ '%C%.%#|%.%#,' . + \ '%C %#^%#,' . + \ '%C%m,' + \ }) +endfunction + +function! s:CheckStackMakerAsync(_job_id, data, _event) dict abort + if a:data == 0 + call add(s:makers, substitute(self.command, '-', '', 'g')) + endif +endfunction + +function! s:TryStack(maker) abort + if executable('stack') + if !has_key(a:maker, 'stackexecargs') + let a:maker['stackexecargs'] = [] + endif + let a:maker['args'] = + \ ['--verbosity', 'silent', 'exec'] + \ + a:maker['stackexecargs'] + \ + ['--', a:maker['exe']] + \ + a:maker['args'] + let a:maker['exe'] = 'stack' + endif + return a:maker +endfunction + +function! s:CleanUpSpaceAndBackticks() abort + return 'substitute(substitute(v:val, " \\{2,\\}", " ", "g"), "`", "''", "g")' +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/haxe.vim b/.vim/autoload/neomake/makers/ft/haxe.vim new file mode 100644 index 0000000..9fd07ec --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/haxe.vim @@ -0,0 +1,11 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#haxe#EnabledMakers() abort + return ['haxe'] +endfunction + +function! neomake#makers#ft#haxe#haxe() abort + return { + \ 'errorformat': '%E%f:%l: characters %c-%n : %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/help.vim b/.vim/autoload/neomake/makers/ft/help.vim new file mode 100644 index 0000000..c573cef --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/help.vim @@ -0,0 +1,40 @@ +let s:makers = ['writegood'] + +let s:slash = neomake#utils#Slash() +let s:vimhelplint_exe = '' +if executable('vimhelplint') + let s:vimhelplint_exe = 'vimhelplint' +else + let s:neomake_root = expand(':p:h:h:h:h:h', 1) + if !empty(glob(join([s:neomake_root, 'build', 'vimhelplint'], s:slash))) + let s:vimhelplint_exe = join([s:neomake_root, 'contrib', 'vimhelplint'], s:slash) + endif +endif +if !empty(s:vimhelplint_exe) + let s:makers += ['vimhelplint'] +endif + +function! neomake#makers#ft#help#EnabledMakers() abort + return s:makers +endfunction + +function! neomake#makers#ft#help#vimhelplint() abort + " NOTE: does not support/uses arg from wrapper script (i.e. no support for + " tempfiles). It will use the arg only to expand/glob `*.txt` + " (which does not include the hidden tempfile). + return { + \ 'exe': s:vimhelplint_exe, + \ 'errorformat': '%f:%l:%c:%trror:%n:%m,%f:%l:%c:%tarning:%n:%m', + \ 'postprocess': function('neomake#postprocess#generic_length'), + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#help#proselint() abort + return neomake#makers#ft#text#proselint() +endfunction + +function! neomake#makers#ft#help#writegood() abort + return neomake#makers#ft#text#writegood() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/html.vim b/.vim/autoload/neomake/makers/ft/html.vim new file mode 100644 index 0000000..6100175 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/html.vim @@ -0,0 +1,20 @@ +function! neomake#makers#ft#html#tidy() abort + " NOTE: could also have info items, but those are skipped with -e/-q, e.g. + " 'line 7 column 1 - Info: value for attribute "id" missing quote marks'. + return { + \ 'args': ['-e', '-q', '--gnu-emacs', 'true'], + \ 'errorformat': '%W%f:%l:%c: Warning: %m', + \ } +endfunction + +function! neomake#makers#ft#html#htmlhint() abort + return { + \ 'args': ['--format', 'unix', '--nocolor'], + \ 'errorformat': '%f:%l:%c: %m,%-G,%-G%*\d problems', + \ } +endfunction + +function! neomake#makers#ft#html#EnabledMakers() abort + return ['tidy', 'htmlhint'] +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/idris.vim b/.vim/autoload/neomake/makers/ft/idris.vim new file mode 100644 index 0000000..5d95edb --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/idris.vim @@ -0,0 +1,25 @@ +function! neomake#makers#ft#idris#EnabledMakers() abort + return ['idris'] +endfunction + +function! neomake#makers#ft#idris#Postprocess(entry) abort + call neomake#postprocess#compress_whitespace(a:entry) + " Extract length from the beginning of the entry ('-4:When checking left hand side of xor:'). + if a:entry.text =~# '\v^\d+:' + let end = 0 + a:entry.text " cast to int + let a:entry.length = end - a:entry.col + let a:entry.text = substitute(a:entry.text, '\v^([^:]+:){2} ', '', '') + endif +endfunction + +function! neomake#makers#ft#idris#idris() abort + return { + \ 'exe': 'idris', + \ 'args': ['--check', '--warn', '--total', '--warnpartial', '--warnreach'], + \ 'errorformat': + \ '%E%f:%l:%c:%.%#,%-C %#%m,%-C%.%#,'. + \ '%E%f:%l:%c-%m,%-C %#%m,%-C%.%#', + \ 'postprocess': function('neomake#makers#ft#idris#Postprocess'), + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/jade.vim b/.vim/autoload/neomake/makers/ft/jade.vim new file mode 100644 index 0000000..c747950 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/jade.vim @@ -0,0 +1,13 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#jade#EnabledMakers() abort + return ['jadelint'] +endfunction + +function! neomake#makers#ft#jade#jadelint() abort + return { + \ 'exe': 'jade-lint', + \ 'args': ['--reporter', 'inline'], + \ 'errorformat': '%f:%l:%c %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/jasmine.vim b/.vim/autoload/neomake/makers/ft/jasmine.vim new file mode 100644 index 0000000..56e0a4f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/jasmine.vim @@ -0,0 +1,9 @@ +function! neomake#makers#ft#jasmine#SupersetOf() abort + return 'javascript' +endfunction + +function! neomake#makers#ft#jasmine#EnabledMakers() abort + return ['jshint', 'eslint', 'jscs'] +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/java.vim b/.vim/autoload/neomake/makers/ft/java.vim new file mode 100644 index 0000000..1c09bda --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/java.vim @@ -0,0 +1,396 @@ +"============================================================================ +"File: java.vim +"Description: Syntax checking plugin for neomake +"Maintainer: Wang Shidong +"License: This program is free software. It comes without any warranty, +" to the extent permitted by applicable law. You can redistribute +" it and/or modify it under the terms of the Do What The Fuck You +" Want To Public License, Version 2, as published by Sam Hocevar. +" See http://sam.zoy.org/wtfpl/COPYING for more details. +"============================================================================ + +let s:save_cpo = &cpoptions +set cpoptions&vim + +if exists('g:loaded_neomake_java_javac_maker') + finish +endif +let g:loaded_neomake_java_javac_maker = 1 + +let g:neomake_java_javac_maven_pom_tags = ['build', 'properties'] +let g:neomake_java_javac_maven_pom_properties = {} +let s:is_windows = has('win32') || has('win64') || has('win16') || has('dos32') || has('dos16') +if s:is_windows + let s:fsep = ';' + let s:psep = '\' +else + let s:fsep = ':' + let s:psep = '/' +endif +let g:neomake_java_checker_home = fnamemodify(expand(''), ':p:h:gs?\\?/?') + +" custom options +let g:neomake_java_javac_executable = + \ get(g:, 'neomake_java_javac_executable', 'javac') + +let g:neomake_java_maven_executable = + \ get(g:, 'neomake_java_maven_executable', 'mvn') + +let g:neomake_java_gradle_executable = + \ get(g:, 'neomake_java_gradle_executable', s:is_windows? '.\gradlew.bat' : './gradlew') + +let g:neomake_java_ant_executable = + \ get(g:, 'neomake_java_ant_executable', 'ant') + +let g:neomake_java_checkstyle_executable = + \ get(g:, 'neomake_java_checkstyle_executable', 'checkstyle') + +let g:neomake_java_javac_options = + \ get(g:, 'neomake_java_javac_options', ['-Xlint']) + +let g:neomake_java_maven_options = + \ get(g:, 'neomake_java_maven_options', '') + +let g:neomake_java_javac_classpath = + \ get(g:, 'neomake_java_javac_classpath', '') + +let g:neomake_java_javac_outputdir = + \ get(g:, 'neomake_java_javac_outputdir', '') + +let g:neomake_java_checkstyle_xml = + \ get(g:, 'neomake_java_checkstyle_xml', '/usr/share/checkstyle/google_checks.xml') + +let g:neomake_java_javac_delete_output = + \ get(g:, 'neomake_java_javac_delete_output', 1) + +let g:neomake_java_javac_autoload_maven_classpath = + \ get(g:, 'neomake_java_javac_autoload_maven_classpath', 1) + +let g:neomake_java_javac_autoload_gradle_classpath = + \ get(g:, 'neomake_java_javac_autoload_gradle_classpath', 1) + +let g:neomake_java_javac_autoload_ant_classpath = + \ get(g:, 'neomake_java_javac_autoload_ant_classpath', 1) + +let g:neomake_java_javac_autoload_eclipse_classpath = + \ get(g:, 'neomake_java_javac_autoload_eclipse_classpath', 1) + +let g:neomake_java_javac_maven_pom_ftime = + \ get(g:, 'neomake_java_javac_maven_pom_ftime', {}) + +let g:neomake_java_javac_maven_pom_classpath = + \ get(g:, 'neomake_java_javac_maven_pom_classpath', {}) + +let g:neomake_java_javac_gradle_ftime = + \ get(g:, 'neomake_java_javac_gradle_ftime', {}) + +let g:neomake_java_javac_gradle_classpath = + \ get(g:, 'neomake_java_javac_gradle_classpath', {}) + +let g:neomake_java_javac_ant_ftime = + \ get(g:, 'neomake_java_javac_ant_ftime', {}) + +let g:neomake_java_javac_ant_classpath = + \ get(g:, 'neomake_java_javac_ant_classpath', {}) + + +let s:has_maven = executable(expand(g:neomake_java_maven_executable, 1)) +let s:has_gradle = executable(expand(g:neomake_java_gradle_executable, 1)) +let s:has_ant = executable(expand(g:neomake_java_ant_executable, 1)) + +function! s:tmpdir() abort + let tempdir = tempname() + call mkdir(tempdir, 'p', 0700) + return tempdir +endfunction + +function! s:ClassSep() abort + return (s:is_windows || has('win32unix')) ? ';' : ':' +endfunction + +function! s:shescape(string) abort + return neomake#utils#shellescape(a:string) +endfunction + +function! s:AddToClasspath(classpath, path) abort + if a:path ==# '' + return a:classpath + endif + return (a:classpath !=# '') ? a:classpath . s:ClassSep() . a:path : a:path +endfunction + +" @vimlint(EVL103, 1, a:classpathFile) +function! s:ReadClassPathFile(classpathFile) abort + let cp = '' + let file = g:neomake_java_checker_home. s:psep. 'java'. s:psep. 'classpath.py' + if has('python3') + execute 'py3file' file + py3 import vim + py3 vim.command("let cp = '%s'" % os.pathsep.join(ReadClasspathFile(vim.eval('a:classpathFile'))).replace('\\', '/')) + elseif has('python') + execute 'pyfile' file + py import vim + py vim.command("let cp = '%s'" % os.pathsep.join(ReadClasspathFile(vim.eval('a:classpathFile'))).replace('\\', '/')) + endif + return cp +endfunction +" @vimlint(EVL103, 0, a:classpathFile) + +function! neomake#makers#ft#java#EnabledMakers() abort + let makers = [] + if executable(expand(g:neomake_java_javac_executable, 1)) + call add(makers, g:neomake_java_javac_executable) + endif + if executable(expand(g:neomake_java_checkstyle_executable, 1)) + call add(makers, g:neomake_java_checkstyle_executable) + endif + return makers +endfunction + +function! neomake#makers#ft#java#javac() abort + let javac_opts = extend([], g:neomake_java_javac_options) + + let output_dir = '' + if g:neomake_java_javac_delete_output + let output_dir = s:tmpdir() + let javac_opts = extend(javac_opts, ['-d', s:shescape(output_dir)]) + endif + + let javac_classpath = get(g:, 'neomake_java_javac_classpath', '') + + if s:has_maven && g:neomake_java_javac_autoload_maven_classpath && empty(javac_classpath) + if !g:neomake_java_javac_delete_output + let javac_opts = extend(javac_opts, ['-d', s:shescape(s:MavenOutputDirectory())]) + endif + let javac_classpath = s:AddToClasspath(javac_classpath, s:GetMavenClasspath()) + endif + + if s:has_gradle && g:neomake_java_javac_autoload_gradle_classpath && empty(javac_classpath) + if !g:neomake_java_javac_delete_output + let javac_opts = extend(javac_opts, ['-d', s:shescape(s:GradleOutputDirectory())]) + endif + let javac_classpath = s:AddToClasspath(javac_classpath, s:GetGradleClasspath()) + endif + + if s:has_ant && g:neomake_java_javac_autoload_ant_classpath && empty(javac_classpath) + let javac_classpath = s:AddToClasspath(javac_classpath, s:GetAntClasspath()) + endif + + if (has('python') || has('python3')) && empty(javac_classpath) + let classpathFile = fnamemodify(findfile('.classpath', escape(expand('.'), '*[]?{}, ') . ';'), ':p') + if !empty(classpathFile) && filereadable(classpathFile) + let javac_classpath = s:ReadClassPathFile(classpathFile) + endif + endif + + if javac_classpath !=# '' + let javac_opts = extend(javac_opts, ['-cp', javac_classpath]) + endif + + return { + \ 'args': javac_opts, + \ 'exe': g:neomake_java_javac_executable, + \ 'errorformat': + \ '%E%f:%l: error: %m,'. + \ '%W%f:%l: warning: %m,'. + \ '%E%f:%l: %m,'. + \ '%Z%p^,'. + \ '%-G%.%#', + \ 'version_arg': '-version' + \ } +endfunction + +function! neomake#makers#ft#java#checkstyle() abort + return { + \ 'args': ['-c', g:neomake_java_checkstyle_xml], + \ 'exe': g:neomake_java_checkstyle_executable, + \ 'errorformat': + \ '%-GStarting audit...,'. + \ '%-GAudit done.,'. + \ '%-GPicked up _JAVA_OPTIONS:%.%#,'. + \ '[%t%*[^]]] %f:%l:%c: %m [%s],'. + \ '[%t%*[^]]] %f:%l: %m [%s]', + \ 'version_arg': '-v' + \ } +endfunction + +function! s:findFileInParent(what, where) abort " {{{2 + let old_suffixesadd = &suffixesadd + let &suffixesadd = '' + let file = findfile(a:what, escape(a:where, ' ') . ';') + let &suffixesadd = old_suffixesadd + return file +endfunction " }}}2 + +function! s:GetMavenProperties() abort " {{{2 + let mvn_properties = {} + let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + if !has_key(g:neomake_java_javac_maven_pom_properties, pom) + let mvn_cmd = s:shescape(expand(g:neomake_java_maven_executable, 1)) . + \ ' -f ' . s:shescape(pom) . + \ ' ' . g:neomake_java_maven_options + let mvn_is_managed_tag = 1 + let mvn_settings_output = split(system(mvn_cmd . ' help:effective-pom'), "\n") + let current_path = 'project' + for line in mvn_settings_output + let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_is_managed_tag = index(g:neomake_java_javac_maven_pom_tags, matches[1]) >= 0 + let current_path .= '.' . matches[1] + else + let matches = matchlist(line, '\m^\s*\s*$') + if !empty(matches) + let mvn_is_managed_tag = index(g:neomake_java_javac_maven_pom_tags, matches[1]) < 0 + let current_path = substitute(current_path, '\m\.' . matches[1] . '$', '', '') + else + let matches = matchlist(line, '\m^\s*<\([a-zA-Z0-9\-\.]\+\)>\(.\+\)\s*$') + if mvn_is_managed_tag && !empty(matches) + let mvn_properties[current_path . '.' . matches[1]] = matches[2] + endif + endif + endif + endfor + let g:neomake_java_javac_maven_pom_properties[pom] = mvn_properties + endif + return g:neomake_java_javac_maven_pom_properties[pom] + endif + return mvn_properties +endfunction " }}}2 + +function! s:GetMavenClasspath() abort " {{{2 + let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + if !has_key(g:neomake_java_javac_maven_pom_ftime, pom) || g:neomake_java_javac_maven_pom_ftime[pom] != getftime(pom) + let mvn_cmd = s:shescape(expand(g:neomake_java_maven_executable, 1)) . + \ ' -f ' . s:shescape(pom) . + \ ' ' . g:neomake_java_maven_options + let mvn_classpath_output = split(system(mvn_cmd . ' dependency:build-classpath -DincludeScope=test'), "\n") + let mvn_classpath = '' + let class_path_next = 0 + + for line in mvn_classpath_output + if class_path_next == 1 + let mvn_classpath = substitute(line, "\r", '', 'g') + break + endif + if stridx(line, 'Dependencies classpath:') >= 0 + let class_path_next = 1 + endif + endfor + + let mvn_properties = s:GetMavenProperties() + + let output_dir = get(mvn_properties, 'project.build.outputDirectory', join(['target', 'classes'], s:psep)) + let mvn_classpath = s:AddToClasspath(mvn_classpath, output_dir) + + let test_output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join(['target', 'test-classes'], s:psep)) + let mvn_classpath = s:AddToClasspath(mvn_classpath, test_output_dir) + + let g:neomake_java_javac_maven_pom_ftime[pom] = getftime(pom) + let g:neomake_java_javac_maven_pom_classpath[pom] = mvn_classpath + endif + return g:neomake_java_javac_maven_pom_classpath[pom] + endif + return '' +endfunction " }}}2 + +function! s:MavenOutputDirectory() abort " {{{2 + let pom = s:findFileInParent('pom.xml', expand('%:p:h', 1)) + if s:has_maven && filereadable(pom) + let mvn_properties = s:GetMavenProperties() + let output_dir = get(mvn_properties, 'project.properties.build.dir', getcwd()) + + let src_main_dir = get(mvn_properties, 'project.build.sourceDirectory', join(['src', 'main', 'java'], s:psep)) + let src_test_dir = get(mvn_properties, 'project.build.testsourceDirectory', join(['src', 'test', 'java'], s:psep)) + if stridx(expand('%:p:h', 1), src_main_dir) >= 0 + let output_dir = get(mvn_properties, 'project.build.outputDirectory', join ([output_dir, 'target', 'classes'], s:psep)) + endif + if stridx(expand('%:p:h', 1), src_test_dir) >= 0 + let output_dir = get(mvn_properties, 'project.build.testOutputDirectory', join([output_dir, 'target', 'test-classes'], s:psep)) + endif + + if has('win32unix') + let output_dir = substitute(system('cygpath -m ' . s:shescape(output_dir)), "\n", '', 'g') + endif + return output_dir + endif + return '.' +endfunction " }}}2 + +function! s:GradleOutputDirectory() abort + let gradle_build = s:findFileInParent('build.gradle', expand('%:p:h', 1)) + let items = split(gradle_build, s:psep) + if len(items)==1 + return join(['build', 'intermediates', 'classes', 'debug'], s:psep) + endif + let outputdir = '' + for i in items + if i !=# 'build.gradle' + let outputdir .= i . s:psep + endif + endfor + return outputdir . join(['build', 'intermediates', 'classes', 'debug'], s:psep) +endf + +function! s:GetGradleClasspath() abort + let gradle = s:findFileInParent('build.gradle', expand('%:p:h', 1)) + if s:has_gradle && filereadable(gradle) + if !has_key(g:neomake_java_javac_gradle_ftime, gradle) || g:neomake_java_javac_gradle_ftime[gradle] != getftime(gradle) + try + let f = tempname() + if s:is_windows + let gradle_cmd = '.\gradlew.bat' + else + let gradle_cmd = './gradlew' + endif + call writefile(["allprojects{apply from: '" . g:neomake_java_checker_home . s:psep. 'java'. s:psep. "classpath.gradle'}"], f) + let ret = system(gradle_cmd . ' -q -I ' . shellescape(f) . ' classpath' ) + if v:shell_error == 0 + let cp = filter(split(ret, "\n"), "v:val =~# '^CLASSPATH:'")[0][10:] + if filereadable(getcwd() . s:psep . 'build.gradle') + let out_putdir = neomake#compat#globpath_list(getcwd(), join( + \ ['**', 'build', 'intermediates', 'classes', 'debug'], + \ s:psep), 0) + for classes in out_putdir + let cp .= s:ClassSep() . classes + endfor + endif + else + let cp = '' + endif + catch + finally + call delete(f) + endtry + let g:neomake_java_javac_gradle_ftime[gradle] = getftime(gradle) + let g:neomake_java_javac_gradle_classpath[gradle] = cp + endif + return g:neomake_java_javac_gradle_classpath[gradle] + endif + return '' +endf + +function! s:GetAntClasspath() abort + let ant = s:findFileInParent('build.xml', expand('%:p:h', 1)) + if s:has_ant && filereadable(ant) + if !has_key(g:neomake_java_javac_ant_ftime, ant) || g:neomake_java_javac_ant_ftime[ant] != getftime(ant) + try + let ant_cmd = 'ant classpath -f build.xml -S -q' + let cp = system(ant_cmd) + if v:shell_error != 0 + let cp = '' + endif + catch + endtry + let g:neomake_java_javac_ant_ftime[ant] = getftime(ant) + let g:neomake_java_javac_ant_classpath[ant] = cp + endif + return g:neomake_java_javac_ant_classpath[ant] + endif + return '' +endf + +let &cpoptions = s:save_cpo +unlet s:save_cpo +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/java/classpath.gradle b/.vim/autoload/neomake/makers/ft/java/classpath.gradle new file mode 100644 index 0000000..f548c0d --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/java/classpath.gradle @@ -0,0 +1,46 @@ +task classpath << { + + String finalFileContents = "" + HashSet classpathFiles = new HashSet() + for (proj in allprojects) { + + def exploded = proj.getBuildDir().absolutePath + File.separator + "intermediates" + File.separator + "exploded-aar" + def listFiles = new File(exploded) + if (listFiles.exists()) { + listFiles.eachFileRecurse(){ file -> + if (file.name.endsWith(".jar")){ + classpathFiles += file + } + } + } + + def rjava = proj.getBuildDir().absolutePath + File.separator + "intermediates" + File.separator + "classes" + File.separator + "debug" + def rFiles = new File(rjava) + if (rFiles.exists()) { + classpathFiles += rFiles + } + + for (conf in proj.configurations) { + for (dependency in conf) { + if (dependency.name.endsWith("aar")){ + } else { + classpathFiles += dependency + } + } + } + if (proj.hasProperty("android")){ + classpathFiles += proj.android.bootClasspath + } + + if (proj.hasProperty("sourceSets")) { + + for (srcSet in proj.sourceSets) { + for (dir in srcSet.java.srcDirs) { + classpathFiles += dir.absolutePath + } + } + } + } + def paths = classpathFiles.join(File.pathSeparator) + println "CLASSPATH:" + paths +} diff --git a/.vim/autoload/neomake/makers/ft/java/classpath.py b/.vim/autoload/neomake/makers/ft/java/classpath.py new file mode 100644 index 0000000..5a7ea8d --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/java/classpath.py @@ -0,0 +1,15 @@ +import os +from xml.etree.ElementTree import * + + +def ReadClasspathFile(fn): + cp = [] + for a in parse(fn).findall('classpathentry'): + kind = a.get('kind') + if kind == 'src' and 'output' in a.keys(): + cp.append(os.path.abspath(a.get('output'))) + elif kind == 'lib' and 'path' in a.keys(): + cp.append(os.path.abspath(a.get('path'))) + elif kind == 'output' and 'path' in a.keys(): + cp.append(os.path.abspath(a.get('path'))) + return cp diff --git a/.vim/autoload/neomake/makers/ft/javascript.vim b/.vim/autoload/neomake/makers/ft/javascript.vim new file mode 100644 index 0000000..7bb379f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/javascript.vim @@ -0,0 +1,119 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#javascript#EnabledMakers() abort + return ['jshint', 'jscs', + \ executable('eslint_d') ? 'eslint_d' : 'eslint', + \] +endfunction + +function! neomake#makers#ft#javascript#tsc() abort + return neomake#makers#ft#typescript#tsc() +endfunction + +function! neomake#makers#ft#javascript#gjslint() abort + return { + \ 'args': ['--nodebug_indentation', '--nosummary', '--unix_mode', '--nobeep'], + \ 'errorformat': '%f:%l:(New Error -%\\?\%n) %m,' . + \ '%f:%l:(-%\\?%n) %m,' . + \ '%-G1 files checked,' . + \ ' no errors found.,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#javascript#jshint() abort + return { + \ 'args': ['--verbose'], + \ 'errorformat': '%A%f: line %l\, col %v\, %m \(%t%*\d\),%-G,%-G%\\d%\\+ errors', + \ 'postprocess': function('neomake#postprocess#generic_length'), + \ } +endfunction + +function! neomake#makers#ft#javascript#jscs() abort + return { + \ 'args': ['--no-colors', '--reporter', 'inline'], + \ 'errorformat': '%E%f: line %l\, col %c\, %m', + \ } +endfunction + +function! neomake#makers#ft#javascript#eslint() abort + let maker = { + \ 'args': ['--format=compact'], + \ 'errorformat': '%E%f: line %l\, col %c\, Error - %m,' . + \ '%W%f: line %l\, col %c\, Warning - %m,%-G,%-G%*\d problems%#', + \ 'cwd': '%:p:h', + \ 'output_stream': 'stdout', + \ } + + function! maker.supports_stdin(_jobinfo) abort + let self.args += ['--stdin', '--stdin-filename=%:p'] + let self.tempfile_name = '' + return 1 + endfunction + + return maker +endfunction + +function! neomake#makers#ft#javascript#eslint_d() abort + return neomake#makers#ft#javascript#eslint() +endfunction + +function! neomake#makers#ft#javascript#standard() abort + return { + \ 'args': ['-v'], + \ 'errorformat': '%W %f:%l:%c: %m,%-Gstandard: %.%#' + \ } +endfunction + +function! neomake#makers#ft#javascript#semistandard() abort + return { + \ 'errorformat': '%W %f:%l:%c: %m' + \ } +endfunction + +function! neomake#makers#ft#javascript#rjsx() abort + return { + \ 'exe': 'emacs', + \ 'args': ['%t','--quick','--batch','--eval=' + \ .'(progn(setq package-load-list ''((js2-mode t)(rjsx-mode t)))(package-initialize)(require ''rjsx-mode)' + \ .' (setq js2-include-node-externs t js2-include-rhino-externs t js2-include-browser-externs t js2-strict-missing-semi-warning nil)' + \ .' (rjsx-mode)(js2-reparse)(js2-display-error-list)' + \ .' (princ(replace-regexp-in-string "^" (concat buffer-file-name " ")' + \ .' (with-current-buffer "*js-lint*" (buffer-substring-no-properties(point-min)(point-max)))))(terpri))'], + \ 'errorformat': '%f line %l: %m,%-G%.%#', + \ 'append_file': 0, + \ } +endfunction + +function! neomake#makers#ft#javascript#flow() abort + return { + \ 'args': ['--from=vim', '--show-all-errors'], + \ 'errorformat': + \ '%-GNo errors!,' + \ .'%EFile "%f"\, line %l\, characters %c-%m,' + \ .'%trror: File "%f"\, line %l\, characters %c-%m,' + \ .'%C%m,%Z', + \ 'postprocess': function('neomake#makers#ft#javascript#FlowProcess') + \ } +endfunction + +function! neomake#makers#ft#javascript#FlowProcess(entry) abort + let lines = split(a:entry.text, '\n') + if !empty(lines) + let a:entry.text = join(lines[1:]) + let a:entry.length = lines[0] - a:entry.col + 1 + endif +endfunction + +function! neomake#makers#ft#javascript#xo() abort + return { + \ 'args': ['--compact'], + \ 'errorformat': '%E%f: line %l\, col %c\, Error - %m,' . + \ '%W%f: line %l\, col %c\, Warning - %m', + \ } +endfunction + +function! neomake#makers#ft#javascript#stylelint() abort + return neomake#makers#ft#css#stylelint() +endfunction + diff --git a/.vim/autoload/neomake/makers/ft/json.vim b/.vim/autoload/neomake/makers/ft/json.vim new file mode 100644 index 0000000..89a38e0 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/json.vim @@ -0,0 +1,38 @@ +function! neomake#makers#ft#json#EnabledMakers() abort + return ['jsonlint'] +endfunction + +function! neomake#makers#ft#json#jsonlintpy() abort + return { + \ 'exe': 'jsonlint-py', + \ 'args': ['--strict'], + \ 'errorformat': + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,', + \ } +endfunction + +function! neomake#makers#ft#json#jsonlint() abort + return { + \ 'args': ['--compact'], + \ 'errorformat': + \ '%ELine %l:%c,'. + \ '%Z\\s%#Reason: %m,'. + \ '%C%.%#,'. + \ '%f: line %l\, col %c\, %m,'. + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#json#eslint() abort + let maker = neomake#makers#ft#javascript#eslint() + let maker.args += ['--plugin', 'json'] + return maker +endfunction + +function! neomake#makers#ft#json#eslint_d() abort + let maker = neomake#makers#ft#javascript#eslint_d() + let maker.args += ['--plugin', 'json'] + return maker +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/jsx.vim b/.vim/autoload/neomake/makers/ft/jsx.vim new file mode 100644 index 0000000..38d3cc3 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/jsx.vim @@ -0,0 +1,17 @@ +function! neomake#makers#ft#jsx#SupersetOf() abort + return 'javascript' +endfunction + +function! neomake#makers#ft#jsx#EnabledMakers() abort + return ['jshint', executable('eslint_d') ? 'eslint_d' : 'eslint'] +endfunction + +function! neomake#makers#ft#jsx#jsxhint() abort + return neomake#makers#ft#javascript#jshint() +endfunction + +function! neomake#makers#ft#jsx#stylelint() abort + return neomake#makers#ft#css#stylelint() +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/julia.vim b/.vim/autoload/neomake/makers/ft/julia.vim new file mode 100644 index 0000000..a6fed9f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/julia.vim @@ -0,0 +1,24 @@ +function! neomake#makers#ft#julia#EnabledMakers() abort + return ['lint'] +endfunction + +function! neomake#makers#ft#julia#lint() abort + return { +\ 'errorformat': '%f:%l %t%*[^ ] %m', +\ 'exe': 'julia', +\ 'args': ['-e', ' +\ try +\ using Lint +\ catch +\ println("$(basename(ARGS[1])):1 E999 Install Lint.jl: Pkg.add(""Lint"")"); +\ exit(1) +\ end; +\ r = lintfile(ARGS[1]); +\ if !isempty(r) +\ display(r); +\ exit(1) +\ end +\ '] +\ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/kotlin.vim b/.vim/autoload/neomake/makers/ft/kotlin.vim new file mode 100644 index 0000000..d7273e3 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/kotlin.vim @@ -0,0 +1,12 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#kotlin#EnabledMakers() abort + return ['ktlint'] +endfunction + +function! neomake#makers#ft#kotlin#ktlint() abort + return { + \ 'errorformat': '%E%f:%l:%c: %m', + \ } +endfunction + diff --git a/.vim/autoload/neomake/makers/ft/less.vim b/.vim/autoload/neomake/makers/ft/less.vim new file mode 100644 index 0000000..51ba941 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/less.vim @@ -0,0 +1,19 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#less#EnabledMakers() abort + return executable('stylelint') ? ['stylelint'] : ['lessc'] +endfunction + +function! neomake#makers#ft#less#lessc() abort + return { + \ 'args': ['--lint', '--no-color'], + \ 'errorformat': + \ '%m in %f on line %l\, column %c:,' . + \ '%m in %f:%l:%c,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#less#stylelint() abort + return neomake#makers#ft#css#stylelint() +endfunction diff --git a/.vim/autoload/neomake/makers/ft/lex.vim b/.vim/autoload/neomake/makers/ft/lex.vim new file mode 100644 index 0000000..7dafebf --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/lex.vim @@ -0,0 +1,11 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#lex#EnabledMakers() abort + return ['flex'] +endfunction + +function! neomake#makers#ft#lex#flex() abort + return { + \ 'errorformat': '%f:%l: %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/lua.vim b/.vim/autoload/neomake/makers/ft/lua.vim new file mode 100644 index 0000000..c0e6bce --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/lua.vim @@ -0,0 +1,33 @@ +function! neomake#makers#ft#lua#EnabledMakers() abort + return executable('luacheck') ? ['luacheck'] : ['luac'] +endfunction + +" luacheck: postprocess: use pattern (%s) for end column. +function! neomake#makers#ft#lua#PostprocessLuacheck(entry) abort + let end_col = matchstr(a:entry.pattern, '\v\d+') + if !empty(end_col) + let a:entry.length = end_col - a:entry.col + 1 + else + echom 'luacheck: no end_col: '.string(a:entry) + endif + let a:entry.pattern = '' +endfunction + +function! neomake#makers#ft#lua#luacheck() abort + " cwd: luacheck looks for .luacheckrc upwards from there. + return { + \ 'args': ['--no-color', '--formatter=plain', '--ranges', '--codes', '--filename', '%:p'], + \ 'cwd': '%:p:h', + \ 'errorformat': '%E%f:%l:%c-%s: \(%t%n\) %m', + \ 'postprocess': function('neomake#makers#ft#lua#PostprocessLuacheck'), + \ 'supports_stdin': 1, + \ } +endfunction + +function! neomake#makers#ft#lua#luac() abort + return { + \ 'args': ['-p'], + \ 'errorformat': '%*\f: %#%f:%l: %m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/mail.vim b/.vim/autoload/neomake/makers/ft/mail.vim new file mode 100644 index 0000000..54cd09e --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/mail.vim @@ -0,0 +1,8 @@ +function! neomake#makers#ft#mail#EnabledMakers() abort + return ['proselint'] +endfunction + +function! neomake#makers#ft#mail#proselint() abort + return neomake#makers#ft#text#proselint() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/markdown.vim b/.vim/autoload/neomake/makers/ft/markdown.vim new file mode 100644 index 0000000..1146488 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/markdown.vim @@ -0,0 +1,97 @@ +function! neomake#makers#ft#markdown#SupersetOf() abort + return 'text' +endfunction + +function! neomake#makers#ft#markdown#EnabledMakers() abort + let makers = executable('mdl') ? ['mdl'] : ['markdownlint'] + if executable('vale') | let makers += ['vale'] | endif + return makers + neomake#makers#ft#text#EnabledMakers() +endfunction + +function! neomake#makers#ft#markdown#mdl() abort + let maker = { + \ + \ 'errorformat': + \ '%W%f:%l: %m,%-G%.%#', + \ 'output_stream': 'stdout', + \ } + function! maker.postprocess(entry) abort + if a:entry.text[0:1] ==# 'MD' + let [code, text] = split(a:entry.text, '\v^MD\d+\zs ') + let a:entry.nr = str2nr(code[2:]) + let a:entry.text = printf('%s (%s)', text, code) + endif + return a:entry + endfunction + return maker +endfunction + +function! neomake#makers#ft#markdown#markdownlint() abort + return { + \ 'errorformat': '%f: %l: %m' + \ } +endfunction + +let s:alex_supports_stdin = {} +function! neomake#makers#ft#markdown#alex() abort + let maker = { + \ 'errorformat': + \ '%P%f,' + \ .'%-Q,' + \ .'%*[ ]%l:%c-%*\d:%n%*[ ]%tarning%*[ ]%m,' + \ .'%-G%.%#' + \ } + + function! maker.supports_stdin(_jobinfo) abort + let exe = exists('*exepath') ? exepath(self.exe) : self.exe + let support = get(s:alex_supports_stdin, exe, -1) + if support == -1 + let ver = neomake#compat#systemlist(['alex', '--version']) + let ver_split = split(ver[0], '\.') + if len(ver_split) > 1 && (ver_split[0] > 0 || +ver_split[1] >= 6) + let support = 1 + else + let support = 0 + endif + let s:alex_supports_stdin[exe] = support + call neomake#log#debug('alex: stdin support: '.support.'.') + endif + if support + let self.args += ['--stdin'] + let self.tempfile_name = '' + endif + return support + endfunction + + return maker +endfunction + +function! neomake#makers#ft#markdown#ProcessVale(context) abort + let entries = [] + for [filename, items] in items(a:context['json']) + for data in items + let entry = { + \ 'maker_name': 'vale', + \ 'filename': filename, + \ 'text': data.Message, + \ 'lnum': data.Line, + \ 'col': data.Span[0], + \ 'length': data.Span[1] - data.Span[0] + 1, + \ 'type': toupper(data.Severity[0]) + \ } + call add(entries, entry) + endfor + endfor + return entries +endfunction + +function! neomake#makers#ft#markdown#vale() abort + return { + \ 'args': [ + \ '--no-wrap', + \ '--output', 'JSON' + \ ], + \ 'process_json': function('neomake#makers#ft#markdown#ProcessVale') + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/matlab.vim b/.vim/autoload/neomake/makers/ft/matlab.vim new file mode 100644 index 0000000..f208be6 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/matlab.vim @@ -0,0 +1,15 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#matlab#EnabledMakers() abort + return ['mlint'] +endfunction + +function! neomake#makers#ft#matlab#mlint() abort + return { + \ 'args': ['-id'], + \ 'mapexpr': "neomake_bufname.':'.v:val", + \ 'errorformat': + \ '%f:L %l (C %c): %m,'. + \ '%f:L %l (C %c-%*[0-9]): %m,', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/moon.vim b/.vim/autoload/neomake/makers/ft/moon.vim new file mode 100644 index 0000000..486bea7 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/moon.vim @@ -0,0 +1,15 @@ +function! neomake#makers#ft#moon#EnabledMakers() abort + return ['moonc'] +endfunction + +function! neomake#makers#ft#moon#moonc() abort + return { + \ 'args': ['-l'], + \ 'errorformat': + \ '%-G,' . + \ '%-G>%#,' . + \ '%+P%f,'. + \ 'line\ %l:\ %m' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/neomake_tests.vim b/.vim/autoload/neomake/makers/ft/neomake_tests.vim new file mode 100644 index 0000000..4d06e7a --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/neomake_tests.vim @@ -0,0 +1,58 @@ +if !exists('g:neomake_test_messages') + " Only use it during tests. + finish +endif + +function! neomake#makers#ft#neomake_tests#EnabledMakers() abort + return get(b:, 'neomake_test_enabledmakers', + \ get(g:, 'neomake_test_enabledmakers', + \ ['maker_without_exe', 'nonexisting'])) +endfunction + +function! neomake#makers#ft#neomake_tests#maker_without_exe() abort + return {} +endfunction + +function! neomake#makers#ft#neomake_tests#maker_with_nonstring_exe() abort + return {'exe': function('tr')} +endfunction + +function! neomake#makers#ft#neomake_tests#echo_maker() abort + return { + \ 'exe': 'printf', + \ 'args': 'neomake_tests_echo_maker', + \ 'errorformat': '%m', + \ 'append_file': 0, + \ } +endfunction + +function! neomake#makers#ft#neomake_tests#echo_args() abort + return { + \ 'exe': 'echo', + \ 'errorformat': '%m', + \ } +endfunction + +function! neomake#makers#ft#neomake_tests#true() abort + return {} +endfunction + +function! neomake#makers#ft#neomake_tests#error_maker() abort + return { + \ 'exe': 'printf', + \ 'args': ['%s:1:error_msg_1'], + \ 'errorformat': '%E%f:%l:%m', + \ 'append_file': 1, + \ 'short_name': 'errmkr', + \ } +endfunction + +function! neomake#makers#ft#neomake_tests#process_output_error() abort + let maker = {'exe': 'echo', 'args': 'output', 'append_file': 0} + + function! maker.process_output(...) abort + return [{'valid': 1, 'text': 'error', 'lnum': 1, 'bufnr': bufnr('%')}] + endfunction + return maker +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/nim.vim b/.vim/autoload/neomake/makers/ft/nim.vim new file mode 100644 index 0000000..68b72a3 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/nim.vim @@ -0,0 +1,16 @@ +function! neomake#makers#ft#nim#EnabledMakers() abort + return ['nim'] +endfunction + +function! neomake#makers#ft#nim#nim() abort + return { + \ 'exe': 'nim', + \ 'args': ['--listFullPaths', '--verbosity:0', '--colors:off', + \ '-c', 'check'], + \ 'errorformat': + \ '%I%f(%l\, %c) Hint: %m,' . + \ '%W%f(%l\, %c) Warning: %m,' . + \ '%E%f(%l\, %c) Error: %m' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/nix.vim b/.vim/autoload/neomake/makers/ft/nix.vim new file mode 100644 index 0000000..f239789 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/nix.vim @@ -0,0 +1,14 @@ +" vim: ts=4 sw=4 et +" +function! neomake#makers#ft#nix#EnabledMakers() abort + return ['nix_instantiate'] +endfunction + +function! neomake#makers#ft#nix#nix_instantiate() abort + return { + \ 'exe': 'nix-instantiate', + \ 'args': ['--parse-only'], + \ 'errorformat': 'error: %m at %f:%l:%c' + \ } +endfunction + diff --git a/.vim/autoload/neomake/makers/ft/node.vim b/.vim/autoload/neomake/makers/ft/node.vim new file mode 100644 index 0000000..a6cd321 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/node.vim @@ -0,0 +1,9 @@ +function! neomake#makers#ft#node#SupersetOf() abort + return 'javascript' +endfunction + +function! neomake#makers#ft#node#EnabledMakers() abort + return ['jshint', 'eslint', 'jscs'] +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/objc.vim b/.vim/autoload/neomake/makers/ft/objc.vim new file mode 100644 index 0000000..5b093f4 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/objc.vim @@ -0,0 +1,55 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#objc#EnabledMakers() abort + let makers = ['clang', 'clangtidy', 'clangcheck'] + return makers +endfunction + +function! neomake#makers#ft#objc#clang() abort + " We will enable ARC and disable warnings about unused parameters because + " it is quite common in Cocoa not to use every method parameter. + return { + \ 'args': ['-fsyntax-only', '-fobjc-arc', '-Wall', '-Wextra', '-Wno-unused-parameter'], + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%I%f:%l:%c: note: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%I%f:%l: note: %m,'. + \ '%f:%l: %m' + \ } +endfunction + +" The -p option followed by the path to the build directory should be set in +" the maker's arguments. That directory should contain the compile command +" database (compile_commands.json). +function! neomake#makers#ft#objc#clangtidy() abort + return { + \ 'exe': 'clang-tidy', + \ 'errorformat': + \ '%E%f:%l:%c: fatal error: %m,' . + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%-G%\m%\%%(LLVM ERROR:%\|No compilation database found%\)%\@!%.%#,' . + \ '%E%m', + \ } +endfunction + +function! neomake#makers#ft#objc#clangcheck() abort + return { + \ 'exe': 'clang-check', + \ 'errorformat': + \ '%-G%f:%s:,' . + \ '%f:%l:%c: %trror: %m,' . + \ '%f:%l:%c: %tarning: %m,' . + \ '%I%f:%l:%c: note: %m,' . + \ '%f:%l:%c: %m,'. + \ '%f:%l: %trror: %m,'. + \ '%f:%l: %tarning: %m,'. + \ '%I%f:%l: note: %m,'. + \ '%f:%l: %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/pandoc.vim b/.vim/autoload/neomake/makers/ft/pandoc.vim new file mode 100644 index 0000000..ae56b04 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/pandoc.vim @@ -0,0 +1,8 @@ +function! neomake#makers#ft#pandoc#SupersetOf() abort + return 'markdown' +endfunction + +function! neomake#makers#ft#pandoc#EnabledMakers() abort + return neomake#makers#ft#markdown#EnabledMakers() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/perl.vim b/.vim/autoload/neomake/makers/ft/perl.vim new file mode 100644 index 0000000..da07694 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/perl.vim @@ -0,0 +1,34 @@ +" vim: ts=4 sw=4 et +function! neomake#makers#ft#perl#EnabledMakers() abort + return ['perl', 'perlcritic'] +endfunction + +function! neomake#makers#ft#perl#perlcritic() abort + return { + \ 'args' : ['--quiet', '--nocolor', '--verbose', + \ '\\%f:\\%l:\\%c:(\\%s) \\%m (\\%e)\\n'], + \ 'errorformat': '%f:%l:%c:%m,' + \} +endfunction + +function! neomake#makers#ft#perl#perl() abort + return { + \ 'args' : ['-c', '-X', '-Mwarnings'], + \ 'errorformat': '%-G%.%#had too many errors.,' + \ . '%-G%.%#had compilation errors.,' + \ . '%-G%.%#syntax OK,' + \ . '%m at %f line %l.,' + \ . '%+E%.%# at %f line %l\,%.%#,' + \ . '%+C%.%#', + \ 'postprocess': function('neomake#makers#ft#perl#PerlEntryProcess'), + \} +endfunction + +function! neomake#makers#ft#perl#PerlEntryProcess(entry) abort + let extramsg = substitute(a:entry.pattern, '\^\\V', '', '') + let extramsg = substitute(extramsg, '\\\$', '', '') + + if !empty(extramsg) + let a:entry.text .= ' ' . extramsg + endif +endfunction diff --git a/.vim/autoload/neomake/makers/ft/php.vim b/.vim/autoload/neomake/makers/ft/php.vim new file mode 100644 index 0000000..7edefa3 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/php.vim @@ -0,0 +1,72 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#php#EnabledMakers() abort + return ['php', 'phpmd', 'phpcs', 'phpstan'] +endfunction + +function! neomake#makers#ft#php#php() abort + return { + \ 'args': ['-l', '-d', 'display_errors=1', '-d', 'log_errors=0', + \ '-d', 'xdebug.cli_color=0'], + \ 'errorformat': + \ '%-GNo syntax errors detected in%.%#,'. + \ '%EParse error: %#syntax error\, %m in %f on line %l,'. + \ '%EParse error: %m in %f on line %l,'. + \ '%EFatal error: %m in %f on line %l,'. + \ '%-G\s%#,'. + \ '%-GErrors parsing %.%#', + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#php#phpcs() abort + let args = ['--report=csv', '-q'] + + "Add standard argument if one is set. + if exists('g:neomake_php_phpcs_args_standard') + call add(args, '--standard=' . expand(g:neomake_php_phpcs_args_standard)) + endif + + return { + \ 'args': args, + \ 'errorformat': + \ '%-GFile\,Line\,Column\,Type\,Message\,Source\,Severity%.%#,'. + \ '"%f"\,%l\,%c\,%t%*[a-zA-Z]\,"%m"\,%*[a-zA-Z0-9_.-]\,%*[0-9]%.%#', + \ } +endfunction + +function! neomake#makers#ft#php#phpmd() abort + return { + \ 'args': ['%t', 'text', 'codesize,design,unusedcode,naming'], + \ 'append_file': 0, + \ 'errorformat': '%W%f:%l%\s%\s%#%m' + \ } +endfunction + +function! neomake#makers#ft#php#phpstan() abort + " PHPStan normally considers 0 to be the default level, so that is used here as the default: + let maker = { + \ 'args': ['analyse', '--error-format', 'raw', '--no-progress', '--level', get(g:, 'neomake_phpstan_level', 0)], + \ 'errorformat': '%E%f:%l:%m', + \ } + " Check for the existence of a default PHPStan project configuration file. + " Technically PHPStan does not have a concept of a default filename for a + " project configuration file, but phpstan.neon is the filename shown in the + " example in the PHPStan documentation, so this is the default name expected + " by Neomake. + let phpStanConfigFilePath = neomake#utils#FindGlobFile('phpstan.neon') + if !empty(phpStanConfigFilePath) + call extend(maker.args, ['-c', phpStanConfigFilePath]) + endif + return maker +endfunction + +function! neomake#makers#ft#php#psalm() abort + let maker = { + \ 'args': [ + \ '--output-format=pylint' + \ ], + \ 'errorformat': '%A%f:%l:%\s[%t%n]%\s%m', + \ } + return maker +endfunction diff --git a/.vim/autoload/neomake/makers/ft/proto.vim b/.vim/autoload/neomake/makers/ft/proto.vim new file mode 100644 index 0000000..fcff577 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/proto.vim @@ -0,0 +1,12 @@ +function! neomake#makers#ft#proto#EnabledMakers() abort + return ['prototool'] +endfunction + +function! neomake#makers#ft#proto#prototool() abort + return { + \ 'exe': 'prototool', + \ 'args': ['lint'], + \ 'errorformat': '%f:%l:%c:%m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/pug.vim b/.vim/autoload/neomake/makers/ft/pug.vim new file mode 100644 index 0000000..53f2214 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/pug.vim @@ -0,0 +1,13 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#pug#EnabledMakers() abort + return ['puglint'] +endfunction + +function! neomake#makers#ft#pug#puglint() abort + return { + \ 'exe': 'pug-lint', + \ 'args': ['--reporter', 'inline'], + \ 'errorformat': '%f:%l:%c %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/puppet.vim b/.vim/autoload/neomake/makers/ft/puppet.vim new file mode 100644 index 0000000..c7a467d --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/puppet.vim @@ -0,0 +1,29 @@ +function! neomake#makers#ft#puppet#EnabledMakers() abort + return ['puppet', 'puppetlint'] +endfunction + +function! neomake#makers#ft#puppet#puppetlint() abort + return { + \ 'exe': 'puppet-lint', + \ 'args': ['--log-format', '%%{path}:%%{line}:%%{column}:%%{kind}:[%%{check}] %%{message}'], + \ 'errorformat': '%f:%l:%c:%t%*[a-zA-Z]:%m', + \ 'short_name': 'pupl', + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#puppet#puppet() abort + return { + \ 'args': ['parser', 'validate', '--color=false'], + \ 'errorformat': + \ '%-Gerr: Try ''puppet help parser validate'' for usage,' . + \ '%-GError: Try ''puppet help parser validate'' for usage,' . + \ '%t%*[a-zA-Z]: %m at %f:%l:%c,' . + \ '%t%*[a-zA-Z]: %m at %f:%l,'. + \ '%t%*[a-zA-Z]: Could not parse for environment production: %m (file: %f\, line: %l\, column: %c),' . + \ '%t%*[a-zA-Z]: Could not parse for environment production: %m (file: %f)', + \ 'short_name': 'pupp', + \ 'output_stream': 'stderr', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/purescript.vim b/.vim/autoload/neomake/makers/ft/purescript.vim new file mode 100644 index 0000000..a26a40f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/purescript.vim @@ -0,0 +1,63 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#purescript#EnabledMakers() abort + return ['pulp'] +endfunction + +function! neomake#makers#ft#purescript#pulp() abort + " command is `pulp build --no-psa -- --json-errors` + " as indicated in https://github.com/nwolverson/atom-ide-purescript/issues/136 + let maker = { + \ 'args': ['build', '--no-psa', '--', '--json-errors'], + \ 'append_file': 0, + \ 'process_output': function('neomake#makers#ft#purescript#PSProcessOutput'), + \ } + + " Find project root, since files are reported relative to it. + let bower_file = neomake#utils#FindGlobFile('bower.json') + if !empty(bower_file) + let maker.cwd = fnamemodify(bower_file, ':h') + endif + + return maker +endfunction + +function! neomake#makers#ft#purescript#PSProcessOutput(context) abort + let errors = [] + for line in a:context.output + if line[0] !=# '{' + continue + endif + let decoded = neomake#compat#json_decode(line) + for [key, values] in items(decoded) + let code = key ==# 'warnings' ? 'W' : 'E' + for item in values + let compiler_error = item['errorCode'] + let message = item['message'] + let position = item['position'] + let filename = item['filename'] + if position is g:neomake#compat#json_null + let row = 1 + let col = 1 + let end_col = 1 + let length = 1 + else + let row = position['startLine'] + let col = position['startColumn'] + let end_col = position['endColumn'] + let length = end_col - col + endif + + call add(errors, { + \ 'text': compiler_error . ' : ' . message, + \ 'type': code, + \ 'lnum': row, + \ 'col': col, + \ 'length': length, + \ 'filename': filename, + \ }) + endfor + endfor + endfor + return errors +endfunction diff --git a/.vim/autoload/neomake/makers/ft/python.vim b/.vim/autoload/neomake/makers/ft/python.vim new file mode 100644 index 0000000..d8c8369 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/python.vim @@ -0,0 +1,419 @@ +" vim: ts=4 sw=4 et + +if !exists('s:compile_script') + let s:slash = neomake#utils#Slash() + let s:compile_script = expand(':p:h', 1).s:slash.'python'.s:slash.'compile.py' +endif + +function! neomake#makers#ft#python#EnabledMakers() abort + let makers = ['python', 'frosted'] + if executable('pylama') + call add(makers, 'pylama') + else + if executable('flake8') + call add(makers, 'flake8') + else + call extend(makers, ['pyflakes', 'pycodestyle', 'pydocstyle']) + endif + call add(makers, 'pylint') " Last because it is the slowest + endif + return makers +endfunction + +let neomake#makers#ft#python#project_root_files = ['setup.cfg', 'tox.ini'] + +function! neomake#makers#ft#python#DetectPythonVersion() abort + let output = neomake#compat#systemlist('python -V 2>&1') + if v:shell_error + call neomake#log#error(printf( + \ 'Failed to detect Python version: %s.', + \ join(output))) + let s:python_version = [-1, -1, -1] + else + let s:python_version = split(split(output[0])[1], '\.') + endif +endfunction + +let s:ignore_python_warnings = [ + \ '\v[\/]inspect.py:\d+: Warning:', + \ '\v^.{-}:\d+: FutureWarning:', + \ ] + +" Filter Python warnings (the warning and the following line). +" To be used as a funcref with filter(). +function! s:filter_py_warning(v) abort + if s:filter_next_py_warning + let s:filter_next_py_warning = 0 + " Only keep (expected) lines starting with two spaces. + return a:v[0:1] !=# ' ' + endif + for pattern in s:ignore_python_warnings + if a:v =~# pattern + let s:filter_next_py_warning = 1 + return 0 + endif + endfor + return 1 +endfunction + +function! neomake#makers#ft#python#FilterPythonWarnings(lines, context) abort + if a:context.source ==# 'stderr' + let s:filter_next_py_warning = 0 + call filter(a:lines, 's:filter_py_warning(v:val)') + endif +endfunction + +function! neomake#makers#ft#python#pylint() abort + let maker = { + \ 'args': [ + \ '--output-format=text', + \ '--msg-template="{path}:{line}:{column}:{C}: [{symbol}] {msg} [{msg_id}]"', + \ '--reports=no' + \ ], + \ 'errorformat': + \ '%A%f:%l:%c:%t: %m,' . + \ '%A%f:%l: %m,' . + \ '%A%f:(%l): %m,' . + \ '%-Z%p^%.%#,' . + \ '%-G%.%#', + \ 'output_stream': 'stdout', + \ 'postprocess': [ + \ function('neomake#postprocess#generic_length'), + \ function('neomake#makers#ft#python#PylintEntryProcess'), + \ ]} + function! maker.filter_output(lines, context) abort + if a:context.source ==# 'stderr' + call filter(a:lines, "v:val !=# 'No config file found, using default configuration' && v:val !~# '^Using config file '") + endif + call neomake#makers#ft#python#FilterPythonWarnings(a:lines, a:context) + endfunction + return maker +endfunction + +function! neomake#makers#ft#python#PylintEntryProcess(entry) abort + if a:entry.type ==# 'F' " Fatal error which prevented further processing + let type = 'E' + elseif a:entry.type ==# 'E' " Error for important programming issues + let type = 'E' + elseif a:entry.type ==# 'W' " Warning for stylistic or minor programming issues + let type = 'W' + elseif a:entry.type ==# 'R' " Refactor suggestion + let type = 'W' + elseif a:entry.type ==# 'C' " Convention violation + let type = 'W' + elseif a:entry.type ==# 'I' " Informations + let type = 'I' + else + let type = '' + endif + let a:entry.type = type + " Pylint uses 0-indexed columns, vim uses 1-indexed columns + let a:entry.col += 1 +endfunction + +function! neomake#makers#ft#python#flake8() abort + let maker = { + \ 'args': ['--format=default'], + \ 'errorformat': + \ '%E%f:%l: could not compile,%-Z%p^,' . + \ '%A%f:%l:%c: %t%n %m,' . + \ '%A%f:%l: %t%n %m,' . + \ '%-G%.%#', + \ 'postprocess': function('neomake#makers#ft#python#Flake8EntryProcess'), + \ 'short_name': 'fl8', + \ 'output_stream': 'stdout', + \ 'filter_output': function('neomake#makers#ft#python#FilterPythonWarnings'), + \ } + + function! maker.supports_stdin(jobinfo) abort + let self.args += ['--stdin-display-name', '%:p'] + + let bufpath = bufname(a:jobinfo.bufnr) + if !empty(bufpath) + let bufdir = fnamemodify(bufpath, ':p:h') + if stridx(bufdir, getcwd()) != 0 + " The buffer is not below the current dir, so let's cd for lookup + " of config files etc. + " This avoids running into issues with flake8's per-file-ignores, + " which is handled not relative to the config file currently + " (https://gitlab.com/pycqa/flake8/issues/517). + call a:jobinfo.cd(bufdir) + endif + endif + return 1 + endfunction + return maker +endfunction + +function! neomake#makers#ft#python#Flake8EntryProcess(entry) abort + if a:entry.type ==# 'F' " pyflakes + " Ref: http://flake8.pycqa.org/en/latest/user/error-codes.html + if a:entry.nr > 400 && a:entry.nr < 500 + if a:entry.nr == 407 + let type = 'E' " 'an undefined __future__ feature name was imported' + else + let type = 'W' + endif + elseif a:entry.nr == 841 + let type = 'W' + else + let type = 'E' + endif + elseif a:entry.type ==# 'E' && a:entry.nr >= 900 " PEP8 runtime errors (E901, E902) + let type = 'E' + elseif a:entry.type ==# 'E' || a:entry.type ==# 'W' " PEP8 errors & warnings + let type = 'W' + elseif a:entry.type ==# 'N' || a:entry.type ==# 'D' " Naming (PEP8) & docstring (PEP257) conventions + let type = 'W' + elseif a:entry.type ==# 'C' || a:entry.type ==# 'T' " McCabe complexity & todo notes + let type = 'I' + elseif a:entry.type ==# 'I' " keep at least 'I' from isort (I1), could get style subtype?! + let type = a:entry.type + else + let type = '' + endif + + let token_pattern = '\v''\zs[^'']+\ze' + if a:entry.type ==# 'F' && (a:entry.nr == 401 || a:entry.nr == 811) + " Special handling for F401 (``module`` imported but unused) and + " F811 (redefinition of unused ``name`` from line ``N``). + " The unused column is incorrect for import errors and redefinition + " errors. + let token = matchstr(a:entry.text, token_pattern) + if !empty(token) + let view = winsaveview() + call cursor(a:entry.lnum, a:entry.col) + " The number of lines to give up searching afterwards + let search_lines = 5 + + if searchpos('\', 'cnW', a:entry.lnum)[1] == a:entry.col + " for 'from xxx.yyy import zzz' the token looks like + " xxx.yyy.zzz, but only the zzz part should be highlighted. So + " this discards the module part + let token = split(token, '\.')[-1] + + " Also the search should be started at the import keyword. + " Otherwise for 'from os import os' the first os will be + " found. This moves the cursor there. + call search('\', 'cW', a:entry.lnum + search_lines) + endif + + " Search for the first occurrence of the token and highlight in + " the next couple of lines and change the lnum and col to that + " position. + " Don't match entries surrounded by dots, even though + " it ends a word, we want to find a full identifier. It also + " matches all seperators such as spaces and newlines with + " backslashes until it knows for sure the previous real character + " was not a dot. + let ident_pos = searchpos('\(\.\(\_s\|\\\)*\)\@\(\(\_s\|\\\)*\.\)\@!', + \ 'cnW', + \ a:entry.lnum + search_lines) + if ident_pos[1] > 0 + let a:entry.lnum = ident_pos[0] + let a:entry.col = ident_pos[1] + endif + + call winrestview(view) + + let a:entry.length = strlen(token) + endif + else + call neomake#postprocess#generic_length_with_pattern(a:entry, token_pattern) + + " Special processing for F821 (undefined name) in f-strings. + if !has_key(a:entry, 'length') && a:entry.type ==# 'F' && a:entry.nr == 821 + let token = matchstr(a:entry.text, token_pattern) + if !empty(token) + " Search for '{token}' in reported and following lines. + " It seems like for the first line it is correct already (i.e. + " flake8 reports the column therein), but we still test there + " to be sure. + " https://gitlab.com/pycqa/flake8/issues/407 + let line = get(getbufline(a:entry.bufnr, a:entry.lnum), 0, '') + " NOTE: uses byte offset, starting at col means to start after + " the opening quote. + let pattern = '\V\C{\.\{-}\zs'.escape(token, '\').'\>' + let pos = match(line, pattern, a:entry.col) + if pos == -1 + let line_offset = 0 + while line_offset < 10 + let line_offset += 1 + let line = get(getbufline(a:entry.bufnr, a:entry.lnum + line_offset), 0, '') + let pos = match(line, pattern) + if pos != -1 + let a:entry.lnum = a:entry.lnum + line_offset + break + endif + endwhile + endif + if pos > 0 + let a:entry.col = pos + 1 + let a:entry.length = strlen(token) + endif + endif + endif + endif + + let a:entry.text = a:entry.type . a:entry.nr . ' ' . a:entry.text + let a:entry.type = type + " Reset "nr" to Avoid redundancy with neomake#GetCurrentErrorMsg. + " TODO: This is rather bad, since "nr" itself can be useful. + " This should rather use the entry via Neomake's list, and then a + " new property like "current_error_text" could be used. + " Or with the maker being available a callback could be used. + let a:entry.nr = -1 +endfunction + +function! neomake#makers#ft#python#pyflakes() abort + return { + \ 'errorformat': + \ '%E%f:%l: could not compile,' . + \ '%-Z%p^,'. + \ '%E%f:%l:%c: %m,' . + \ '%E%f:%l: %m,' . + \ '%-G%.%#', + \ } +endfunction + +function! neomake#makers#ft#python#pycodestyle() abort + if !exists('s:_pycodestyle_exe') + " Use the preferred exe to avoid deprecation warnings. + let s:_pycodestyle_exe = executable('pycodestyle') ? 'pycodestyle' : 'pep8' + endif + return { + \ 'exe': s:_pycodestyle_exe, + \ 'errorformat': '%f:%l:%c: %m', + \ 'postprocess': function('neomake#makers#ft#python#Pep8EntryProcess') + \ } +endfunction + +" Note: pep8 has been renamed to pycodestyle, but is kept also as alias. +function! neomake#makers#ft#python#pep8() abort + return neomake#makers#ft#python#pycodestyle() +endfunction + +function! neomake#makers#ft#python#Pep8EntryProcess(entry) abort + if a:entry.text =~# '^E9' " PEP8 runtime errors (E901, E902) + let a:entry.type = 'E' + elseif a:entry.text =~# '^E113' " unexpected indentation (IndentationError) + let a:entry.type = 'E' + else " Everything else is a warning + let a:entry.type = 'W' + endif +endfunction + +function! neomake#makers#ft#python#pydocstyle() abort + if !exists('s:_pydocstyle_exe') + " Use the preferred exe to avoid deprecation warnings. + let s:_pydocstyle_exe = executable('pydocstyle') ? 'pydocstyle' : 'pep257' + endif + return { + \ 'exe': s:_pydocstyle_exe, + \ 'errorformat': + \ '%W%f:%l %.%#:,' . + \ '%+C %m', + \ 'postprocess': function('neomake#postprocess#compress_whitespace'), + \ } +endfunction + +" Note: pep257 has been renamed to pydocstyle, but is kept also as alias. +function! neomake#makers#ft#python#pep257() abort + return neomake#makers#ft#python#pydocstyle() +endfunction + +function! neomake#makers#ft#python#PylamaEntryProcess(entry) abort + if a:entry.nr == -1 + " Get number from the beginning of text. + let nr = matchstr(a:entry.text, '\v^\u\zs\d+') + if !empty(nr) + let a:entry.nr = nr + 0 + endif + endif + if a:entry.type ==# 'C' && a:entry.text =~# '\v\[%(pycodestyle|pep8)\]$' + call neomake#makers#ft#python#Pep8EntryProcess(a:entry) + elseif a:entry.type ==# 'D' " pydocstyle/pep257 + let a:entry.type = 'W' + elseif a:entry.type ==# 'C' && a:entry.nr == 901 " mccabe + let a:entry.type = 'I' + elseif a:entry.type ==# 'R' " Radon + let a:entry.type = 'W' + endif +endfunction + +function! neomake#makers#ft#python#pylama() abort + let maker = { + \ 'args': ['--format', 'parsable'], + \ 'errorformat': '%f:%l:%c: [%t] %m', + \ 'postprocess': function('neomake#makers#ft#python#PylamaEntryProcess'), + \ 'output_stream': 'stdout', + \ } + " Pylama looks for the config only in the current directory. + " Therefore we change to where the config likely is. + " --options could be used to pass a config file, but we cannot be sure + " which one really gets used. + let ini_file = neomake#utils#FindGlobFile('{pylama.ini,setup.cfg,tox.ini,pytest.ini}') + if !empty(ini_file) + let maker.cwd = fnamemodify(ini_file, ':h') + endif + return maker +endfunction + +function! neomake#makers#ft#python#python() abort + return { + \ 'args': [s:compile_script], + \ 'errorformat': '%E%f:%l:%c: %m', + \ 'serialize': 1, + \ 'serialize_abort_on_error': 1, + \ 'output_stream': 'stdout', + \ 'short_name': 'py', + \ } +endfunction + +function! neomake#makers#ft#python#frosted() abort + return { + \ 'args': [ + \ '-vb' + \ ], + \ 'errorformat': + \ '%f:%l:%c:%m,' . + \ '%E%f:%l: %m,' . + \ '%-Z%p^,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#python#vulture() abort + return { + \ 'errorformat': '%f:%l: %m', + \ } +endfunction + +" --fast-parser: adds experimental support for async/await syntax +" --silent-imports: replaced by --ignore-missing-imports +function! neomake#makers#ft#python#mypy() abort + let args = ['--check-untyped-defs', '--ignore-missing-imports'] + + " Append '--py2' to args with Python 2 for Python 2 mode. + if !exists('s:python_version') + call neomake#makers#ft#python#DetectPythonVersion() + endif + if s:python_version[0] ==# '2' + call add(args, '--py2') + endif + + return { + \ 'args': args, + \ 'errorformat': + \ '%E%f:%l: error: %m,' . + \ '%W%f:%l: warning: %m,' . + \ '%I%f:%l: note: %m', + \ } +endfunction + +function! neomake#makers#ft#python#py3kwarn() abort + return { + \ 'errorformat': '%W%f:%l:%c: %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/python/compile.py b/.vim/autoload/neomake/makers/ft/python/compile.py new file mode 100755 index 0000000..d211673 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/python/compile.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python + +from __future__ import print_function +from sys import argv, exit + + +if len(argv) != 2: + exit(64) + +try: + compile(open(argv[1]).read(), argv[1], 'exec', 0, 1) +except SyntaxError as err: + print('%s:%s:%s: %s' % (err.filename, err.lineno, err.offset, err.msg)) + exit(1) diff --git a/.vim/autoload/neomake/makers/ft/r.vim b/.vim/autoload/neomake/makers/ft/r.vim new file mode 100644 index 0000000..59f488a --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/r.vim @@ -0,0 +1,17 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#r#EnabledMakers() abort + return ['lintr'] +endfunction + +function! neomake#makers#ft#r#lintr() abort + return { + \ 'exe': 'R', + \ 'args': ['--slave', '--no-restore', '--no-save', '-e lintr::lint("%t")'], + \ 'append_file': 0, + \ 'errorformat': + \ '%W%f:%l:%c: style: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%E%f:%l:%c: error: %m,' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/racket.vim b/.vim/autoload/neomake/makers/ft/racket.vim new file mode 100644 index 0000000..fc7145a --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/racket.vim @@ -0,0 +1,32 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#racket#EnabledMakers() abort + return ['raco'] +endfunction + +" This is the same form of syntax-checking used by DrRacket as well. The +" downside is that it will only catch the first error, but none of the +" subsequent ones. This is due to how evaluation in Racket works. +" +" About the error format: raco will print the first line as +" :: +" Every successive line will be indented by two spaces: +" in: +" context...: +" ::: +" The last pattern will be repeated as often as necessary. Example: +" foo.rkt:4:1: dfine: unbound identifier in modulemessage +" in: dfine +" context...: +" /usr/local/Cellar/racket/6.5/share/racket/pkgs/compiler-lib/compiler/commands/expand.rkt:34:15: loop +" /usr/local/Cellar/racket/6.5/share/racket/pkgs/compiler-lib/compiler/commands/expand.rkt:10:2: show-program +" /usr/local/Cellar/racket/6.5/share/racket/pkgs/compiler-lib/compiler/commands/expand.rkt: [running body] +" /usr/local/Cellar/minimal-racket/6.6/share/racket/collects/raco/raco.rkt: [running body] +" /usr/local/Cellar/minimal-racket/6.6/share/racket/collects/raco/main.rkt: [running body] +function! neomake#makers#ft#racket#raco() abort + return { + \ 'exe': 'raco', + \ 'args': ['expand'], + \ 'errorformat': '%-G %.%#,%E%f:%l:%c: %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/rst.vim b/.vim/autoload/neomake/makers/ft/rst.vim new file mode 100644 index 0000000..a7874ec --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/rst.vim @@ -0,0 +1,89 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#rst#SupersetOf() abort + return 'text' +endfunction + +" Get Sphinx source dir for the current buffer (determined by looking for +" conf.py, typically in docs/ or doc/). +" Caches the value in a buffer-local setting. +function! s:get_sphinx_srcdir() abort + let srcdir = neomake#config#get('sphinx.source_dir') + if srcdir isnot# g:neomake#config#undefined + return srcdir + endif + + let r = '' + let project_root = neomake#utils#get_project_root() + let bufname = bufname('%') + if empty(bufname) + call neomake#log#debug('sphinx: skipping setting of source_dir for empty bufname.', {'bufnr': bufnr('%')}) + return '' + endif + let f = findfile('conf.py', printf('%s;%s', fnamemodify(bufname, ':p:h'), project_root)) + if !empty(f) + let r = fnamemodify(f, ':p:h') + endif + call neomake#log#debug(printf('sphinx: setting b:neomake.sphinx.source_dir=%s.', string(r)), {'bufnr': bufnr('%')}) + call neomake#config#set('b:sphinx.source_dir', r) + return r +endfunction + +function! neomake#makers#ft#rst#EnabledMakers() abort + if executable('sphinx-build') && !empty(s:get_sphinx_srcdir()) + return ['sphinx'] + endif + return ['rstlint', 'rstcheck'] +endfunction + +function! neomake#makers#ft#rst#rstlint() abort + return { + \ 'exe': 'rst-lint', + \ 'errorformat': + \ '%ESEVERE %f:%l %m,'. + \ '%EERROR %f:%l %m,'. + \ '%WWARNING %f:%l %m,'. + \ '%IINFO %f:%l %m,'. + \ '%C%m', + \ 'postprocess': function('neomake#postprocess#compress_whitespace'), + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#rst#rstcheck() abort + return { + \ 'errorformat': + \ '%I%f:%l: (INFO/1) %m,'. + \ '%W%f:%l: (WARNING/2) %m,'. + \ '%E%f:%l: (ERROR/3) %m,'. + \ '%E%f:%l: (SEVERE/4) %m', + \ } +endfunction + +function! neomake#makers#ft#rst#sphinx() abort + " TODO: + " - project mode (after cleanup branch) + let srcdir = s:get_sphinx_srcdir() + if empty(srcdir) + throw 'Neomake: sphinx: could not find conf.py (you can configure sphinx.source_dir)' + endif + if !exists('s:sphinx_cache') + let s:sphinx_cache = tempname() + endif + " NOTE: uses '%Z%m,%-G%.%#' instead of '%C%m,%-G' to include next line in + " multiline errors (fixed in 7.4.203). + return { + \ 'exe': 'sphinx-build', + \ 'args': ['-n', '-E', '-q', '-N', '-b', 'dummy', srcdir, s:sphinx_cache], + \ 'append_file': 0, + \ 'errorformat': + \ '%f:%l: %tARNING: %m,' . + \ '%EWARNING: %f:%l: (SEVER%t/4) %m,' . + \ '%EWARNING: %f:%l: (%tRROR/3) %m,' . + \ '%EWARNING: %f:%l: (%tARNING/2) %m,' . + \ '%Z%m,' . + \ '%-G%.%#', + \ 'output_stream': 'stderr', + \ 'postprocess': function('neomake#postprocess#compress_whitespace'), + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/ruby.vim b/.vim/autoload/neomake/makers/ft/ruby.vim new file mode 100644 index 0000000..ceb6a46 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/ruby.vim @@ -0,0 +1,90 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#ruby#EnabledMakers() abort + return ['flog', 'mri', 'rubocop', 'reek', 'rubylint'] +endfunction + +function! neomake#makers#ft#ruby#rubocop() abort + return { + \ 'args': ['--format', 'emacs', '--force-exclusion', '--display-cop-names'], + \ 'errorformat': '%f:%l:%c: %t: %m,%E%f:%l: %m', + \ 'postprocess': function('neomake#makers#ft#ruby#RubocopEntryProcess'), + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#ruby#RubocopEntryProcess(entry) abort + if a:entry.type ==# 'F' " Fatal error which prevented further processing + let a:entry.type = 'E' + elseif a:entry.type ==# 'E' " Error for important programming issues + let a:entry.type = 'E' + elseif a:entry.type ==# 'W' " Warning for stylistic or minor programming issues + let a:entry.type = 'W' + elseif a:entry.type ==# 'R' " Refactor suggestion + let a:entry.type = 'W' + elseif a:entry.type ==# 'C' " Convention violation + let a:entry.type = 'I' + endif +endfunction + +function! neomake#makers#ft#ruby#rubylint() abort + return { + \ 'exe': 'ruby-lint', + \ 'args': ['--presenter', 'syntastic'], + \ 'errorformat': '%f:%t:%l:%c: %m', + \ } +endfunction + +function! neomake#makers#ft#ruby#mri() abort + let errorformat = '%-G%\m%.%#warning: %\%%(possibly %\)%\?useless use of == in void context,' + let errorformat .= '%-G%\%.%\%.%\%.%.%#,' + let errorformat .= + \ '%-GSyntax OK,'. + \ '%E%f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return { + \ 'exe': 'ruby', + \ 'args': ['-c', '-T1', '-w'], + \ 'errorformat': errorformat, + \ 'output_stream': 'both', + \ } +endfunction + +function! neomake#makers#ft#ruby#jruby() abort + let errorformat = + \ '%-GSyntax OK for %f,'. + \ '%ESyntaxError in %f:%l: syntax error\, %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: warning: %m,'. + \ '%Z%p^,'. + \ '%W%f:%l: %m,'. + \ '%-C%.%#' + + return { + \ 'exe': 'jruby', + \ 'args': ['-c', '-T1', '-w'], + \ 'errorformat': errorformat + \ } +endfunction + +function! neomake#makers#ft#ruby#reek() abort + return { + \ 'args': ['--format', 'text', '--single-line'], + \ 'errorformat': '%W%f:%l: %m', + \ } +endfunction + +function! neomake#makers#ft#ruby#flog() abort + return { + \ 'errorformat': + \ '%W%m %f:%l-%c,' . + \ '%-G\s%#,' . + \ '%-G%.%#: flog total,' . + \ '%-G%.%#: flog/method average,' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/rust.vim b/.vim/autoload/neomake/makers/ft/rust.vim new file mode 100644 index 0000000..71ddec1 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/rust.vim @@ -0,0 +1,233 @@ +function! neomake#makers#ft#rust#EnabledMakers() abort + return ['cargo'] +endfunction + +function! neomake#makers#ft#rust#rustc() abort + return { + \ 'errorformat': + \ '%-Gerror: aborting due to previous error,'. + \ '%-Gerror: aborting due to %\\d%\\+ previous errors,'. + \ '%-Gerror: Could not compile `%s`.,'. + \ '%Eerror[E%n]: %m,'. + \ '%Eerror: %m,'. + \ '%Wwarning: %m,'. + \ '%Inote: %m,'. + \ '%-Z\ %#-->\ %f:%l:%c,'. + \ '%G\ %#\= %*[^:]: %m,'. + \ '%G\ %#|\ %#%\\^%\\+ %m,'. + \ '%I%>help:\ %#%m,'. + \ '%Z\ %#%m,'. + \ '%-G%.%#', + \ } +endfunction + +function! s:get_cargo_workspace_root() abort + if !exists('b:_neomake_cargo_workspace') + let cmd = 'cargo metadata --no-deps --format-version 1' + let [cd_error, cd_back_cmd] = neomake#utils#temp_cd(expand('%:h')) + if !empty(cd_error) + call neomake#log#debug(printf( + \ 's:get_cargo_workspace_root: failed to cd to buffer directory: %s.', + \ cd_error)) + endif + let output = system(cmd) + if !empty(cd_back_cmd) + exe cd_back_cmd + endif + if v:shell_error + call neomake#log#debug(printf( + \ 'Failed to get cargo metadata for workspace using %s.', + \ string(cmd))) + let b:_neomake_cargo_workspace = '' + else + let json = neomake#compat#json_decode(output) + let b:_neomake_cargo_workspace = json['workspace_root'] + endif + endif + return b:_neomake_cargo_workspace +endfunction + +function! s:get_cargo_maker_cwd(default) abort + let cargo_workspace_root = s:get_cargo_workspace_root() + if !empty(cargo_workspace_root) + return cargo_workspace_root + endif + + let cargo_toml = neomake#utils#FindGlobFile('Cargo.toml') + if !empty(cargo_toml) + return fnamemodify(cargo_toml, ':h') + endif + + return a:default +endfunction + +function! neomake#makers#ft#rust#cargotest() abort + " NOTE: duplicates are removed due to https://github.com/rust-lang/cargo/issues/5128. + let maker = { + \ 'exe': 'cargo', + \ 'args': ['test', '%:t:r', '--quiet'], + \ 'append_file': 0, + \ 'uses_filename': 0, + \ 'postprocess': copy(g:neomake#postprocess#remove_duplicates), + \ 'errorformat': + \ '%-G,' . + \ '%-Gtest %s,' . + \ '%-Grunning %\\d%# test%s,' . + \ '%-Gfailures:%s,' . + \ '%-G----%s,' . + \ '%-G%.%#--verbose%s,' . + \ '%-G%.%#--explain%s,' . + \ '%-Gerror: aborting due to previous error,' . + \ '%-G%\ %#error: aborting due to %\\d%#%\ %#previous errors,' . + \ '%E%\ %#error[E%n]:\ %m,' . + \ '%E%\ %#error:\ %m,' . + \ '%I%\ %#note:\ %m,'. + \ '%W%\ %#warning:\ %m,' . + \ '%-Z%\ %#-->\ %f:%l:%c,' . + \ '%-G%\\d%# %#|\ %s,' . + \ '%-G%\\d%# %#|,' . + \ '%-G\ %#\= %*[^:]:\ %m,'. + \ '%E%\ %#%m,' . + \ '%G%\ %#%s%\\,,' . + \ '%Z%\ %#%s%\\,%\\s%f:%l:%c' + \ } + + function! maker.InitForJob(_jobinfo) abort + if !has_key(self, 'cwd') + let self.cwd = s:get_cargo_maker_cwd('%:p:h') + return self + endif + endfunction + return maker +endfunction + +function! neomake#makers#ft#rust#cargo() abort + let maker_command = get(b:, 'neomake_rust_cargo_command', + \ get(g:, 'neomake_rust_cargo_command', ['check'])) + let maker = { + \ 'args': maker_command + ['--message-format=json', '--quiet'], + \ 'append_file': 0, + \ 'process_output': function('neomake#makers#ft#rust#CargoProcessOutput'), + \ } + + function! maker.InitForJob(_jobinfo) abort + if !has_key(self, 'cwd') + let self.cwd = s:get_cargo_maker_cwd('%:p:h') + return self + endif + endfunction + return maker +endfunction + +" NOTE: does not use process_json, since cargo outputs multiple JSON root +" elements per line. +function! neomake#makers#ft#rust#CargoProcessOutput(context) abort + let errors = [] + for line in a:context['output'] + if line[0] !=# '{' + continue + endif + + let decoded = neomake#compat#json_decode(line) + let data = get(decoded, 'message', -1) + if type(data) != type({}) || empty(data['spans']) + continue + endif + + let error = {'maker_name': 'cargo'} + let code_dict = get(data, 'code', -1) + if code_dict is g:neomake#compat#json_null + if get(data, 'level', '') ==# 'warning' + let error.type = 'W' + else + let error.type = 'E' + endif + else + let error.type = code_dict['code'][0] + let error.nr = code_dict['code'][1:] + endif + + let span = data.spans[0] + for candidate_span in data.spans + if candidate_span.is_primary + let span = candidate_span + break + endif + endfor + + let expanded = 0 + let has_expansion = type(span.expansion) == type({}) + \ && type(span.expansion.span) == type({}) + \ && type(span.expansion.def_site_span) == type({}) + + if span.file_name =~# '^<.*>$' && has_expansion + let expanded = 1 + call neomake#makers#ft#rust#FillErrorFromSpan(error, + \ span.expansion.span) + else + call neomake#makers#ft#rust#FillErrorFromSpan(error, span) + endif + + let error.text = data.message + let detail = span.label + let children = data.children + if type(detail) == type('') && !empty(detail) + let error.text = error.text . ': ' . detail + elseif !empty(children) && has_key(children[0], 'message') + let error.text = error.text . '. ' . children[0].message + endif + + call add(errors, error) + + if has_expansion && !expanded + let error = copy(error) + call neomake#makers#ft#rust#FillErrorFromSpan(error, + \ span.expansion.span) + call add(errors, error) + endif + + for child in children[1:] + if !has_key(child, 'message') + continue + endif + + let info = deepcopy(error) + let info.type = 'I' + let info.text = child.message + call neomake#postprocess#compress_whitespace(info) + if has_key(child, 'rendered') + \ && !(child.rendered is g:neomake#compat#json_null) + let info.text = info.text . ': ' . child.rendered + endif + + if len(child.spans) + let span = child.spans[0] + if span.file_name =~# '^<.*>$' + \ && type(span.expansion) == type({}) + \ && type(span.expansion.span) == type({}) + \ && type(span.expansion.def_site_span) == type({}) + call neomake#makers#ft#rust#FillErrorFromSpan(info, + \ span.expansion.span) + else + call neomake#makers#ft#rust#FillErrorFromSpan(info, span) + endif + let detail = span.label + if type(detail) == type('') && len(detail) + let info.text = info.text . ': ' . detail + endif + endif + + call add(errors, info) + endfor + endfor + return errors +endfunction + +function! neomake#makers#ft#rust#FillErrorFromSpan(error, span) abort + let a:error.filename = a:span.file_name + let a:error.col = a:span.column_start + let a:error.lnum = a:span.line_start + let a:error.length = a:span.byte_end - a:span.byte_start +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/scala.vim b/.vim/autoload/neomake/makers/ft/scala.vim new file mode 100644 index 0000000..0899881 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/scala.vim @@ -0,0 +1,40 @@ +" vim: ts=4 sw=4 et +function! neomake#makers#ft#scala#EnabledMakers() abort + " use let g:neomake_scala_enabled_makers = ['fsc','scalastyle'] for fsc + let makers = ['scalac', 'scalastyle'] + return makers +endfunction + +function! neomake#makers#ft#scala#fsc() abort + return { + \ 'args': [ + \ '-Ystop-after:parser' + \ ], + \ 'errorformat': + \ '%E%f:%l: %trror: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#scala#scalac() abort + return { + \ 'args': [ + \ '-Ystop-after:parser' + \ ], + \ 'errorformat': + \ '%E%f:%l: %trror: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + \ } +endfunction + +function! neomake#makers#ft#scala#scalastyle() abort + return { + \ 'errorformat': + \ '%trror file=%f message=%m line=%l column=%c,' . + \ '%trror file=%f message=%m line=%l,' . + \ '%tarning file=%f message=%m line=%l column=%c,' . + \ '%tarning file=%f message=%m line=%l' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/scss.vim b/.vim/autoload/neomake/makers/ft/scss.vim new file mode 100644 index 0000000..e33ea6f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/scss.vim @@ -0,0 +1,25 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#scss#EnabledMakers() abort + return executable('stylelint') ? ['stylelint'] : executable('sass-lint') ? ['sasslint'] : ['scsslint'] +endfunction + +function! neomake#makers#ft#scss#sasslint() abort + return { + \ 'exe': 'sass-lint', + \ 'args': ['--no-exit', '--verbose', '--format', 'compact'], + \ 'errorformat': neomake#makers#ft#javascript#eslint()['errorformat'] + \ } +endfunction + +function! neomake#makers#ft#scss#scsslint() abort + return { + \ 'exe': 'scss-lint', + \ 'errorformat': '%A%f:%l:%v [%t] %m,' . + \ '%A%f:%l [%t] %m' + \ } +endfunction + +function! neomake#makers#ft#scss#stylelint() abort + return neomake#makers#ft#css#stylelint() +endfunction diff --git a/.vim/autoload/neomake/makers/ft/serpent.vim b/.vim/autoload/neomake/makers/ft/serpent.vim new file mode 100644 index 0000000..eff20ba --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/serpent.vim @@ -0,0 +1,13 @@ +function! neomake#makers#ft#serpent#EnabledMakers() abort + return ['serplint'] +endfunction + +function! neomake#makers#ft#serpent#serplint() abort + return { + \ 'exe': 'serplint', + \ 'args': [], + \ 'errorformat': + \ '%f:%l:%c %t%n %m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/sh.vim b/.vim/autoload/neomake/makers/ft/sh.vim new file mode 100644 index 0000000..00889b9 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/sh.vim @@ -0,0 +1,86 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#sh#EnabledMakers() abort + return ['sh', 'shellcheck'] +endfunction + +let s:shellcheck = { + \ 'args': ['-fgcc', '-x'], + \ 'errorformat': + \ '%f:%l:%c: %trror: %m [SC%n],' . + \ '%f:%l:%c: %tarning: %m [SC%n],' . + \ '%I%f:%l:%c: Note: %m [SC%n]', + \ 'output_stream': 'stdout', + \ 'short_name': 'SC', + \ 'cwd': '%:h', + \ } + +function! neomake#makers#ft#sh#shellcheck() abort + let maker = deepcopy(s:shellcheck) + + let line1 = getline(1) + if match(line1, '\v^#!.*<%(sh|dash|bash|ksh)') < 0 + \ && match(line1, '\v^#\s*shellcheck\s+shell\=') < 0 + " shellcheck does not read the shebang by itself. + let ext = expand('%:e') + if ext ==# 'ksh' + let maker.args += ['-s', 'ksh'] + elseif ext ==# 'sh' + if exists('g:is_sh') + let maker.args += ['-s', 'sh'] + elseif exists('g:is_posix') || exists('g:is_kornshell') + let maker.args += ['-s', 'ksh'] + else + let maker.args += ['-s', 'bash'] + endif + else + let maker.args += ['-s', 'bash'] + endif + endif + return maker +endfunction + +function! neomake#makers#ft#sh#checkbashisms() abort + return { + \ 'args': ['-fx'], + \ 'errorformat': + \ '%-Gscript %f is already a bash script; skipping,' . + \ '%Eerror: %f: %m\, opened in line %l,' . + \ '%Eerror: %f: %m,' . + \ '%Ecannot open script %f for reading: %m,' . + \ '%Wscript %f %m,%C%.# lines,' . + \ '%Wpossible bashism in %f line %l (%m):,%C%.%#,%Z.%#,' . + \ '%-G%.%#', + \ 'output_stream': 'stderr', + \ } +endfunction + +function! neomake#makers#ft#sh#sh() abort + let shebang = matchstr(getline(1), '^#!\s*\zs.*$') + if !empty(shebang) + let l = split(shebang) + let exe = l[0] + let args = l[1:] + ['-n'] + else + let exe = '/usr/bin/env' + let args = ['sh', '-n'] + endif + + " NOTE: the format without "line" is used by dash. + return { + \ 'exe': exe, + \ 'args': args, + \ 'errorformat': + \ '%E%f: line %l: %m,' . + \ '%E%f: %l: %m', + \ 'output_stream': 'stderr', + \} +endfunction + +function! neomake#makers#ft#sh#dash() abort + return { + \ 'args': ['-n'], + \ 'errorformat': '%E%f: %l: %m', + \ 'output_stream': 'stderr', + \} +endfunction diff --git a/.vim/autoload/neomake/makers/ft/slim.vim b/.vim/autoload/neomake/makers/ft/slim.vim new file mode 100644 index 0000000..931f57f --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/slim.vim @@ -0,0 +1,13 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#slim#EnabledMakers() abort + return ['slimlint'] +endfunction + +function! neomake#makers#ft#slim#slimlint() abort + return { + \ 'exe': 'slim-lint', + \ 'args': ['--no-color'], + \ 'errorformat': '%f:%l [%t] %m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/sml.vim b/.vim/autoload/neomake/makers/ft/sml.vim new file mode 100644 index 0000000..46e0bd0 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/sml.vim @@ -0,0 +1,19 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#sml#EnabledMakers() abort + return ['smlnj'] +endfunction + +" This comes straight out of syntastic. +function! neomake#makers#ft#sml#smlnj() abort + return { + \ 'exe': 'sml', + \ 'errorformat': + \ '%E%f:%l%\%.%c %trror: %m,' . + \ '%E%f:%l%\%.%c-%\d%\+%\%.%\d%\+ %trror: %m,' . + \ '%W%f:%l%\%.%c %tarning: %m,' . + \ '%W%f:%l%\%.%c-%\d%\+%\%.%\d%\+ %tarning: %m,' . + \ '%C%\s%\+%m,' . + \ '%-G%.%#' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/solidity.vim b/.vim/autoload/neomake/makers/ft/solidity.vim new file mode 100644 index 0000000..200e910 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/solidity.vim @@ -0,0 +1,16 @@ +function! neomake#makers#ft#solidity#EnabledMakers() abort + return ['solium', 'solhint'] +endfunction + +function! neomake#makers#ft#solidity#solium() abort + return { + \ 'args': ['--reporter', 'gcc', '--file'], + \ 'errorformat': + \ '%f:%l:%c: %t%s: %m', + \ } +endfunction + +function! neomake#makers#ft#solidity#solhint() abort + return neomake#makers#ft#javascript#eslint() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/spar.vim b/.vim/autoload/neomake/makers/ft/spar.vim new file mode 100644 index 0000000..9efe7a1 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/spar.vim @@ -0,0 +1,13 @@ +function! neomake#makers#ft#spar#EnabledMakers() abort + return ['spar'] +endfunction + +function! neomake#makers#ft#spar#spar() abort + return { + \ 'args': ['-g', '-c'], + \ 'errorformat': + \ '%f:%l:%c: %m', + \ 'nvim_job_opts': {'pty': 1} + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/spec.vim b/.vim/autoload/neomake/makers/ft/spec.vim new file mode 100644 index 0000000..2723340 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/spec.vim @@ -0,0 +1,16 @@ +function! neomake#makers#ft#spec#EnabledMakers() abort + return ['rpmlint'] +endfunction + +function! neomake#makers#ft#spec#rpmlint() abort + return { + \ 'errorformat': + \ '%E%f:%l: E: %m,' . + \ '%E%f: E: %m,' . + \ '%W%f:%l: W: %m,' . + \ '%W%f: W: %m,' . + \ '%-G%.%#' + \ } +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/sql.vim b/.vim/autoload/neomake/makers/ft/sql.vim new file mode 100644 index 0000000..bdbfdfa --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/sql.vim @@ -0,0 +1,13 @@ +function! neomake#makers#ft#sql#EnabledMakers() abort + return ['sqlint'] +endfunction + +function! neomake#makers#ft#sql#sqlint() abort + return { + \ 'errorformat': + \ '%E%f:%l:%c:ERROR %m,' . + \ '%W%f:%l:%c:WARNING %m,' . + \ '%C %m' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/stylus.vim b/.vim/autoload/neomake/makers/ft/stylus.vim new file mode 100644 index 0000000..113a194 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/stylus.vim @@ -0,0 +1,16 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#stylus#EnabledMakers() abort + return ['stylint'] +endfunction + +function! neomake#makers#ft#stylus#stylint() abort + return { + \ 'errorformat': + \ '%WWarning: %m,' . + \ '%EError: %m,' . + \ '%-Csee file: %f for the original selector,' . + \ '%CFile: %f,' . + \ '%ZLine: %l:%.%#' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/swift.vim b/.vim/autoload/neomake/makers/ft/swift.vim new file mode 100644 index 0000000..76bb440 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/swift.vim @@ -0,0 +1,54 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#swift#EnabledMakers() abort + if !empty(s:get_swiftpm_config()) + return ['swiftpm'] + endif + return ['swiftc'] +endfunction + +function! s:get_swiftpm_config() abort + return neomake#utils#FindGlobFile('Package.swift') +endfunction + +function! s:get_swiftpm_base_maker() abort + let maker = { + \ 'exe': 'swift', + \ 'append_file': 0, + \ 'errorformat': + \ '%E%f:%l:%c: error: %m,' . + \ '%E%f:%l: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%Z%\s%#^~%#,' . + \ '%-G%.%#', + \ } + let config = s:get_swiftpm_config() + if !empty(config) + let maker.cwd = fnamemodify(config, ':h') + endif + return maker +endfunction + +function! neomake#makers#ft#swift#swiftpm() abort + let maker = s:get_swiftpm_base_maker() + let maker.args = ['build', '--build-tests'] + return maker +endfunction + +function! neomake#makers#ft#swift#swiftpmtest() abort + let maker = s:get_swiftpm_base_maker() + let maker.args = ['test'] + return maker +endfunction + +function! neomake#makers#ft#swift#swiftc() abort + " `export SDKROOT="$(xcodebuild -version -sdk macosx Path)"` + return { + \ 'args': ['-parse'], + \ 'errorformat': + \ '%E%f:%l:%c: error: %m,' . + \ '%W%f:%l:%c: warning: %m,' . + \ '%Z%\s%#^~%#,' . + \ '%-G%.%#', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/tcl.vim b/.vim/autoload/neomake/makers/ft/tcl.vim new file mode 100644 index 0000000..76c5af4 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/tcl.vim @@ -0,0 +1,15 @@ +function! neomake#makers#ft#tcl#EnabledMakers() abort + return ['nagelfar'] +endfunction + +function! neomake#makers#ft#tcl#nagelfar() abort + return { + \ 'exe': 'nagelfar', + \ 'args': ['-H'], + \ 'errorformat': + \ '%I%f: %l: N %m,' . + \ '%f: %l: %t %m,' . + \ '%-GChecking file %f' + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/tex.vim b/.vim/autoload/neomake/makers/ft/tex.vim new file mode 100644 index 0000000..9fca53b --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/tex.vim @@ -0,0 +1,69 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#tex#EnabledMakers() abort + return ['chktex', 'lacheck', 'rubberinfo', 'proselint'] +endfunction + +function! neomake#makers#ft#tex#chktex() abort + let maker = { + \ 'args': [], + \ 'errorformat': + \ '%EError %n in %f line %l: %m,' . + \ '%WWarning %n in %f line %l: %m,' . + \ '%WMessage %n in %f line %l: %m,' . + \ '%Z%p^,' . + \ '%-G%.%#' + \ } + let rcfile = neomake#utils#FindGlobFile('.chktexrc') + if !empty(rcfile) + let maker.args += ['-l', fnamemodify(rcfile, ':h')] + endif + return maker +endfunction + +function! neomake#makers#ft#tex#lacheck() abort + return { + \ 'errorformat': + \ '%-G** %f:,' . + \ '%E"%f"\, line %l: %m' + \ } +endfunction + +function! neomake#makers#ft#tex#rubber() abort + return { + \ 'args': ['--pdf', '-f', '--warn=all'], + \ 'errorformat': + \ '%f:%l: %m,' . + \ '%f: %m' + \ } +endfunction + +function! neomake#makers#ft#tex#rubberinfo() abort + return { + \ 'exe': 'rubber-info', + \ 'errorformat': + \ '%f:%l: %m,' . + \ '%f:%l-%\d%\+: %m,' . + \ '%f: %m' + \ } +endfunction + +function! neomake#makers#ft#tex#latexrun() abort + return { + \ 'args': ['--color', 'never'], + \ 'errorformat': + \ '%f:%l: %m' + \ } +endfunction + +function! neomake#makers#ft#tex#pdflatex() abort + return { + \ 'exe': 'pdflatex', + \ 'args': ['-shell-escape', '-file-line-error', '-interaction', 'nonstopmode'], + \ 'errorformat': '%E%f:%l: %m' + \ } +endfunction + +function! neomake#makers#ft#tex#proselint() abort + return neomake#makers#ft#text#proselint() +endfunction diff --git a/.vim/autoload/neomake/makers/ft/text.vim b/.vim/autoload/neomake/makers/ft/text.vim new file mode 100644 index 0000000..a1ebe0a --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/text.vim @@ -0,0 +1,30 @@ +function! neomake#makers#ft#text#EnabledMakers() abort + " No makers enabled by default, since text is used as fallback often. + return [] +endfunction + +function! neomake#makers#ft#text#proselint() abort + return { + \ 'errorformat': '%W%f:%l:%c: %m', + \ 'postprocess': function('neomake#postprocess#generic_length'), + \ } +endfunction + +function! neomake#makers#ft#text#PostprocessWritegood(entry) abort + let a:entry.col += 1 + if a:entry.text[0] ==# '"' + let matchend = match(a:entry.text, '\v^[^"]+\zs"', 1) + if matchend != -1 + let a:entry.length = matchend - 1 + endif + endif +endfunction + +function! neomake#makers#ft#text#writegood() abort + return { + \ 'args': ['--parse'], + \ 'errorformat': '%W%f:%l:%c:%m,%C%m,%-G', + \ 'postprocess': function('neomake#makers#ft#text#PostprocessWritegood'), + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/toml.vim b/.vim/autoload/neomake/makers/ft/toml.vim new file mode 100644 index 0000000..d314911 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/toml.vim @@ -0,0 +1,15 @@ +function! neomake#makers#ft#toml#EnabledMakers() abort + return ['tomlcheck'] +endfunction + +function! neomake#makers#ft#toml#tomlcheck() abort + return { + \ 'args': ['-f'], + \ 'errorformat': + \ '%E%f:%l:%c:,' . + \ '%E%m' + \ } +endfunction + +" vim: et sw=4 ts=4 +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/tsx.vim b/.vim/autoload/neomake/makers/ft/tsx.vim new file mode 100644 index 0000000..2a31b4d --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/tsx.vim @@ -0,0 +1,15 @@ +function! neomake#makers#ft#tsx#SupersetOf() abort + return 'typescript' +endfunction + +function! neomake#makers#ft#tsx#EnabledMakers() abort + return ['tsc', 'tslint'] +endfunction + +function! neomake#makers#ft#tsx#tsc() abort + let config = neomake#makers#ft#typescript#tsc() + let config.args = config.args + ['--jsx', 'preserve'] + return config +endfunction + +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/typescript.vim b/.vim/autoload/neomake/makers/ft/typescript.vim new file mode 100644 index 0000000..4d011b7 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/typescript.vim @@ -0,0 +1,45 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#typescript#EnabledMakers() abort + return ['tsc', 'tslint'] +endfunction + +function! neomake#makers#ft#typescript#tsc() abort + " tsc should not be passed a single file. + let maker = { + \ 'args': ['--noEmit', '--watch', 'false', '--pretty', 'false'], + \ 'append_file': 0, + \ 'errorformat': + \ '%E%f %#(%l\,%c): error %m,' . + \ '%E%f %#(%l\,%c): %m,' . + \ '%Eerror %m,' . + \ '%C%\s%\+%m' + \ } + let config = neomake#utils#FindGlobFile('tsconfig.json') + if !empty(config) + let maker.args += ['--project', config] + endif + return maker +endfunction + +function! neomake#makers#ft#typescript#tslint() abort + " NOTE: output format changed in tslint 5.12.0. + let maker = { + \ 'args': ['-t', 'prose'], + \ 'errorformat': '%-G,' + \ .'%EERROR: %f:%l:%c - %m,' + \ .'%WWARNING: %f:%l:%c - %m,' + \ .'%EERROR: %f[%l\, %c]: %m,' + \ .'%WWARNING: %f[%l\, %c]: %m', + \ } + let config = neomake#utils#FindGlobFile('tsconfig.json') + if !empty(config) + let maker.args += ['--project', config] + let maker.cwd = fnamemodify(config, ':h') + endif + return maker +endfunction + +function! neomake#makers#ft#typescript#eslint() abort + return neomake#makers#ft#javascript#eslint() +endfunction diff --git a/.vim/autoload/neomake/makers/ft/verilog.vim b/.vim/autoload/neomake/makers/ft/verilog.vim new file mode 100644 index 0000000..78d9189 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/verilog.vim @@ -0,0 +1,16 @@ +function! neomake#makers#ft#verilog#EnabledMakers() abort + return ['iverilog'] +endfunction + +function! neomake#makers#ft#verilog#iverilog() abort + return { + \ 'args' : ['-tnull', '-Wall', '-y./'], + \ 'cwd' : '%:h', + \ 'errorformat' : '%f:%l: %trror: %m,' . + \ '%f:%l: %tarning: %m,' . + \ '%E%f:%l: : %m,' . + \ '%W%f:%l: : %m,' . + \ '%f:%l: %m', + \ } +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/vhdl.vim b/.vim/autoload/neomake/makers/ft/vhdl.vim new file mode 100644 index 0000000..dffa813 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/vhdl.vim @@ -0,0 +1,12 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#vhdl#EnabledMakers() abort + return ['ghdl'] +endfunction + +function! neomake#makers#ft#vhdl#ghdl() abort + return { + \ 'args' : ['-s'], + \ 'errorformat' : '%E%f:%l:%c: %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/vim.vim b/.vim/autoload/neomake/makers/ft/vim.vim new file mode 100644 index 0000000..8cd1318 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/vim.vim @@ -0,0 +1,87 @@ +function! neomake#makers#ft#vim#EnabledMakers() abort + return ['vint'] +endfunction + +let s:slash = neomake#utils#Slash() +let s:neomake_root = expand(':p:h:h:h:h:h', 1) + +let s:vint_supports_stdin = {} + +function! neomake#makers#ft#vim#neomake_checks() abort + let maker = { + \ 'exe': join([s:neomake_root, 'contrib', 'vim-checks'], s:slash), + \ 'errorformat': '%f:%l: %m', + \ } + + return maker +endfunction + +function! neomake#makers#ft#vim#vint() abort + let args = ['--style-problem', '--no-color', + \ '-f', '{file_path}:{line_number}:{column_number}:{severity}:{description} ({policy_name})'] + + if has('nvim') + call add(args, '--enable-neovim') + endif + + let maker = { + \ 'args': args, + \ 'errorformat': '%I%f:%l:%c:style_problem:%m,' + \ .'%f:%l:%c:%t%*[^:]:E%n: %m,' + \ .'%f:%l:%c:%t%*[^:]:%m', + \ 'output_stream': 'stdout', + \ 'postprocess': { + \ 'fn': function('neomake#postprocess#generic_length'), + \ 'pattern': '\v%(^:|%([^:]+: ))\zs(\S+)', + \ }} + + function! maker.supports_stdin(_jobinfo) abort + let exe = exists('*exepath') ? exepath(self.exe) : self.exe + let support = get(s:vint_supports_stdin, exe, -1) + if support == -1 + let ver = neomake#compat#systemlist(['vint', '--version']) + let ver_split = split(ver[0], '\.') + if len(ver_split) > 1 && (ver_split[0] > 0 || +ver_split[1] >= 4) + let support = 1 + else + let support = 0 + endif + let s:vint_supports_stdin[exe] = support + call neomake#log#debug('vint: stdin support: '.support.'.') + endif + if support + let self.args += ['--stdin-display-name', '%:.'] + endif + return support + endfunction + return maker +endfunction + +function! neomake#makers#ft#vim#vimlint() abort + return { + \ 'args': ['-u'], + \ 'errorformat': '%f:%l:%c:%trror: EVL%n: %m,' + \ . '%f:%l:%c:%tarning: EVL%n: %m,' + \ . '%f:%l:%c:%t%*[^:]: EVP_%#E%#%n: %m', + \ 'postprocess': function('neomake#makers#ft#vim#PostprocessVimlint'), + \ 'output_stream': 'stdout', + \ } +endfunction + +function! neomake#makers#ft#vim#PostprocessVimlint(entry) abort + let m = matchlist(a:entry.text, '\v`\zs[^`]{-}\ze`') + if empty(m) + return + endif + + " Ensure that the text is there. + let l = len(m[0]) + let line = getline(a:entry.lnum) + if line[a:entry.col-1 : a:entry.col-2+l] == m[0] + let a:entry.length = l + elseif m[0][0:1] ==# 'l:' && line[a:entry.col-1 : a:entry.col-4+l] == m[0][2:] + " Ignore implicit 'l:' prefix. + let a:entry.length = l - 2 + endif +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/vue.vim b/.vim/autoload/neomake/makers/ft/vue.vim new file mode 100644 index 0000000..d9f5303 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/vue.vim @@ -0,0 +1,28 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#vue#EnabledMakers() abort + return ['eslint', 'standard'] +endfunction + +function! neomake#makers#ft#vue#eslint() abort + let maker = neomake#makers#ft#javascript#eslint() + call extend(get(maker, 'args', []), ['--plugin', 'html']) + return maker +endfunction + +function! neomake#makers#ft#vue#eslint_d() abort + return neomake#makers#ft#vue#eslint() +endfunction + +function! neomake#makers#ft#vue#standard() abort + let maker = neomake#makers#ft#javascript#standard() + call extend(get(maker, 'args', []), ['--plugin', 'html']) + return maker +endfunction + +function! neomake#makers#ft#vue#semistandard() abort + let maker = neomake#makers#ft#javascript#semistandard() + call extend(get(maker, 'args', []), ['--plugin', 'html']) + return maker +endfunction + diff --git a/.vim/autoload/neomake/makers/ft/xml.vim b/.vim/autoload/neomake/makers/ft/xml.vim new file mode 100644 index 0000000..75b6996 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/xml.vim @@ -0,0 +1,25 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#xml#EnabledMakers() abort + return ['xmllint'] +endfunction + +function! neomake#makers#ft#xml#xmllint() abort + let args = ['--xinclude', '--postvalid', '--noout'] + + return { + \ 'args': args, + \ 'supports_stdin': 1, + \ 'errorformat': + \ '%E%f:%l: error : %m,' . + \ '%-G%f:%l: validity error : Validation failed: no DTD found %m,' . + \ '%W%f:%l: warning : %m,' . + \ '%W%f:%l: validity warning : %m,' . + \ '%E%f:%l: validity error : %m,' . + \ '%E%f:%l: parser error : %m,' . + \ '%E%f:%l: %m,' . + \ '%-Z%p^,' . + \ '%-C%.%#,' . + \ '%-G%.%#', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/xslt.vim b/.vim/autoload/neomake/makers/ft/xslt.vim new file mode 100644 index 0000000..61bcf02 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/xslt.vim @@ -0,0 +1,8 @@ +function! neomake#makers#ft#xslt#EnabledMakers() abort + return ['xmllint'] +endfunction + +function! neomake#makers#ft#xslt#xmllint() abort + return neomake#makers#ft#xml#xmllint() +endfunction +" vim: ts=4 sw=4 et diff --git a/.vim/autoload/neomake/makers/ft/yacc.vim b/.vim/autoload/neomake/makers/ft/yacc.vim new file mode 100644 index 0000000..8a2edd5 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/yacc.vim @@ -0,0 +1,17 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#yacc#EnabledMakers() abort + return ['bison'] +endfunction + +function! neomake#makers#ft#yacc#bison() abort + return { + \ 'errorformat': + \ '%E%f:%l%.%v-%.%\{-}: %trror: %m,' . + \ '%E%f:%l%.%v: %trror: %m,' . + \ '%W%f:%l%.%v-%.%\{-}: %tarning: %m,' . + \ '%W%f:%l%.%v: %tarning: %m,' . + \ '%I%f:%l%.%v-%.%\{-}: %\s%\+%m,' . + \ '%I%f:%l%.%v: %\s%\+%m' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/yaml.vim b/.vim/autoload/neomake/makers/ft/yaml.vim new file mode 100644 index 0000000..338ca8c --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/yaml.vim @@ -0,0 +1,12 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#yaml#EnabledMakers() abort + return ['yamllint'] +endfunction + +function! neomake#makers#ft#yaml#yamllint() abort + return { + \ 'args': ['-f', 'parsable'], + \ 'errorformat': '%E%f:%l:%c: [error] %m,%W%f:%l:%c: [warning] %m', + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/ft/zsh.vim b/.vim/autoload/neomake/makers/ft/zsh.vim new file mode 100644 index 0000000..a63e365 --- /dev/null +++ b/.vim/autoload/neomake/makers/ft/zsh.vim @@ -0,0 +1,19 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#ft#zsh#EnabledMakers() abort + return ['zsh'] +endfunction + +" Note: newer versions of shellcheck do not support zsh. +function! neomake#makers#ft#zsh#shellcheck() abort + let maker = neomake#makers#ft#sh#shellcheck() + let maker.args += ['--shell', 'zsh'] + return maker +endfunction + +function! neomake#makers#ft#zsh#zsh() abort + return { + \ 'args': ['-n'], + \ 'errorformat': '%E%f:%l: %m' + \} +endfunction diff --git a/.vim/autoload/neomake/makers/gradle.vim b/.vim/autoload/neomake/makers/gradle.vim new file mode 100644 index 0000000..de892a7 --- /dev/null +++ b/.vim/autoload/neomake/makers/gradle.vim @@ -0,0 +1,28 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#gradle#gradle() abort + let g:gradleBin = filereadable('./gradlew') ? './gradlew' : 'gradle' + + return { + \ 'exe': g:gradleBin, + \ 'append_file': 0, + \ 'args': ['assemble', '--daemon'], + \ 'errorformat': '\%+ATask\ %.%#\ not\ found\ %.%#.,'. + \'%EExecution\ failed\ for\ task\ %m,'. + \'findbugs:\ %tarning\ %f:%l:%c\ %m,'. + \'pmd:\ %tarning\ %f:%l:%c\ %m,'. + \'checkstyle:\ %tarning\ %f:%l:%c\ %m,'. + \'lint:\ %tarning\ %f:%l:%c\ %m,'. + \'%A>\ %f:%l:%c:\ %trror:\ %m,'. + \'%A>\ %f:%l:%c:\ %tarning:\ %m,'. + \'%A%f:%l:\ %trror:\ %m,'. + \'%A%f:%l:\ %tarning:\ %m,'. + \'%A%f:%l:\ %trror\ -\ %m,'. + \'%A%f:%l:\ %tarning\ -\ %m,'. + \'%E%f:%l\ :\ %m,'. + \'%C>\ %m,'. + \'%-G%p^,'. + \'%+G\ \ %.%#,'. + \'%-G%.%#' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/mvn.vim b/.vim/autoload/neomake/makers/mvn.vim new file mode 100644 index 0000000..cac2a80 --- /dev/null +++ b/.vim/autoload/neomake/makers/mvn.vim @@ -0,0 +1,9 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#mvn#mvn() abort + return { + \ 'exe': 'mvn', + \ 'args': ['install'], + \ 'errorformat': '[%tRROR]\ %f:[%l]\ %m,%-G%.%#' + \ } +endfunction diff --git a/.vim/autoload/neomake/makers/sbt.vim b/.vim/autoload/neomake/makers/sbt.vim new file mode 100644 index 0000000..93e233b --- /dev/null +++ b/.vim/autoload/neomake/makers/sbt.vim @@ -0,0 +1,13 @@ +" vim: ts=4 sw=4 et + +function! neomake#makers#sbt#sbt() abort + return { + \ 'exe': 'sbt', + \ 'args': ['-Dsbt.log.noformat=true', 'compile'], + \ 'errorformat': + \ '%E[%trror]\ %f:%l:%c:\ %m,' . + \ '%-Z[error]\ %p^,' . + \ '%-C%.%#,' . + \ '%-G%.%#' + \ } +endfunction -- cgit v1.2.3