Optionally output packages (#201)

Helps makes diagnostics for issues like #199 easier.

.vscode/settings.json

@@ -3,6 +3,7 @@
     "editor.tabSize": 4,
     "files.associations": {
         "functional": "cpp",
-        "string": "cpp"
+        "string": "cpp",
+        "unordered_map": "cpp"
     }
 }

src/vswhere.lib/CommandArgs.cpp

@@ -132,6 +132,25 @@ void CommandArgs::Parse(_In_ vector<CommandParser::Token> args)
 
             m_property = ParseArgument(it, args.end(), arg);
         }
+        else if (ArgumentEquals(arg.Value, L"include"))
+        {
+            vector<wstring> include;
+            ParseArgumentArray(it, args.end(), arg, include);
+
+            for (const auto& value : include)
+            {
+                if (ArgumentEquals(value, L"packages"))
+                {
+                    m_includePackages = true;
+                }
+                else
+                {
+                    auto message = ResourceManager::FormatString(IDS_E_UNSUPPORTEDARG, value.c_str(), L"include");
+                    throw win32_error(ERROR_INVALID_PARAMETER, message);
+                }
+
+            }
+        }
         else if (ArgumentEquals(arg.Value, L"find"))
         {
             if (m_property.length())

src/vswhere.lib/CommandArgs.h

@@ -16,6 +16,7 @@ class CommandArgs
         m_latest(false),
         m_legacy(false),
         m_prerelease(false),
+        m_includePackages(false),
         m_nologo(false),
         m_utf8(false),
         m_help(false)
@@ -36,6 +37,7 @@ class CommandArgs
         m_prerelease(obj.m_prerelease),
         m_format(obj.m_format),
         m_property(obj.m_property),
+        m_includePackages(obj.m_includePackages),
         m_find(obj.m_find),
         m_nologo(obj.m_nologo),
         m_utf8(obj.m_utf8),
@@ -118,6 +120,11 @@ class CommandArgs
         return m_property;
     }
 
+    const bool get_IncludePackages() const noexcept
+    {
+        return m_includePackages;
+    }
+
     const std::wstring& get_Find() const noexcept
     {
         return m_find;
@@ -163,6 +170,7 @@ class CommandArgs
     bool m_prerelease;
     std::wstring m_format;
     std::wstring m_property;
+    bool m_includePackages;
     std::wstring m_find;
     bool m_nologo;
     bool m_utf8;

src/vswhere.lib/Formatter.cpp

@@ -258,11 +258,96 @@ void Formatter::WriteInternal(_In_ const CommandArgs& args, _In_ Console& consol
                 }
             }
         }
+
+        if (args.get_IncludePackages() && SupportsPackages())
+        {
+            if (specified.empty() || s_comparer(specified, L"packages"))
+            {
+                WritePackages(args, console, pInstance);
+            }
+        }
     }
 
     EndObject(console);
 }
 
+void Formatter::WritePackage(_In_ Console& console, _In_ ISetupPackageReference* pPackage)
+{
+    StartObject(console, L"package");
+
+    bstr_t bstr;
+    auto hr = pPackage->GetId(bstr.GetAddress());
+    if (SUCCEEDED(hr))
+    {
+        WriteProperty(console, L"id", bstr);
+    }
+
+    hr = pPackage->GetVersion(bstr.GetAddress());
+    if (SUCCEEDED(hr) && bstr.length())
+    {
+        WriteProperty(console, L"version", bstr);
+    }
+
+    hr = pPackage->GetChip(bstr.GetAddress());
+    if (SUCCEEDED(hr) && bstr.length())
+    {
+        WriteProperty(console, L"chip", bstr);
+    }
+
+    hr = pPackage->GetLanguage(bstr.GetAddress());
+    if (SUCCEEDED(hr) && bstr.length())
+    {
+        WriteProperty(console, L"language", bstr);
+    }
+
+    hr = pPackage->GetBranch(bstr.GetAddress());
+    if (SUCCEEDED(hr) && bstr.length())
+    {
+        WriteProperty(console, L"branch", bstr);
+    }
+
+    hr = pPackage->GetType(bstr.GetAddress());
+    if (SUCCEEDED(hr))
+    {
+        WriteProperty(console, L"type", bstr);
+    }
+
+    VARIANT_BOOL vtBool;
+    hr = pPackage->GetIsExtension(&vtBool);
+    if (SUCCEEDED(hr) && VARIANT_TRUE == vtBool)
+    {
+        WriteProperty(console, L"extension", true);
+    }
+
+    EndObject(console);
+}
+
+void Formatter::WritePackages(_In_ const CommandArgs& args, _In_ Console& console, _In_ ISetupInstance* pInstance)
+{
+    ISetupInstance2Ptr instance2;
+    LPSAFEARRAY psaPackages;
+
+    auto hr = pInstance->QueryInterface(&instance2);
+    if (SUCCEEDED(hr))
+    {
+        hr = instance2->GetPackages(&psaPackages);
+        if (SUCCEEDED(hr) && psaPackages->rgsabound[0].cElements)
+        {
+            StartArray(console, L"packages");
+
+            SafeArray<ISetupPackageReference*> saPackages(psaPackages);
+            const auto packages = saPackages.Elements();
+
+            for (const auto& package : packages)
+            {
+                WritePackage(console, package);
+            }
+
+            EndArray(console);
+        }
+    }
+}
+
 void Formatter::WriteProperty(_In_ Console& console, _In_ const wstring& name, _In_ const variant_t& value)
 {
     switch (value.vt)

src/vswhere.lib/Formatter.h

@@ -29,6 +29,11 @@ class Formatter
         return true;
     }
 
+    virtual bool SupportsPackages() const
+    {
+        return false;
+    }
+
 protected:
     typedef std::function<HRESULT(_In_ ISetupInstance*, _Out_ VARIANT*)> PropertyFunction;
     typedef std::vector<std::pair<std::wstring, PropertyFunction>> PropertyArray;
@@ -82,6 +87,8 @@ class Formatter
     HRESULT GetDescription(_In_ ISetupInstance* pInstance, _Out_ VARIANT* pvtDescription);
 
     void WriteInternal(_In_ const CommandArgs& args, _In_ Console& console, _In_ ISetupInstance* pInstance);
+    void WritePackage(_In_ Console& console, _In_ ISetupPackageReference* pPackage);
+    void WritePackages(_In_ const CommandArgs& args, _In_ Console& console, _In_ ISetupInstance* pInstance);
     void WriteProperty(_In_ Console& console, _In_ const std::wstring& name, _In_ const variant_t& value);
     bool WriteProperties(_In_ const CommandArgs& args, _In_ Console& console, _In_ ISetupInstance* pInstance);
     bool WriteProperties(_In_ const CommandArgs& args, _In_ Console& console, _In_ ISetupPropertyStore* pProperties, _In_opt_ const std::wstring& prefix = empty_wstring);

src/vswhere.lib/JsonFormatter.h

@@ -33,6 +33,11 @@ class JsonFormatter :
         return false;
     }
 
+    bool SupportsPackages() const override
+    {
+        return true;
+    }
+
 protected:
     void StartArray(_In_ Console& console, _In_opt_ const std::wstring& name = empty_wstring) override;
     void StartObject(_In_ Console& console, _In_opt_ const std::wstring& name = empty_wstring) override;

src/vswhere.lib/JsonScope.cpp

@@ -23,21 +23,28 @@ void JsonScope::StartProperty(_In_ Console& console)
 
 void JsonScope::WriteStartImpl(_In_ Console& console)
 {
+    bool writeKey = false;
+
     WriteSeparator(console);
 
-    // Write new line if not the root scope.
     if (Parent())
     {
+        if (Parent()->IsObject())
+        {
+            writeKey = true;
+        }
+
+        // Write new line if not the root scope.
         console.WriteLine();
     }
 
-    if (m_type == Type::array || Name().empty())
+    if (writeKey && Name().length())
     {
-        console.Write(L"%ls%lc", Padding().c_str(), StartChar());
+        console.Write(L"%ls\"%ls\": %lc", Padding().c_str(), Name().c_str(), StartChar());
     }
     else
     {
-        console.Write(L"%ls\"%ls\": %lc", Padding().c_str(), Name().c_str(), StartChar());
+        console.Write(L"%ls%lc", Padding().c_str(), StartChar());
     }
 }
 

src/vswhere.lib/JsonScope.h

@@ -25,6 +25,11 @@ class JsonScope :
     {
     }
 
+    bool IsArray() const noexcept
+    {
+        return m_type == Type::array;
+    }
+
     bool IsObject() const noexcept
     {
         return m_type == Type::object;

src/vswhere.lib/XmlFormatter.h

@@ -31,6 +31,11 @@ class XmlFormatter :
         return false;
     }
 
+    bool SupportsPackages() const override
+    {
+        return true;
+    }
+
 protected:
     void StartDocument(_In_ Console& console) override;
     void StartArray(_In_ Console& console, _In_opt_ const std::wstring& name = empty_wstring) override;

test/vswhere.test/JsonFormatterTests.cpp

@@ -531,4 +531,122 @@ TEST_CLASS(JsonFormatterTests)
             Assert::AreEqual(expected.c_str(), actual.c_str());
         }
     }
+
+    BEGIN_TEST_METHOD_ATTRIBUTE(Include_Packages)
+        TEST_WORKITEM(199)
+    END_TEST_METHOD_ATTRIBUTE()
+    TEST_METHOD(Include_Packages)
+    {
+        TestPackageReference product1 =
+        {
+            { L"Id", L"Microsoft.VisualStudio.Product.Community" },
+        };
+
+        TestPackageReference a1 =
+        {
+            { L"Id", L"A" },
+            { L"Version", L"1.0" },
+            { L"Type", L"Workload"},
+        };
+
+        TestPackageReference b1 =
+        {
+            { L"Id", L"B" },
+            { L"Version", L"1.0" },
+            { L"Type", L"Component"},
+        };
+
+        vector<TestInstance::ElementType> packages1 = { &a1, &b1 };
+
+        TestInstance::MapType properties1 =
+        {
+            { L"InstanceId", L"a1b2c3" },
+            { L"InstallationName", L"test" },
+        };
+
+        TestInstance instance1(&product1, packages1, properties1);
+
+        TestPackageReference product2 =
+        {
+            { L"Id", L"Microsoft.VisualStudio.Product.Enterprise" },
+        };
+
+        TestPackageReference a2 =
+        {
+            { L"Id", L"A" },
+            { L"Version", L"1.0" },
+            { L"Type", L"Workload"},
+        };
+
+        TestPackageReference b2 =
+        {
+            { L"Id", L"B" },
+            { L"Version", L"1.0" },
+            { L"Type", L"Component"},
+        };
+
+        vector<TestInstance::ElementType> packages2 = { &a2, &b2 };
+
+        TestInstance::MapType properties2 =
+        {
+            { L"InstanceId", L"b1c2d3" },
+            { L"InstallationName", L"test" },
+        };
+
+        TestInstance instance2(&product2, packages2, properties2);
+
+        vector<ISetupInstancePtr> instances =
+        {
+            &instance1,
+            &instance2,
+        };
+
+        CommandArgs args;
+        args.Parse(L"vswhere.exe -include packages");
+
+        TestConsole console(args);
+
+        JsonFormatter sut;
+        sut.Write(args, console, instances);
+
+        auto expected =
+            L"[\n"
+            L"  {\n"
+            L"    \"instanceId\": \"a1b2c3\",\n"
+            L"    \"installationName\": \"test\",\n"
+            L"    \"productId\": \"Microsoft.VisualStudio.Product.Community\",\n"
+            L"    \"packages\": [\n"
+            L"      {\n"
+            L"        \"id\": \"A\",\n"
+            L"        \"version\": \"1.0\",\n"
+            L"        \"type\": \"Workload\"\n"
+            L"      },\n"
+            L"      {\n"
+            L"        \"id\": \"B\",\n"
+            L"        \"version\": \"1.0\",\n"
+            L"        \"type\": \"Component\"\n"
+            L"      }\n"
+            L"    ]\n"
+            L"  },\n"
+            L"  {\n"
+            L"    \"instanceId\": \"b1c2d3\",\n"
+            L"    \"installationName\": \"test\",\n"
+            L"    \"productId\": \"Microsoft.VisualStudio.Product.Enterprise\",\n"
+            L"    \"packages\": [\n"
+            L"      {\n"
+            L"        \"id\": \"A\",\n"
+            L"        \"version\": \"1.0\",\n"
+            L"        \"type\": \"Workload\"\n"
+            L"      },\n"
+            L"      {\n"
+            L"        \"id\": \"B\",\n"
+            L"        \"version\": \"1.0\",\n"
+            L"        \"type\": \"Component\"\n"
+            L"      }\n"
+            L"    ]\n"
+            L"  }\n"
+            L"]\n";
+
+        Assert::AreEqual(expected, console);
+    }
 };