Add support for bool, strings and arrays in Configuration settings

src/AppInstallerCLICore/Workflows/ConfigurationFlow.cpp

@@ -104,7 +104,7 @@ namespace AppInstaller::CLI::Workflow
                 out << ' ' << Utility::ConvertToUTF8(property.GetString()) << '\n';
                 break;
             case PropertyType::Boolean:
-                out << ' ' << (property.GetBoolean() ? "true" : "false") << '\n';
+                out << ' ' << (property.GetBoolean() ? Utility::LocIndView("true") : Utility::LocIndView("false")) << '\n';
                 break;
             case PropertyType::Int64:
                 out << ' ' << property.GetInt64() << '\n';
@@ -115,24 +115,81 @@ namespace AppInstaller::CLI::Workflow
             }
         }
 
-        void OutputValueSet(OutputStream& out, const ValueSet& valueSet, size_t indent, bool isArray)
+        void OutputValueSet(OutputStream& out, const ValueSet& valueSet, size_t indent);
+
+        void OutputValueSetAsArray(OutputStream& out, const ValueSet& valueSetArray, size_t indent)
         {
             Utility::LocIndString indentString{ std::string(indent, ' ') };
-            bool processedFirstElement = false;
 
-            for (const auto& value : valueSet)
+            std::vector<IKeyValuePair<winrt::hstring, winrt::Windows::Foundation::IInspectable>> arrayValues;
+            for (const auto& arrayValue : valueSetArray)
             {
-                if (isArray && !processedFirstElement)
+                if (arrayValue.Key() != L"treatAsArray")
                 {
-                    Utility::LocIndString firstArrayIndentString{ std::string(indent - 2, ' ') };
-                    out << firstArrayIndentString << "- " << Utility::ConvertToUTF8(value.Key()) << ':';
+                    arrayValues.emplace_back(arrayValue);
+                }
+            }
+
+            std::sort(
+                arrayValues.begin(),
+                arrayValues.end(),
+                [](const IKeyValuePair<winrt::hstring, winrt::Windows::Foundation::IInspectable>& a, const IKeyValuePair<winrt::hstring, winrt::Windows::Foundation::IInspectable>& b)
+                {
+                    return a.Key() < b.Key();
+                });
+
+            for (const auto& arrayValue : arrayValues)
+            {
+                auto arrayObject = arrayValue.Value();
+                IPropertyValue arrayProperty = arrayObject.try_as<IPropertyValue>();
+
+                out << indentString << "-";
+                if (arrayProperty)
+                {
+                    OutputPropertyValue(out, arrayProperty);
                 }
                 else
                 {
-                    out << indentString << Utility::ConvertToUTF8(value.Key()) << ':';
+                    ValueSet arraySubset = arrayObject.as<ValueSet>();
+                    auto size = arraySubset.Size();
+                    if (size > 0)
+                    {
+                        // First one is special.
+                        auto first = arraySubset.First().Current();
+                        out << ' ' << Utility::ConvertToUTF8(first.Key()) << ':';
+
+                        auto object = first.Value();
+                        IPropertyValue property = object.try_as<IPropertyValue>();
+                        if (property)
+                        {
+                            OutputPropertyValue(out, property);
+                        }
+                        else
+                        {
+                            // If not an IPropertyValue, it must be a ValueSet
+                            ValueSet subset = object.as<ValueSet>();
+                            out << '\n';
+                            OutputValueSet(out, subset, indent + 4);
+                        }
+
+                        if (size > 1)
+                        {
+                            arraySubset.Remove(first.Key());
+                            OutputValueSet(out, arraySubset, indent + 2);
+                            arraySubset.Insert(first.Key(), first.Value());
+                        }
+                    }
                 }
+            }
+        }
 
-                processedFirstElement = true;
+        void OutputValueSet(OutputStream& out, const ValueSet& valueSet, size_t indent)
+        {
+            Utility::LocIndString indentString{ std::string(indent, ' ') };
+
+            for (const auto& value : valueSet)
+            {
+                out << indentString << Utility::ConvertToUTF8(value.Key()) << ':';
 
                 auto object = value.Value();
 
@@ -145,34 +202,14 @@ namespace AppInstaller::CLI::Workflow
                 {
                     // If not an IPropertyValue, it must be a ValueSet
                     ValueSet subset = object.as<ValueSet>();
-
                     out << '\n';
                     if (subset.HasKey(L"treatAsArray"))
                     {
-                        size_t arrayIndent = indent + 2;
-                        Utility::LocIndString arrayIndentString{ std::string(arrayIndent, ' ') };
-                        for (const auto& arrayValue : subset)
-                        {
-                            if (arrayValue.Key() != L"treatAsArray")
-                            {
-                                auto arrayObject = arrayValue.Value();
-                                IPropertyValue arrayProperty = arrayObject.try_as<IPropertyValue>();
-                                if (arrayProperty)
-                                {
-                                    out << arrayIndentString << "-";
-                                    OutputPropertyValue(out, arrayProperty);
-                                }
-                                else
-                                {
-                                    ValueSet arraySubset = arrayObject.as<ValueSet>();
-                                    OutputValueSet(out, arraySubset, arrayIndent + 2, true);
-                                }
-                            }
-                        }
+                        OutputValueSetAsArray(out, subset, indent + 2);
                     }
                     else
                     {
-                        OutputValueSet(out, subset, indent + 2, false);
+                        OutputValueSet(out, subset, indent + 2);
                     }
                 }
             }
@@ -310,7 +347,7 @@ namespace AppInstaller::CLI::Workflow
             if (settings.Size() > 0)
             {
                 out << "  "_liv << Resource::String::ConfigurationSettings << '\n';
-                OutputValueSet(out, settings, 4, false);
+                OutputValueSet(out, settings, 4);
             }
         }
 

src/AppInstallerCLITests/TestData/Node-Types.yaml

@@ -8,4 +8,4 @@ StringTrue: 'true'
 BooleanFalse: false
 StringFalse: 'false'
 
-LocalTag: !mytag value
+LocalTag: !myTag value

src/AppInstallerSharedLib/AppInstallerStrings.cpp

@@ -175,6 +175,32 @@ namespace AppInstaller::Utility
         return result;
     }
 
+    std::optional<std::wstring> TryConvertToUTF16(std::string_view input, UINT codePage)
+    {
+        if (input.empty())
+        {
+            return {};
+        }
+
+        int utf16CharCount = MultiByteToWideChar(codePage, 0, input.data(), wil::safe_cast<int>(input.length()), nullptr, 0);
+        if (utf16CharCount == 0)
+        {
+            return {};
+        }
+
+        // Since the string view should not contain the null char, the result won't either.
+        // This allows us to use the resulting size value directly in the string constructor.
+        std::wstring result(wil::safe_cast<size_t>(utf16CharCount), L'\0');
+
+        int utf16CharsWritten = MultiByteToWideChar(codePage, 0, input.data(), wil::safe_cast<int>(input.length()), &result[0], wil::safe_cast<int>(result.size()));
+        if (utf16CharCount != utf16CharsWritten)
+        {
+            return {};
+        }
+
+        return std::optional{ result };
+    }
+
     std::u32string ConvertToUTF32(std::string_view input)
     {
         if (input.empty())

src/AppInstallerSharedLib/Public/AppInstallerStrings.h

@@ -16,6 +16,9 @@ namespace AppInstaller::Utility
     // Converts the given UTF8 string to UTF16
     std::wstring ConvertToUTF16(std::string_view input, UINT codePage = CP_UTF8);
 
+    // Tries to convert the given UTF8 string to UTF16
+    std::optional<std::wstring> TryConvertToUTF16(std::string_view input, UINT codePage = CP_UTF8);
+
     // Converts the given UTF8 string to UTF32
     std::u32string ConvertToUTF32(std::string_view input);
 

src/AppInstallerSharedLib/Public/winget/Yaml.h

@@ -128,6 +128,14 @@ namespace AppInstaller::YAML
             return as_dispatch(t);
         }
 
+        template <typename T>
+        std::optional<T> try_as() const
+        {
+            Require(Type::Scalar);
+            T* t = nullptr;
+            return try_as_dispatch(t);
+        }
+
         bool operator<(const Node& other) const;
 
         // Gets a child node from the mapping by its name.
@@ -158,10 +166,19 @@ namespace AppInstaller::YAML
 
         // The workers for the as function.
         std::string as_dispatch(std::string*) const;
+        std::optional<std::string> try_as_dispatch(std::string*) const;
+
         std::wstring as_dispatch(std::wstring*) const;
+        std::optional<std::wstring> try_as_dispatch(std::wstring*) const;
+
         int64_t as_dispatch(int64_t*) const;
+        std::optional<int64_t> try_as_dispatch(int64_t*) const;
+
         int as_dispatch(int*) const;
+        std::optional<int> try_as_dispatch(int*) const;
+
         bool as_dispatch(bool*) const;
+        std::optional<bool> try_as_dispatch(bool*) const;
 
         Type m_type;
         std::string m_tag;

src/AppInstallerSharedLib/Yaml.cpp

@@ -207,22 +207,19 @@ namespace AppInstaller::YAML
         {
             // Integer
             // 0 | -? [1-9] [0-9]*
-            try
+            auto tryInt = this->try_as<int64_t>();
+            if (tryInt.has_value())
             {
-                this->as<int64_t>();
                 m_tagType = TagType::Int;
-                return;
             }
-            catch (...)
-            {
-            }
-
-            // Either 'true' or 'false'
-            // Avoid THROW_HR to don't log.
-            if (Utility::CaseInsensitiveEquals(m_scalar, "true") ||
-                Utility::CaseInsensitiveEquals(m_scalar, "false"))
+            else
             {
-                m_tagType = TagType::Bool;
+                // Boolean. Either 'true' or 'false'
+                auto tryBool = this->try_as<bool>();
+                if (tryBool.has_value())
+                {
+                    m_tagType = TagType::Bool;
+                }
             }
         }
     }
@@ -319,38 +316,84 @@ namespace AppInstaller::YAML
         return m_scalar;
     }
 
+    std::optional<std::string> Node::try_as_dispatch(std::string*) const
+    {
+        return std::optional{ m_scalar };
+    }
+
     std::wstring Node::as_dispatch(std::wstring*) const
     {
         return Utility::ConvertToUTF16(m_scalar);
     }
 
+    std::optional<std::wstring> Node::try_as_dispatch(std::wstring*) const
+    {
+        return Utility::TryConvertToUTF16(m_scalar);
+    }
+
     int64_t Node::as_dispatch(int64_t*) const
     {
         return std::stoll(m_scalar);
     }
 
+    std::optional<int64_t> Node::try_as_dispatch(int64_t*) const
+    {
+        try
+        {
+            return std::optional{ std::stoll(m_scalar) };
+        }
+        catch(...)
+        {
+            return {};
+        }
+    }
+
     int Node::as_dispatch(int*) const
     {
         // To allow HResult representation
         return static_cast<int>(std::stoll(m_scalar, 0, 0));
     }
 
-    bool Node::as_dispatch(bool*) const
+    std::optional<int> Node::try_as_dispatch(int*) const
     {
-        if (Utility::CaseInsensitiveEquals(m_scalar, "true"))
+        try
         {
-            return true;
+            return std::optional{ static_cast<int>(std::stoll(m_scalar, 0, 0)) };
         }
-        else if (Utility::CaseInsensitiveEquals(m_scalar, "false"))
+        catch (...)
+        {
+            return {};
+        }
+    }
+
+    bool Node::as_dispatch(bool*) const
+    {
+        bool* t = nullptr;
+        auto tryToBool = this->try_as_dispatch(t);
+        if (tryToBool.has_value())
         {
-            return false;
+            return tryToBool.value();
         }
         else
         {
             THROW_HR(APPINSTALLER_CLI_ERROR_YAML_INVALID_DATA);
         }
     }
 
+    std::optional<bool> Node::try_as_dispatch(bool*) const
+    {
+        if (Utility::CaseInsensitiveEquals(m_scalar, "true"))
+        {
+            return std::optional{ true };
+        }
+        else if (Utility::CaseInsensitiveEquals(m_scalar, "false"))
+        {
+            return std::optional{ false };
+        }
+
+        return {};
+    }
+
     Node Load(std::string_view input)
     {
         Wrapper::Parser parser(input);