[VcpkgPaths.cpp] Naming conventions and const fixes

toolsrc/src/VcpkgPaths.cpp

@@ -13,24 +13,24 @@ namespace vcpkg
     static bool exists_and_has_equal_or_greater_version(const std::wstring& version_cmd,
                                                         const std::array<int, 3>& expected_version)
     {
-        static const std::regex re(R"###((\d+)\.(\d+)\.(\d+))###");
+        static const std::regex RE(R"###((\d+)\.(\d+)\.(\d+))###");
 
-        auto rc = System::cmd_execute_and_capture_output(Strings::wformat(LR"(%s)", version_cmd));
+        const auto rc = System::cmd_execute_and_capture_output(Strings::wformat(LR"(%s)", version_cmd));
         if (rc.exit_code != 0)
         {
             return false;
         }
 
         std::match_results<std::string::const_iterator> match;
-        auto found = std::regex_search(rc.output, match, re);
+        const auto found = std::regex_search(rc.output, match, RE);
         if (!found)
         {
             return false;
         }
 
-        int d1 = atoi(match[1].str().c_str());
+        const int d1 = atoi(match[1].str().c_str());
-        int d2 = atoi(match[2].str().c_str());
+        const int d2 = atoi(match[2].str().c_str());
-        int d3 = atoi(match[3].str().c_str());
+        const int d3 = atoi(match[3].str().c_str());
         if (d1 > expected_version[0] || (d1 == expected_version[0] && d2 > expected_version[1]) ||
             (d1 == expected_version[0] && d2 == expected_version[1] && d3 >= expected_version[2]))
         {
@@ -64,8 +64,9 @@ namespace vcpkg
                                      const std::array<int, 3>& version)
     {
         const fs::path script = scripts_folder / "fetchDependency.ps1";
-        auto install_cmd = System::create_powershell_script_cmd(script, Strings::wformat(L"-Dependency %s", tool_name));
+        const auto install_cmd =
-        System::ExitCodeAndOutput rc = System::cmd_execute_and_capture_output(install_cmd);
+            System::create_powershell_script_cmd(script, Strings::wformat(L"-Dependency %s", tool_name));
+        const System::ExitCodeAndOutput rc = System::cmd_execute_and_capture_output(install_cmd);
         if (rc.exit_code)
         {
             const std::string version_as_string = Strings::format("%d.%d.%d", version[0], version[1], version[2]);
@@ -85,7 +86,7 @@ namespace vcpkg
 
         const fs::path actual_downloaded_path = Strings::trimmed(rc.output);
         std::error_code ec;
-        auto eq = fs::stdfs::equivalent(expected_downloaded_path, actual_downloaded_path, ec);
+        const auto eq = fs::stdfs::equivalent(expected_downloaded_path, actual_downloaded_path, ec);
         Checks::check_exit(VCPKG_LINE_INFO,
                            eq && !ec,
                            "Expected dependency downloaded path to be %s, but was %s",
@@ -96,8 +97,8 @@ namespace vcpkg
 
     static fs::path get_cmake_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
-        static constexpr std::array<int, 3> expected_version = {3, 9, 1};
+        static constexpr std::array<int, 3> EXPECTED_VERSION = {3, 9, 1};
-        static const std::wstring version_check_arguments = L"--version";
+        static const std::wstring VERSION_CHECK_ARGUMENTS = L"--version";
 
         const fs::path downloaded_copy = downloads_folder / "cmake-3.9.1-win32-x86" / "bin" / "cmake.exe";
         const std::vector<fs::path> from_path = Files::find_from_PATH(L"cmake");
@@ -109,19 +110,19 @@ namespace vcpkg
         candidate_paths.push_back(System::get_program_files_32_bit() / "CMake" / "bin");
 
         const Optional<fs::path> path =
-            find_if_has_equal_or_greater_version(candidate_paths, version_check_arguments, expected_version);
+            find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
-        if (auto p = path.get())
+        if (const auto p = path.get())
         {
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"cmake", downloaded_copy, expected_version);
+        return fetch_dependency(scripts_folder, L"cmake", downloaded_copy, EXPECTED_VERSION);
     }
 
     fs::path get_nuget_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
-        static constexpr std::array<int, 3> expected_version = {4, 1, 0};
+        static constexpr std::array<int, 3> EXPECTED_VERSION = {4, 1, 0};
-        static const std::wstring version_check_arguments = Strings::WEMPTY;
+        static const std::wstring VERSION_CHECK_ARGUMENTS = Strings::WEMPTY;
 
         const fs::path downloaded_copy = downloads_folder / "nuget-4.1.0" / "nuget.exe";
         const std::vector<fs::path> from_path = Files::find_from_PATH(L"nuget");
@@ -130,19 +131,19 @@ namespace vcpkg
         candidate_paths.push_back(downloaded_copy);
         candidate_paths.insert(candidate_paths.end(), from_path.cbegin(), from_path.cend());
 
-        auto path = find_if_has_equal_or_greater_version(candidate_paths, version_check_arguments, expected_version);
+        auto path = find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
-        if (auto p = path.get())
+        if (const auto p = path.get())
         {
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"nuget", downloaded_copy, expected_version);
+        return fetch_dependency(scripts_folder, L"nuget", downloaded_copy, EXPECTED_VERSION);
     }
 
     fs::path get_git_path(const fs::path& downloads_folder, const fs::path& scripts_folder)
     {
-        static constexpr std::array<int, 3> expected_version = {2, 14, 1};
+        static constexpr std::array<int, 3> EXPECTED_VERSION = {2, 14, 1};
-        static const std::wstring version_check_arguments = L"--version";
+        static const std::wstring VERSION_CHECK_ARGUMENTS = L"--version";
 
         const fs::path downloaded_copy = downloads_folder / "MinGit-2.14.1-32-bit" / "cmd" / "git.exe";
         const std::vector<fs::path> from_path = Files::find_from_PATH(L"git");
@@ -154,13 +155,13 @@ namespace vcpkg
         candidate_paths.push_back(System::get_program_files_32_bit() / "git" / "cmd" / "git.exe");
 
         const Optional<fs::path> path =
-            find_if_has_equal_or_greater_version(candidate_paths, version_check_arguments, expected_version);
+            find_if_has_equal_or_greater_version(candidate_paths, VERSION_CHECK_ARGUMENTS, EXPECTED_VERSION);
-        if (auto p = path.get())
+        if (const auto p = path.get())
         {
             return *p;
         }
 
-        return fetch_dependency(scripts_folder, L"git", downloaded_copy, expected_version);
+        return fetch_dependency(scripts_folder, L"git", downloaded_copy, EXPECTED_VERSION);
     }
 
     Expected<VcpkgPaths> VcpkgPaths::create(const fs::path& vcpkg_root_dir)
@@ -221,7 +222,7 @@ namespace vcpkg
     {
         for (auto&& path : get_filesystem().get_files_non_recursive(this->triplets))
         {
-            std::string triplet_file_name = path.stem().generic_u8string();
+            const std::string triplet_file_name = path.stem().generic_u8string();
             if (t.canonical_name() == triplet_file_name) // TODO: fuzzy compare
             {
                 // t.value = triplet_file_name; // NOTE: uncomment when implementing fuzzy compare
@@ -246,19 +247,19 @@ namespace vcpkg
         return this->nuget_exe.get_lazy([this]() { return get_nuget_path(this->downloads, this->scripts); });
     }
 
-    static std::vector<std::string> get_VS2017_installation_instances(const VcpkgPaths& paths)
+    static std::vector<std::string> get_vs2017_installation_instances(const VcpkgPaths& paths)
     {
         const fs::path script = paths.scripts / "findVisualStudioInstallationInstances.ps1";
         const std::wstring cmd = System::create_powershell_script_cmd(script);
-        System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd);
+        const System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd);
         Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Could not run script to detect VS 2017 instances");
         return Strings::split(ec_data.output, "\n");
     }
 
-    static Optional<fs::path> get_VS2015_installation_instance()
+    static Optional<fs::path> get_vs2015_installation_instance()
     {
         const Optional<std::wstring> vs2015_cmntools_optional = System::get_environment_variable(L"VS140COMNTOOLS");
-        if (auto v = vs2015_cmntools_optional.get())
+        if (const auto v = vs2015_cmntools_optional.get())
         {
             const fs::path vs2015_cmntools = fs::path(*v).parent_path(); // The call to parent_path() is needed because
                                                                          // the env variable has a trailing backslash
@@ -274,15 +275,15 @@ namespace vcpkg
 
         const auto& fs = paths.get_filesystem();
 
-        const std::vector<std::string> vs2017_installation_instances = get_VS2017_installation_instances(paths);
+        const std::vector<std::string> vs2017_installation_instances = get_vs2017_installation_instances(paths);
         // Note: this will contain a mix of vcvarsall.bat locations and dumpbin.exe locations.
         std::vector<fs::path> paths_examined;
 
         std::vector<Toolset> found_toolsets;
 
         // VS2015
-        const Optional<fs::path> vs_2015_installation_instance = get_VS2015_installation_instance();
+        const Optional<fs::path> vs_2015_installation_instance = get_vs2015_installation_instance();
-        if (auto v = vs_2015_installation_instance.get())
+        if (const auto v = vs_2015_installation_instance.get())
         {
             const fs::path vs2015_vcvarsall_bat = *v / "VC" / "vcvarsall.bat";
 
@@ -362,7 +363,7 @@ namespace vcpkg
                     break;
                 }
             }
-            if (auto value = vs2017_toolset.get())
+            if (const auto value = vs2017_toolset.get())
             {
                 found_toolsets.push_back(*value);
                 break;