Merge branch 'master' of https://github.com/microsoft/vcpkg

11 files changed, 186 insertions, 40 deletions

diff --git a/toolsrc/include/BinaryParagraph.h b/toolsrc/include/BinaryParagraph.h
index 01979c924..dcb986423 100644
--- a/toolsrc/include/BinaryParagraph.h
+++ b/toolsrc/include/BinaryParagraph.h
@@ -10,7 +10,7 @@ namespace vcpkg
     struct BinaryParagraph
     {
         BinaryParagraph();
-        explicit BinaryParagraph(const std::unordered_map<std::string, std::string>& fields);
+        explicit BinaryParagraph(std::unordered_map<std::string, std::string> fields);
         BinaryParagraph(const SourceParagraph& spgh, const triplet& target_triplet);
 
         std::string displayname() const;
diff --git a/toolsrc/include/SourceParagraph.h b/toolsrc/include/SourceParagraph.h
index 72dca8324..bac005144 100644
--- a/toolsrc/include/SourceParagraph.h
+++ b/toolsrc/include/SourceParagraph.h
@@ -9,7 +9,7 @@ namespace vcpkg
     {
         SourceParagraph();
 
-        explicit SourceParagraph(const std::unordered_map<std::string, std::string>& fields);
+        explicit SourceParagraph(std::unordered_map<std::string, std::string> fields);
 
         std::string name;
         std::string version;
diff --git a/toolsrc/include/vcpkg_Maps.h b/toolsrc/include/vcpkg_Maps.h
index 5b7b8ed46..886889294 100644
--- a/toolsrc/include/vcpkg_Maps.h
+++ b/toolsrc/include/vcpkg_Maps.h
@@ -15,4 +15,15 @@ namespace vcpkg { namespace Maps
         }
         return key_set;
     }
+
+    template <typename K, typename V>
+    std::vector<K> extract_keys(const std::unordered_map<K, V>& input_map)
+    {
+        std::vector<K> key_set;
+        for (auto const& element : input_map)
+        {
+            key_set.push_back(element.first);
+        }
+        return key_set;
+    }
 }}
diff --git a/toolsrc/include/vcpkg_Strings.h b/toolsrc/include/vcpkg_Strings.h
index 70526198c..d55a01224 100644
--- a/toolsrc/include/vcpkg_Strings.h
+++ b/toolsrc/include/vcpkg_Strings.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 namespace vcpkg {namespace Strings {namespace details
 {
@@ -67,4 +68,6 @@ namespace vcpkg {namespace Strings
     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);
+
+    std::string join(const std::vector<std::string>& v, const std::string& delimiter);
 }}
diff --git a/toolsrc/include/vcpkglib_helpers.h b/toolsrc/include/vcpkglib_helpers.h
index 72711d63b..05c9e17df 100644
--- a/toolsrc/include/vcpkglib_helpers.h
+++ b/toolsrc/include/vcpkglib_helpers.h
@@ -5,8 +5,10 @@
 namespace vcpkg {namespace details
 {
     std::string optional_field(const std::unordered_map<std::string, std::string>& fields, const std::string& fieldname);
+    std::string remove_optional_field(std::unordered_map<std::string, std::string>* fields, const std::string& fieldname);
 
     std::string required_field(const std::unordered_map<std::string, std::string>& fields, const std::string& fieldname);
+    std::string remove_required_field(std::unordered_map<std::string, std::string>* fields, const std::string& fieldname);
 
     std::vector<std::string> parse_depends(const std::string& depends_string);
 }}
diff --git a/toolsrc/src/BinaryParagraph.cpp b/toolsrc/src/BinaryParagraph.cpp
index 48d04f686..6dceb66d9 100644
--- a/toolsrc/src/BinaryParagraph.cpp
+++ b/toolsrc/src/BinaryParagraph.cpp
@@ -6,28 +6,57 @@ using namespace vcpkg::details;
 
 namespace vcpkg
 {
+    //
+    namespace BinaryParagraphRequiredField
+    {
+        static const std::string PACKAGE = "Package";
+        static const std::string VERSION = "Version";
+        static const std::string ARCHITECTURE = "Architecture";
+        static const std::string MULTI_ARCH = "Multi-Arch";
+    }
+
+    namespace BinaryParagraphOptionalField
+    {
+        static const std::string DESCRIPTION = "Description";
+        static const std::string MAINTAINER = "Maintainer";
+        static const std::string DEPENDS = "Depends";
+    }
+
+    static const std::vector<std::string>& get_list_of_valid_fields()
+    {
+        static const std::vector<std::string> valid_fields =
+        {
+            BinaryParagraphRequiredField::PACKAGE,
+            BinaryParagraphRequiredField::VERSION,
+            BinaryParagraphRequiredField::ARCHITECTURE,
+
+            BinaryParagraphOptionalField::DESCRIPTION,
+            BinaryParagraphOptionalField::MAINTAINER,
+            BinaryParagraphOptionalField::DEPENDS
+        };
+
+        return valid_fields;
+    }
+
     BinaryParagraph::BinaryParagraph() = default;
 
-    BinaryParagraph::BinaryParagraph(const std::unordered_map<std::string, std::string>& fields) :
-        version(required_field(fields, "Version")),
-        description(optional_field(fields, "Description")),
-        maintainer(optional_field(fields, "Maintainer"))
+    BinaryParagraph::BinaryParagraph(std::unordered_map<std::string, std::string> fields)
     {
-        const std::string name = required_field(fields, "Package");
-        const triplet target_triplet = triplet::from_canonical_name(required_field(fields, "Architecture"));
+        const std::string name = details::remove_required_field(&fields, BinaryParagraphRequiredField::PACKAGE);
+        const std::string architecture = details::remove_required_field(&fields, BinaryParagraphRequiredField::ARCHITECTURE);
+        const triplet target_triplet = triplet::from_canonical_name(architecture);
+
         this->spec = package_spec::from_name_and_triplet(name, target_triplet).get_or_throw();
+        this->version = details::remove_required_field(&fields, BinaryParagraphRequiredField::VERSION);
 
-        {
-            std::string multi_arch = required_field(fields, "Multi-Arch");
-            Checks::check_throw(multi_arch == "same", "Multi-Arch must be 'same' but was %s", multi_arch);
-        }
+        this->description = details::remove_optional_field(&fields, BinaryParagraphOptionalField::DESCRIPTION);
+        this->maintainer = details::remove_optional_field(&fields, BinaryParagraphOptionalField::MAINTAINER);
 
-        std::string deps = optional_field(fields, "Depends");
-        if (!deps.empty())
-        {
-            this->depends.clear();
-            this->depends = parse_depends(deps);
-        }
+        std::string multi_arch = details::remove_required_field(&fields, BinaryParagraphRequiredField::MULTI_ARCH);
+        Checks::check_exit(multi_arch == "same", "Multi-Arch must be 'same' but was %s", multi_arch);
+
+        std::string deps = details::remove_optional_field(&fields, BinaryParagraphOptionalField::DEPENDS);
+        this->depends = details::parse_depends(deps);
     }
 
     BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const triplet& target_triplet)
diff --git a/toolsrc/src/SourceParagraph.cpp b/toolsrc/src/SourceParagraph.cpp
index 374121ae9..6f25dbded 100644
--- a/toolsrc/src/SourceParagraph.cpp
+++ b/toolsrc/src/SourceParagraph.cpp
@@ -1,20 +1,63 @@
 #include "SourceParagraph.h"
 #include "vcpkglib_helpers.h"
+#include "vcpkg_System.h"
+#include "vcpkg_Maps.h"
 
-using namespace vcpkg::details;
+namespace vcpkg
+{
+    //
+    namespace SourceParagraphRequiredField
+    {
+        static const std::string SOURCE = "Source";
+        static const std::string VERSION = "Version";
+    }
 
-vcpkg::SourceParagraph::SourceParagraph() = default;
+    namespace SourceParagraphOptionalField
+    {
+        static const std::string DESCRIPTION = "Description";
+        static const std::string MAINTAINER = "Maintainer";
+        static const std::string BUILD_DEPENDS = "Build-Depends";
+    }
 
-vcpkg::SourceParagraph::SourceParagraph(const std::unordered_map<std::string, std::string>& fields):
-    name(required_field(fields, "Source")),
-    version(required_field(fields, "Version")),
-    description(optional_field(fields, "Description")),
-    maintainer(optional_field(fields, "Maintainer"))
-{
-    std::string deps = optional_field(fields, "Build-Depends");
-    if (!deps.empty())
+    static const std::vector<std::string>& get_list_of_valid_fields()
     {
-        this->depends.clear();
-        this->depends = parse_depends(deps);
-    };
+        static const std::vector<std::string> valid_fields =
+        {
+            SourceParagraphRequiredField::SOURCE,
+            SourceParagraphRequiredField::VERSION,
+
+            SourceParagraphOptionalField::DESCRIPTION,
+            SourceParagraphOptionalField::MAINTAINER,
+            SourceParagraphOptionalField::BUILD_DEPENDS
+        };
+
+        return valid_fields;
+    }
+
+    SourceParagraph::SourceParagraph() = default;
+
+    SourceParagraph::SourceParagraph(std::unordered_map<std::string, std::string> fields)
+    {
+        this->name = details::remove_required_field(&fields, SourceParagraphRequiredField::SOURCE);
+        this->version = details::remove_required_field(&fields, SourceParagraphRequiredField::VERSION);
+        this->description = details::remove_optional_field(&fields, SourceParagraphOptionalField::DESCRIPTION);
+        this->maintainer = details::remove_optional_field(&fields, SourceParagraphOptionalField::MAINTAINER);
+
+        std::string deps = details::remove_optional_field(&fields, SourceParagraphOptionalField::BUILD_DEPENDS);
+        this->depends = details::parse_depends(deps);
+
+        if (!fields.empty())
+        {
+            const std::vector<std::string> remaining_fields = Maps::extract_keys(fields);
+            const std::vector<std::string>& valid_fields = get_list_of_valid_fields();
+
+            const std::string remaining_fields_as_string = Strings::join(remaining_fields, "\n    ");
+            const std::string valid_fields_as_string = Strings::join(valid_fields, "\n    ");
+
+            System::println(System::color::error, "Error: There are invalid fields in the Source Paragraph of %s", this->name);
+            System::println("The following fields were not expected:\n\n    %s\n\n", remaining_fields_as_string);
+            System::println("This is the list of valid fields (case-sensitive): \n\n    %s\n", valid_fields_as_string);
+            exit(EXIT_FAILURE);
+        }
+    }
 }
diff --git a/toolsrc/src/StatusParagraph.cpp b/toolsrc/src/StatusParagraph.cpp
index 5aa425969..bf12ae89a 100644
--- a/toolsrc/src/StatusParagraph.cpp
+++ b/toolsrc/src/StatusParagraph.cpp
@@ -5,6 +5,12 @@ using namespace vcpkg::details;
 
 namespace vcpkg
 {
+    //
+    namespace BinaryParagraphRequiredField
+    {
+        static const std::string STATUS = "Status";
+    }
+
     StatusParagraph::StatusParagraph() : want(want_t::error), state(install_state_t::error)
     {
     }
@@ -19,7 +25,7 @@ namespace vcpkg
     StatusParagraph::StatusParagraph(const std::unordered_map<std::string, std::string>& fields)
         : package(fields)
     {
-        std::string status_field = required_field(fields, "Status");
+        std::string status_field = required_field(fields, BinaryParagraphRequiredField::STATUS);
 
         auto b = status_field.begin();
         auto mark = b;
diff --git a/toolsrc/src/commands_installation.cpp b/toolsrc/src/commands_installation.cpp
index 7e7da9e3f..022b87139 100644
--- a/toolsrc/src/commands_installation.cpp
+++ b/toolsrc/src/commands_installation.cpp
@@ -8,20 +8,23 @@
 #include "vcpkg_System.h"
 #include "vcpkg_Dependencies.h"
 #include "vcpkg_Input.h"
+#include "vcpkg_Maps.h"
 
 namespace vcpkg
 {
-    static void create_binary_control_file(const vcpkg_paths& paths, const fs::path& port_dir, const triplet& target_triplet)
+    static void create_binary_control_file(const vcpkg_paths& paths, const SourceParagraph& source_paragraph, const triplet& target_triplet)
     {
-        auto pghs = get_paragraphs(port_dir / "CONTROL");
-        Checks::check_exit(pghs.size() == 1, "Error: invalid control file");
-        auto bpgh = BinaryParagraph(SourceParagraph(pghs[0]), target_triplet);
+        auto bpgh = BinaryParagraph(source_paragraph, target_triplet);
         const fs::path binary_control_file = paths.packages / bpgh.dir() / "CONTROL";
         std::ofstream(binary_control_file) << bpgh;
     }
 
     static void build_internal(const package_spec& spec, const vcpkg_paths& paths, const fs::path& port_dir)
     {
+        auto pghs = get_paragraphs(port_dir / "CONTROL");
+        Checks::check_exit(pghs.size() == 1, "Error: invalid control file");
+        SourceParagraph source_paragraph(pghs[0]);
+
         const fs::path ports_cmake_script_path = paths.ports_cmake;
         auto&& target_triplet = spec.target_triplet();
         const std::wstring command = Strings::wformat(LR"("%%VS140COMNTOOLS%%..\..\VC\vcvarsall.bat" %s && cmake -DCMD=BUILD -DPORT=%s -DTARGET_TRIPLET=%s "-DCURRENT_PORT_DIR=%s/." -P "%s")",
@@ -54,7 +57,7 @@ namespace vcpkg
 
         perform_all_checks(spec, paths);
 
-        create_binary_control_file(paths, port_dir, target_triplet);
+        create_binary_control_file(paths, source_paragraph, target_triplet);
 
         // const fs::path port_buildtrees_dir = paths.buildtrees / spec.name;
         // delete_directory(port_buildtrees_dir);
diff --git a/toolsrc/src/vcpkg_Strings.cpp b/toolsrc/src/vcpkg_Strings.cpp
index 56eeae7a0..c53cba1fc 100644
--- a/toolsrc/src/vcpkg_Strings.cpp
+++ b/toolsrc/src/vcpkg_Strings.cpp
@@ -64,4 +64,25 @@ namespace vcpkg {namespace Strings
         std::transform(output.begin(), output.end(), output.begin(), ::tolower);
         return output;
     }
+
+    std::string join(const std::vector<std::string>& v, const std::string& delimiter)
+    {
+        if (v.empty())
+        {
+            return std::string();
+        }
+
+        std::string output;
+        size_t size = v.size();
+
+        output.append(v.at(0));
+
+        for (int i = 1; i < size; ++i)
+        {
+            output.append(delimiter);
+            output.append(v.at(i));
+        }
+
+        return output;
+    }
 }}
diff --git a/toolsrc/src/vcpkglib_helpers.cpp b/toolsrc/src/vcpkglib_helpers.cpp
index 3aa3735b0..3d14d4b06 100644
--- a/toolsrc/src/vcpkglib_helpers.cpp
+++ b/toolsrc/src/vcpkglib_helpers.cpp
@@ -13,17 +13,45 @@ namespace vcpkg {namespace details
         }
 
         return it->second;
-    };
+    }
+
+    std::string remove_optional_field(std::unordered_map<std::string, std::string>* fields, const std::string& fieldname)
+    {
+        auto it = fields->find(fieldname);
+        if (it == fields->end())
+        {
+            return std::string();
+        }
+
+        const std::string value = std::move(it->second);
+        fields->erase(it);
+        return value;
+    }
 
     std::string required_field(const std::unordered_map<std::string, std::string>& fields, const std::string& fieldname)
     {
         auto it = fields.find(fieldname);
-        vcpkg::Checks::check_throw(it != fields.end(), "Required field not present: %s", fieldname);
+        Checks::check_exit(it != fields.end(), "Required field not present: %s", fieldname);
         return it->second;
-    };
+    }
+
+    std::string remove_required_field(std::unordered_map<std::string, std::string>* fields, const std::string& fieldname)
+    {
+        auto it = fields->find(fieldname);
+        Checks::check_exit(it != fields->end(), "Required field not present: %s", fieldname);
+
+        const std::string value = std::move(it->second);
+        fields->erase(it);
+        return value;
+    }
 
     std::vector<std::string> parse_depends(const std::string& depends_string)
     {
+        if (depends_string.empty())
+        {
+            return {};
+        }
+
         std::vector<std::string> out;
 
         size_t cur = 0;