Update version detection

autoload/cmake4vim.vim

@@ -68,13 +68,13 @@ function! cmake4vim#GenerateCMake(...) abort
     " For old CMake version need to change the directory to generate CMake project
     " -B option was introduced only in CMake 3.13
     let l:cw_dir = getcwd()
-    if !utils#cmake#verNewerOrEq([3, 13])
+    if !utils#cmake#version#verNewerOrEq([3, 13])
         " Change work directory
         silent exec 'cd' l:build_dir
     endif
     " Generates CMake project
     call utils#common#executeCommand(l:cmake_cmd, 0, getcwd(), s:getCMakeErrorFormat())
-    if !utils#cmake#verNewerOrEq([3, 13])
+    if !utils#cmake#version#verNewerOrEq([3, 13])
         " Change work directory to old work directory
         silent exec 'cd' l:cw_dir
     endif
@@ -189,7 +189,7 @@ function! cmake4vim#CompileSource(...) abort
     let l:generator = l:cache_info['cmake']['generator']
 
     let l:target_name = ''
-    if l:generator =~# 'Unix Makefiles' || utils#cmake#verNewerOrEq([ 3, 14 ])
+    if l:generator =~# 'Unix Makefiles' || utils#cmake#version#verNewerOrEq([ 3, 14 ])
         let l:target_name = utils#gen#common#getSingleUnitTargetName(l:generator, l:source_name)
     else
         let l:prefix = ''
@@ -200,7 +200,7 @@ function! cmake4vim#CompileSource(...) abort
                 for i in range(len(l:subfolders))
                     let l:prefix .= '../'
                 endfor
-                if utils#cmake#verNewerOrEq([3, 13])
+                if utils#cmake#version#verNewerOrEq([3, 13])
                     let l:target_name = '"' . l:prefix . l:source_name . '^' . '"'
                 else
                     let l:target_name = l:prefix . fnameescape(l:source_name) . '^'
@@ -209,7 +209,7 @@ function! cmake4vim#CompileSource(...) abort
     endif
 
     " TODO: find the middle point
-    if !utils#cmake#verNewerOrEq([ 3, 13 ])
+    if !utils#cmake#version#verNewerOrEq([ 3, 13 ])
         let l:target_name = printf('"%s"', l:target_name)
     endif
 
@@ -231,20 +231,23 @@ function! cmake4vim#CTest(bang, ...) abort
     if !a:bang
         if type(g:cmake_ctest_args) == v:t_list
             let l:args += g:cmake_ctest_args
-            call extend(l:args, g:cmake_ctest_args)
         else
             call extend(l:args, [g:cmake_ctest_args])
         endif
     endif
-    if !utils#cmake#verNewerOrEq([3, 20])
+
+    " Use --test-dir for modern CMake versions, otherwise use directory change
+    if utils#cmake#version#verNewerOrEq([3, 20])
+        call extend(l:args, ['--test-dir', utils#fs#fnameescape(l:build_dir)])
+    else
         " Change work directory
         silent exec 'cd' l:build_dir
-    else
-        call extend(l:args, ['--test-dir', utils#fs#fnameescape(l:build_dir)])
     endif
+
     " Run
     call utils#common#executeCommand(printf('%s %s', l:cmd, join(l:args)), 1)
-    if !utils#cmake#verNewerOrEq([3, 20])
+
+    if !utils#cmake#version#verNewerOrEq([3, 20])
         " Change work directory to old work directory
         silent exec 'cd' l:cw_dir
     endif

autoload/utils/cmake.vim

@@ -141,6 +141,16 @@ function! utils#cmake#getDefaultBuildTypes() abort
     return ['Release', 'Debug', 'RelWithDebInfo', 'MinSizeRel', '']
 endfunction
 
+" Returns the path to build directory if directory was found and returns empty string in other case.
+" Use build directory from the cmake cache or try to find it at the current folder
+" Creates directory if it doesn't exist
+function! utils#cmake#getBuildDir() abort
+    let l:build_dir = s:detectCMakeBuildDir()
+    let l:build_dir = utils#fs#makeDir(l:build_dir)
+    let l:build_dir = fnamemodify(l:build_dir, ':p:h')
+    return l:build_dir
+endfunction
+
 " Return the names of possible builds, includes default CMake build types
 function! utils#cmake#getCMakeVariants() abort
     call s:populateDefaultCMakeVariants()
@@ -160,20 +170,7 @@ function! utils#cmake#getVersion() abort
     return l:version
 endfunction
 
-" Return 1 if cmake version is newer or equal to passed value
-function! utils#cmake#verNewerOrEq(cmake_version) abort
-    let l:i = 0
-    let l:cmake_ver = utils#cmake#getVersion()
-    while l:i < len(a:cmake_version) && l:i < len(l:cmake_ver)
-        if a:cmake_version[l:i] > l:cmake_ver[l:i]
-            return 0
-        elseif a:cmake_version[l:i] < l:cmake_ver[l:i]
-            return 1
-        endif
-        let l:i += 1
-    endwhile
-    return 1
-endfunction
+
 
 " Set CMake build target
 function! utils#cmake#setBuildTarget(build_dir, target) abort
@@ -258,10 +255,13 @@ function! utils#cmake#getCMakeGenerationCommand(...) abort
     let l:cmake_args += l:cmake_variant_usr_args + get(l:, 'cmake_kit_usr_args', [])
     let l:cmake_args += a:000
 
-    " CMake -B option was introduced in the 3.13 version
-    if utils#cmake#verNewerOrEq([3, 13])
+    " Check that we have at least CMake 3.13 for -B option, fallback for older versions
+    let l:has_b_option = utils#cmake#version#verNewerOrEq([3, 13])
+
+    if l:has_b_option
         let l:cmake_args += ['-B', utils#fs#fnameescape(l:build_dir), '-S', utils#fs#fnameescape(l:src_dir)]
     else
+        " For older CMake versions, use the current directory as source
         let l:cmake_args += [utils#fs#fnameescape(getcwd())]
     endif
 

autoload/utils/cmake/fileapi.vim

@@ -100,7 +100,7 @@ endfunction
 " }}} Private functions "
 
 function! utils#cmake#fileapi#prepare(build_dir) abort
-    if !(utils#cmake#verNewerOrEq([3, 14]))
+    if !(utils#cmake#version#verNewerOrEq([3, 14]))
         return
     endif
     let l:reply_folder = s:getReplyFolder(a:build_dir)

autoload/utils/cmake/version.vim

@@ -0,0 +1,52 @@
+" autoload/utils/cmake/version.vim - CMake version handling utilities
+" Maintainer:   Ilya Churaev <https://github.com/ilyachur>
+
+if !exists('s:cmake_version_cache')
+    let s:cmake_version_cache = []
+endif
+
+" Gets CMake version
+" Returns array [major, minor, patch]
+function! utils#cmake#version#getVersion() abort
+    if !empty(s:cmake_version_cache)
+        return s:cmake_version_cache
+    endif
+
+    let l:version_out = system(g:cmake_executable . ' --version')
+    let l:version_str = matchstr(l:version_out, '\v\d+.\d+.\d+')
+    let l:version_exp = split(l:version_str, '\.')
+    let l:version = []
+    for l:val in l:version_exp
+        let l:version += [str2nr(l:val)]
+    endfor
+    let s:cmake_version_cache = l:version
+    return l:version
+endfunction
+
+" Return 1 if cmake version is newer or equal to passed value
+function! utils#cmake#version#verNewerOrEq(cmake_version) abort
+    let l:cmake_ver = utils#cmake#version#getVersion()
+    let l:cmake_version = a:cmake_version
+    if len(l:cmake_version) == 0
+        return 1
+    endif
+    if len(l:cmake_ver) == 0
+        return 0
+    endif
+
+    " Compare versions
+    for i in range(max([len(l:cmake_version), len(l:cmake_ver)]))
+        if i >= len(l:cmake_ver) 
+            return 0
+        endif
+        if i >= len(l:cmake_version)
+            return 1
+        endif
+        if l:cmake_ver[i] > l:cmake_version[i]
+            return 1
+        elseif l:cmake_ver[i] < l:cmake_version[i]
+            return 0
+        endif
+    endfor
+    return 1
+endfunction

test/tests/basic/cmake_version.vader

@@ -7,104 +7,104 @@ After:
 Execute ([CMake version] Check older cmake version):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1, cur_version[2] - 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1, cur_version[2] - 1]), 1
 
 Execute ([CMake version] Check older major, minor cmake version 1):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1]), 1
 
 Execute ([CMake version] Check older major, minor cmake version 2):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1] + 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1] + 1]), 1
 
 Execute ([CMake version] Check older major, minor cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1]]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1]]), 1
 
 Execute ([CMake version] Check older major, minor cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0], cur_version[1] - 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0], cur_version[1] - 1]), 1
 
 Execute ([CMake version] Check older major, minor, path cmake version 1):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1], cur_version[2] - 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1], cur_version[2] - 1]), 1
 
 Execute ([CMake version] Check older major, minor, path cmake version 2):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1], cur_version[2] + 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1], cur_version[2] + 1]), 1
 
 Execute ([CMake version] Check older major, minor, path cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1, cur_version[2] + 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1] - 1, cur_version[2] + 1]), 1
 
 Execute ([CMake version] Check older major, minor, path cmake version 4):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] - 1, cur_version[1] + 1, cur_version[2] + 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] - 1, cur_version[1] + 1, cur_version[2] + 1]), 1
 
 Execute ([CMake version] Check older major, minor, path cmake version 5):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2] - 1]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2] - 1]), 1
 
 Execute ([CMake version] Check newer cmake version):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1, cur_version[2] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1, cur_version[2] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor cmake version 1):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1] - 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1] - 1]), 0
 
 Execute ([CMake version] Check newer major, minor cmake version 2):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1]]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1]]), 0
 
 Execute ([CMake version] Check newer major, minor cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0], cur_version[1] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0], cur_version[1] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor, path cmake version 1):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1], cur_version[2] - 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1], cur_version[2] - 1]), 0
 
 Execute ([CMake version] Check newer major, minor, path cmake version 2):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1], cur_version[2] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1], cur_version[2] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor, path cmake version 3):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1] - 1, cur_version[2] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1] - 1, cur_version[2] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor, path cmake version 4):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1, cur_version[2] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0] + 1, cur_version[1] + 1, cur_version[2] + 1]), 0
 
 Execute ([CMake version] Check newer major, minor, path cmake version 5):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2] + 1]), 0
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2] + 1]), 0
 
 Execute ([CMake version] Check equal cmake version):
     let cur_version = utils#cmake#getVersion()
     AssertEqual len(cur_version), 3
-    AssertEqual utils#cmake#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2]]), 1
+    AssertEqual utils#cmake#version#verNewerOrEq([cur_version[0], cur_version[1], cur_version[2]]), 1

test/tests/basic/generate_cmake_project.vader

@@ -151,7 +151,7 @@ Execute ([CMake generate] Call prepare file API after project generation):
     endif
 
 Execute ([CMake generate] Generate cmake project in custom source folder):
-    if utils#cmake#verNewerOrEq([3, 13])
+    if utils#cmake#version#verNewerOrEq([3, 13])
         Assert !isdirectory("cmake-build-Release"), "Build directory shouldn't exist"
         let g:cmake_src_dir='test proj'
         cd ..

test/tests/basic/plugin_initialization.vader

@@ -21,7 +21,7 @@ Execute ([Plugin Initialization] Check default initialization):
     let cmake_info = utils#cmake#common#getInfo()
     let cmake_gen = cmake_info['cmake']['generator']
     " Disable this check for windows with cmake 2.8
-    if !has('win32') || utils#cmake#verNewerOrEq([3, 0])
+    if !has('win32') || utils#cmake#version#verNewerOrEq([3, 0])
         if stridx(cmake_gen, utils#gen#vs#getGeneratorName()) != -1
             AssertEqual g:cmake_build_target, "ALL_BUILD"
         else