Merge remote-tracking branch 'upstream/master'

15 files changed, 149 insertions, 47 deletions

diff --git a/toolsrc/include/BinaryParagraph.h b/toolsrc/include/BinaryParagraph.h
index 88d6e84b1..01979c924 100644
--- a/toolsrc/include/BinaryParagraph.h
+++ b/toolsrc/include/BinaryParagraph.h
@@ -3,6 +3,7 @@
 #include <unordered_map>
 #include "SourceParagraph.h"
 #include "triplet.h"
+#include "package_spec.h"
 
 namespace vcpkg
 {
@@ -18,11 +19,10 @@ namespace vcpkg
 
         std::string dir() const;
 
-        std::string name;
+        package_spec spec;
         std::string version;
         std::string description;
         std::string maintainer;
-        triplet target_triplet;
         std::vector<std::string> depends;
     };
 
diff --git a/toolsrc/include/package_spec.h b/toolsrc/include/package_spec.h
index b8ed1e088..30dfca5c7 100644
--- a/toolsrc/include/package_spec.h
+++ b/toolsrc/include/package_spec.h
@@ -8,13 +8,20 @@ namespace vcpkg
 {
     struct package_spec
     {
-        std::string name;
-        triplet target_triplet;
+        static expected<package_spec> from_string(const std::string& spec_as_string, const triplet& default_target_triplet);
+
+        static expected<package_spec> from_name_and_triplet(const std::string& name, const triplet& target_triplet);
+
+        const std::string& name() const;
+
+        const triplet& target_triplet() const;
 
         std::string dir() const;
-    };
 
-    expected<package_spec> parse(const std::string& spec, const triplet& default_target_triplet);
+    private:
+        std::string m_name;
+        triplet m_target_triplet;
+    };
 
     std::string to_string(const package_spec& spec);
 
@@ -33,8 +40,8 @@ namespace std
         size_t operator()(const vcpkg::package_spec& value) const
         {
             size_t hash = 17;
-            hash = hash * 31 + std::hash<std::string>()(value.name);
-            hash = hash * 31 + std::hash<vcpkg::triplet>()(value.target_triplet);
+            hash = hash * 31 + std::hash<std::string>()(value.name());
+            hash = hash * 31 + std::hash<vcpkg::triplet>()(value.target_triplet());
             return hash;
         }
     };
diff --git a/toolsrc/include/package_spec_parse_result.h b/toolsrc/include/package_spec_parse_result.h
index e59622951..5735c4f4c 100644
--- a/toolsrc/include/package_spec_parse_result.h
+++ b/toolsrc/include/package_spec_parse_result.h
@@ -5,8 +5,9 @@ namespace vcpkg
 {
     enum class package_spec_parse_result
     {
-        success = 0,
-        too_many_colons
+        SUCCESS = 0,
+        TOO_MANY_COLONS,
+        INVALID_CHARACTERS
     };
 
     struct package_spec_parse_result_category_impl final : std::error_category
@@ -30,5 +31,6 @@ namespace std
 {
     template <>
     struct is_error_code_enum<vcpkg::package_spec_parse_result> : ::std::true_type
-    {};
+    {
+    };
 }
diff --git a/toolsrc/include/triplet.h b/toolsrc/include/triplet.h
index f9d1e9483..bc99a17df 100644
--- a/toolsrc/include/triplet.h
+++ b/toolsrc/include/triplet.h
@@ -6,17 +6,30 @@ namespace vcpkg
 {
     struct triplet
     {
+        static triplet from_canonical_name(const std::string& triplet_as_string);
+
+        enum class BuildType
+        {
+            DYNAMIC,
+            STATIC
+        };
+
         static const triplet X86_WINDOWS;
         static const triplet X64_WINDOWS;
         static const triplet X86_UWP;
         static const triplet X64_UWP;
         static const triplet ARM_UWP;
 
-        std::string value;
+        BuildType build_type() const;
+
+        const std::string& canonical_name() const;
 
         std::string architecture() const;
 
         std::string system() const;
+
+    private:
+        std::string m_canonical_name;
     };
 
     bool operator==(const triplet& left, const triplet& right);
@@ -39,7 +52,7 @@ namespace std
         {
             std::hash<std::string> hasher;
             size_t hash = 17;
-            hash = hash * 31 + hasher(t.value);
+            hash = hash * 31 + hasher(t.canonical_name());
             return hash;
         }
     };
diff --git a/toolsrc/include/vcpkg.h b/toolsrc/include/vcpkg.h
index 264d61fa9..a4a0682cf 100644
--- a/toolsrc/include/vcpkg.h
+++ b/toolsrc/include/vcpkg.h
@@ -18,10 +18,6 @@ namespace vcpkg
     std::vector<std::unordered_map<std::string, std::string>> parse_paragraphs(const std::string& str);
     std::string shorten_description(const std::string& desc);
 
-    fs::path find_available_package(const vcpkg_paths& paths, const package_spec& spec);
-    fs::path find_available_port_file(const vcpkg_paths& paths, const package_spec& spec);
-    fs::path control_file_for_package(const fs::path& package_path);
-
     StatusParagraphs database_load_check(const vcpkg_paths& paths);
 
     std::vector<std::string> get_unmet_package_dependencies(const vcpkg_paths& paths, const package_spec& spec, const StatusParagraphs& status_db);
diff --git a/toolsrc/include/vcpkg_Commands.h b/toolsrc/include/vcpkg_Commands.h
index c706c131c..978519820 100644
--- a/toolsrc/include/vcpkg_Commands.h
+++ b/toolsrc/include/vcpkg_Commands.h
@@ -9,6 +9,7 @@ namespace vcpkg
 
     void print_usage();
     void print_example(const char* command_and_arguments);
+    std::string create_example_string(const char* command_and_arguments);
     void update_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
 
     void build_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
@@ -16,8 +17,8 @@ namespace vcpkg
     void install_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
     void remove_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
 
-    void edit_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
-    void create_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet);
+    void edit_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
+    void create_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
 
     void search_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
     void list_command(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths);
diff --git a/toolsrc/include/vcpkg_Dependencies.h b/toolsrc/include/vcpkg_Dependencies.h
new file mode 100644
index 000000000..9dc32fc41
--- /dev/null
+++ b/toolsrc/include/vcpkg_Dependencies.h
@@ -0,0 +1,13 @@
+#pragma once
+#include <vector>
+#include "package_spec.h"
+#include "StatusParagraphs.h"
+#include <unordered_set>
+#include "vcpkg_paths.h"
+
+namespace vcpkg {namespace Dependencies
+{
+    std::vector<package_spec> create_dependency_ordered_install_plan(const vcpkg_paths& paths, const std::vector<package_spec>& specs, const StatusParagraphs& status_db);
+
+    std::unordered_set<package_spec> find_unmet_dependencies(const vcpkg_paths& paths, const package_spec& spec, const StatusParagraphs& status_db);
+}}
diff --git a/toolsrc/include/vcpkg_Files.h b/toolsrc/include/vcpkg_Files.h
index d23742f74..445713965 100644
--- a/toolsrc/include/vcpkg_Files.h
+++ b/toolsrc/include/vcpkg_Files.h
@@ -5,7 +5,13 @@
 
 namespace vcpkg {namespace Files
 {
+    static const char* FILESYSTEM_INVALID_CHARACTERS = R"(\/:*?"<>|)";
+
     void check_is_directory(const std::tr2::sys::path& dirpath);
 
+    bool has_invalid_chars_for_filesystem(const std::string s);
+
     expected<std::string> get_contents(const std::tr2::sys::path& file_path) noexcept;
+
+    std::tr2::sys::path find_file_recursively_up(const std::tr2::sys::path& starting_dir, const std::string& filename);
 }}
diff --git a/toolsrc/include/vcpkg_Input.h b/toolsrc/include/vcpkg_Input.h
new file mode 100644
index 000000000..bbf3adfbf
--- /dev/null
+++ b/toolsrc/include/vcpkg_Input.h
@@ -0,0 +1,15 @@
+#pragma once
+#include <vector>
+#include "package_spec.h"
+#include "vcpkg_paths.h"
+
+namespace vcpkg {namespace Input
+{
+    package_spec check_and_get_package_spec(const std::string& package_spec_as_string, const triplet& default_target_triplet, const char* example_text);
+
+    std::vector<package_spec> check_and_get_package_specs(const std::vector<std::string>& package_specs_as_strings, const triplet& default_target_triplet, const char* example_text);
+
+    void check_triplet(const triplet& t, const vcpkg_paths& paths);
+
+    void check_triplets(std::vector<package_spec> triplets, const vcpkg_paths& paths);
+}}
diff --git a/toolsrc/include/vcpkg_Maps.h b/toolsrc/include/vcpkg_Maps.h
new file mode 100644
index 000000000..5b7b8ed46
--- /dev/null
+++ b/toolsrc/include/vcpkg_Maps.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <unordered_map>
+#include <unordered_set>
+
+namespace vcpkg { namespace Maps
+{
+    template <typename K, typename V>
+    std::unordered_set<K> extract_key_set(const std::unordered_map<K, V>& input_map)
+    {
+        std::unordered_set<K> key_set;
+        for (auto const& element : input_map)
+        {
+            key_set.insert(element.first);
+        }
+        return key_set;
+    }
+}}
diff --git a/toolsrc/include/vcpkg_Sets.h b/toolsrc/include/vcpkg_Sets.h
new file mode 100644
index 000000000..7b330f31c
--- /dev/null
+++ b/toolsrc/include/vcpkg_Sets.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "vcpkg_Checks.h"
+#include <unordered_set>
+
+namespace vcpkg { namespace Sets
+{
+    template <typename T, typename Container>
+    void remove_all(std::unordered_set<T>* input_set, Container remove_these)
+    {
+        Checks::check_throw(input_set != nullptr, "Input set cannot be null");
+        for (const T& r : remove_these)
+        {
+            input_set->erase(r);
+        }
+    }
+}}
diff --git a/toolsrc/include/vcpkg_Strings.h b/toolsrc/include/vcpkg_Strings.h
index f4b989292..2aa99afe0 100644
--- a/toolsrc/include/vcpkg_Strings.h
+++ b/toolsrc/include/vcpkg_Strings.h
@@ -19,6 +19,11 @@ namespace vcpkg {namespace Strings {namespace details
         return s;
     }
 
+    inline size_t to_printf_arg(const size_t s)
+    {
+        return s;
+    }
+
     std::string format_internal(const char* fmtstr, ...);
 
     inline const wchar_t* to_wprintf_arg(const std::wstring& s)
@@ -31,7 +36,7 @@ namespace vcpkg {namespace Strings {namespace details
         return s;
     }
 
-    std::wstring format_internal(const wchar_t* fmtstr, ...);
+    std::wstring wformat_internal(const wchar_t* fmtstr, ...);
 }}}
 
 namespace vcpkg {namespace Strings
@@ -44,15 +49,17 @@ namespace vcpkg {namespace Strings
     }
 
     template <class...Args>
-    std::wstring format(const wchar_t* fmtstr, const Args&...args)
+    std::wstring wformat(const wchar_t* fmtstr, const Args&...args)
     {
         using vcpkg::Strings::details::to_wprintf_arg;
-        return details::format_internal(fmtstr, to_wprintf_arg(to_wprintf_arg(args))...);
+        return details::wformat_internal(fmtstr, to_wprintf_arg(to_wprintf_arg(args))...);
     }
 
     std::wstring utf8_to_utf16(const std::string& s);
 
     std::string utf16_to_utf8(const std::wstring& w);
 
-    std::string::const_iterator case_insensitive_find(const std::string& s, const std::string& pattern);
+    std::string::const_iterator case_insensitive_ascii_find(const std::string& s, const std::string& pattern);
+
+    std::string ascii_to_lowercase(const std::string& input);
 }}
diff --git a/toolsrc/include/vcpkg_cmd_arguments.h b/toolsrc/include/vcpkg_cmd_arguments.h
index 0df3d1222..95feb4814 100644
--- a/toolsrc/include/vcpkg_cmd_arguments.h
+++ b/toolsrc/include/vcpkg_cmd_arguments.h
@@ -4,16 +4,13 @@
 #include <vector>
 #include <unordered_set>
 #include "opt_bool.h"
-#include "package_spec.h"
 #include "vcpkg_paths.h"
-#include "StatusParagraphs.h"
 
 namespace vcpkg
 {
     struct vcpkg_cmd_arguments
     {
         static vcpkg_cmd_arguments create_from_command_line(const int argc, const wchar_t* const* const argv);
-
         static vcpkg_cmd_arguments create_from_arg_sequence(const std::string* arg_begin, const std::string* arg_end);
 
         std::unique_ptr<std::string> vcpkg_root_dir;
@@ -26,9 +23,12 @@ namespace vcpkg
         std::vector<std::string> command_arguments;
         std::unordered_set<std::string> check_and_get_optional_command_arguments(const std::vector<std::string>& valid_options) const;
 
-        void check_max_args(size_t arg_count, const char* example_text = nullptr) const;
-        std::vector<package_spec> parse_all_arguments_as_package_specs(const triplet& default_target_triplet, const char* example_text = nullptr) const;
-        std::vector<package_spec> extract_package_specs_with_unmet_dependencies(const vcpkg_paths& paths, const triplet& default_target_triplet, const StatusParagraphs& status_db) const;
+        void check_max_arg_count(const size_t expected_arg_count) const;
+        void check_max_arg_count(const size_t expected_arg_count, const char* example_text) const;
+        void check_min_arg_count(const size_t expected_arg_count) const;
+        void check_min_arg_count(const size_t expected_arg_count, const char* example_text) const;
+        void check_exact_arg_count(const size_t expected_arg_count) const;
+        void check_exact_arg_count(const size_t expected_arg_count, const char* example_text) const;
 
     private:
         std::unordered_set<std::string> optional_command_arguments;
diff --git a/toolsrc/include/vcpkg_paths.h b/toolsrc/include/vcpkg_paths.h
index 58ab45bc5..046b6836c 100644
--- a/toolsrc/include/vcpkg_paths.h
+++ b/toolsrc/include/vcpkg_paths.h
@@ -1,29 +1,36 @@
 #pragma once
 #include <filesystem>
 #include "expected.h"
+#include "package_spec.h"
 
 namespace vcpkg
 {
+    namespace fs = std::tr2::sys;
+
     struct vcpkg_paths
     {
-        static expected<vcpkg_paths> create(const std::tr2::sys::path& vcpkg_root_dir);
+        static expected<vcpkg_paths> create(const fs::path& vcpkg_root_dir);
+
+        fs::path package_dir(const package_spec& spec) const;
+        fs::path port_dir(const package_spec& spec) const;
+        bool is_valid_triplet(const triplet& t) const;
 
-        std::tr2::sys::path root;
-        std::tr2::sys::path packages;
-        std::tr2::sys::path buildtrees;
-        std::tr2::sys::path downloads;
-        std::tr2::sys::path ports;
-        std::tr2::sys::path installed;
-        std::tr2::sys::path triplets;
+        fs::path root;
+        fs::path packages;
+        fs::path buildtrees;
+        fs::path downloads;
+        fs::path ports;
+        fs::path installed;
+        fs::path triplets;
 
-        std::tr2::sys::path buildsystems;
-        std::tr2::sys::path buildsystems_msbuild_targets;
+        fs::path buildsystems;
+        fs::path buildsystems_msbuild_targets;
 
-        std::tr2::sys::path vcpkg_dir;
-        std::tr2::sys::path vcpkg_dir_status_file;
-        std::tr2::sys::path vcpkg_dir_info;
-        std::tr2::sys::path vcpkg_dir_updates;
+        fs::path vcpkg_dir;
+        fs::path vcpkg_dir_status_file;
+        fs::path vcpkg_dir_info;
+        fs::path vcpkg_dir_updates;
 
-        std::tr2::sys::path ports_cmake;
+        fs::path ports_cmake;
     };
 }
diff --git a/toolsrc/include/vcpkglib_helpers.h b/toolsrc/include/vcpkglib_helpers.h
index e15b59b0b..72711d63b 100644
--- a/toolsrc/include/vcpkglib_helpers.h
+++ b/toolsrc/include/vcpkglib_helpers.h
@@ -4,9 +4,9 @@
 
 namespace vcpkg {namespace details
 {
-    void optional_field(const std::unordered_map<std::string, std::string>& fields, std::string& out, const std::string& fieldname);
+    std::string optional_field(const std::unordered_map<std::string, std::string>& fields, const std::string& fieldname);
 
-    void required_field(const std::unordered_map<std::string, std::string>& fields, std::string& out, const std::string& fieldname);
+    std::string required_field(const std::unordered_map<std::string, std::string>& fields, const std::string& fieldname);
 
-    void parse_depends(const std::string& depends_string, std::vector<std::string>& out);
+    std::vector<std::string> parse_depends(const std::string& depends_string);
 }}