#92 : Settings UI can now display / handle base custom commands

clechasseur · Jan 19, 2020 · 9830a0d · 9830a0d
1 parent d22b1c0
commit 9830a0d
Show file tree

Hide file tree

Showing 14 changed files with 180 additions and 134 deletions.
diff --git a/PathCopyCopy/plugins/prihdr/PipelinePlugin.h b/PathCopyCopy/plugins/prihdr/PipelinePlugin.h
@@ -24,6 +24,8 @@
 #include <PathCopyCopyPrivateTypes.h>
 #include <Plugin.h>
 
+#include <optional>
+
 
 namespace PCC
 {
@@ -47,6 +49,7 @@ namespace PCC
             PipelinePlugin&             operator=(const PipelinePlugin&) = delete;
 
             const Pipeline*             GetPipeline(GUIDS* p_psSeenPluginIds = nullptr) const;
+            std::string                 GetPipelineError() const;
 
             const GUID&                 Id() const noexcept(false) override;
 
@@ -69,8 +72,9 @@ namespace PCC
             const std::wstring          m_IconFile;         // Plugin icon file.
             const bool                  m_UseDefaultIcon;   // Whether to use default icon for plugin.
             const std::wstring          m_EncodedElements;  // Pipeline encoded elements.
-            mutable PipelineSP          m_spPipeline;       // Pipeline to execute on each path received.
-            mutable bool                m_PipelineCreated;  // Whether m_spPipeline has been created.
+            mutable std::optional<PipelineSP>
+                                        m_spPipeline;       // Pipeline to execute on each path received.
+            mutable std::string         m_PipelineError;    // If pipeline failed to load, can contain the error message.
         };
 
     } // namespace Plugins

diff --git a/PathCopyCopy/plugins/src/PipelinePlugin.cpp b/PathCopyCopy/plugins/src/PipelinePlugin.cpp
@@ -53,7 +53,7 @@ namespace PCC
               m_UseDefaultIcon(p_UseDefaultIcon),
               m_EncodedElements(p_EncodedElements),
               m_spPipeline(),
-              m_PipelineCreated(false)
+              m_PipelineError()
         {
         }
 
@@ -68,21 +68,38 @@ namespace PCC
         //
         const Pipeline* PipelinePlugin::GetPipeline(GUIDS* const p_psSeenPluginIds /*= nullptr*/) const
         {
-            if (!m_PipelineCreated) {
+            if (!m_spPipeline.has_value()) {
                 try {
-                    m_spPipeline = std::make_shared<Pipeline>(m_EncodedElements);
+                    PipelineSP spPipeline = std::make_shared<Pipeline>(m_EncodedElements);
 
                     // Make sure pipeline is valid.
                     GUIDS sSeenPluginIds;
                     GUIDS& rsSeenPluginIds = p_psSeenPluginIds != nullptr ? *p_psSeenPluginIds : sSeenPluginIds;
-                    if (!rsSeenPluginIds.emplace(Id()).second || !m_spPipeline->Valid(m_pPluginProvider, rsSeenPluginIds)) {
-                        m_spPipeline = nullptr;
+                    if (!rsSeenPluginIds.emplace(Id()).second) {
+                        throw InvalidPipelineException(ATL::CStringA(MAKEINTRESOURCEA(IDS_INVALIDPIPELINE_LOOP_DETECTED)));
                     }
-                } catch (const InvalidPipelineException&) {
+                    spPipeline->Validate(m_pPluginProvider, rsSeenPluginIds);
+
+                    m_spPipeline = spPipeline;
+                    m_PipelineError.clear();
+                } catch (const std::exception& e) {
+                    m_spPipeline = std::make_optional<PipelineSP>(nullptr);
+                    m_PipelineError = e.what();
                 }
-                m_PipelineCreated = true;
             }
-            return m_spPipeline.get();
+            return m_spPipeline.value().get();
+        }
+
+        //
+        // Returns any error message retrieved when this plugin's pipeline
+        // has been loaded. Call this if GetPipeline returns nullptr to
+        // perhaps get more information.
+        //
+        // @return Error message. May be empty even if pipeline failed to load.
+        //
+        std::string PipelinePlugin::GetPipelineError() const
+        {
+            return m_PipelineError;
         }
 
         //
@@ -154,6 +171,8 @@ namespace PCC
             const Pipeline* pPipeline = GetPipeline();
             if (pPipeline != nullptr) {
                 pPipeline->ModifyPath(modifiedPath, m_pPluginProvider);
+            } else if (!m_PipelineError.empty()) {
+                modifiedPath = ATL::CStringW(m_PipelineError.c_str());
             }
             return modifiedPath;
         }

diff --git a/PathCopyCopy/prihdr/PluginPipeline.h b/PathCopyCopy/prihdr/PluginPipeline.h
@@ -24,6 +24,7 @@
 #include "PathCopyCopyPrivateTypes.h"
 #include "PluginProvider.h"
 
+#include <exception>
 #include <string>
 
 
@@ -70,8 +71,8 @@ namespace PCC
                         Pipeline(const Pipeline&) = delete;
         Pipeline&       operator=(const Pipeline&) = delete;
 
-        bool            Valid(const PluginProvider* p_pPluginProvider,
-                              GUIDS& p_rsSeenPluginIds) const;
+        void            Validate(const PluginProvider* p_pPluginProvider,
+                                 GUIDS& p_rsSeenPluginIds) const;
 
         void            ModifyPath(std::wstring& p_rPath,
                                    const PluginProvider* p_pPluginProvider) const;
@@ -100,8 +101,8 @@ namespace PCC
         PipelineElement& operator=(PipelineElement&&) = delete;
         virtual         ~PipelineElement() = default;
 
-        virtual bool    Valid(const PluginProvider* p_pPluginProvider,
-                              GUIDS& p_rsSeenPluginIds) const noexcept(false);
+        virtual void    Validate(const PluginProvider* p_pPluginProvider,
+                                 GUIDS& p_rsSeenPluginIds) const noexcept(false);
 
         virtual void    ModifyPath(std::wstring& p_rPath,
                                    const PluginProvider* p_pPluginProvider) const = 0;
@@ -111,4 +112,15 @@ namespace PCC
                                            const PluginProvider* p_pPluginProvider) const noexcept(false);
     };
 
+    //
+    // Exception type thrown when a pipeline is invalid.
+    //
+    class InvalidPipelineException : public std::runtime_error
+    {
+    public:
+                        [[gsl::suppress(f.6)]]
+                        InvalidPipelineException();
+        explicit        InvalidPipelineException(const char* p_pWhat);
+    };
+
 } // namespace PCC
diff --git a/PathCopyCopy/prihdr/PluginPipelineDecoder.h b/PathCopyCopy/prihdr/PluginPipelineDecoder.h
@@ -23,7 +23,6 @@
 
 #include "PathCopyCopyPrivateTypes.h"
 
-#include <exception>
 #include <string>
 
 
@@ -56,8 +55,6 @@ namespace PCC
             EncodedElementsStream&
                         operator=(const EncodedElementsStream&) = delete;
 
-            auto        GetEncodedElements() const noexcept -> const std::wstring&;
-
             auto        ReadData(std::wstring::size_type p_DataSize) -> std::wstring;
             auto        ReadElementCount() -> size_t;
             auto        ReadLong() -> long;
@@ -82,22 +79,4 @@ namespace PCC
                                                 EncodedElementsStream& p_rStream) -> PipelineElementSP;
     };
 
-    //
-    // Exception type thrown when a encoded pipeline string is invalid.
-    //
-    class InvalidPipelineException : public std::exception
-    {
-    public:
-                        InvalidPipelineException() noexcept;
-        explicit        InvalidPipelineException(const std::wstring& p_EncodedElements);
-
-        const std::wstring&
-                        EncodedElements() const noexcept;
-
-        const char*     what() const noexcept override;
-
-    private:
-        std::wstring    m_EncodedElements;      // The pipeline's encoded string.
-    };
-
 } // namespace PCC
diff --git a/PathCopyCopy/prihdr/PluginPipelineElements.h b/PathCopyCopy/prihdr/PluginPipelineElements.h
@@ -308,8 +308,8 @@ namespace PCC
         ApplyPipelinePluginPipelineElement&
                         operator=(const ApplyPipelinePluginPipelineElement&) = delete;
 
-        bool            Valid(const PluginProvider* p_pPluginProvider,
-                              GUIDS& p_rsSeenPluginIds) const override;
+        void            Validate(const PluginProvider* p_pPluginProvider,
+                                 GUIDS& p_rsSeenPluginIds) const override;
     };
 
     //

diff --git a/PathCopyCopy/rsrc/PathCopyCopy.rc b/PathCopyCopy/rsrc/PathCopyCopy.rc
@@ -193,6 +193,11 @@ BEGIN
     IDS_MSYS_PATH_PLUGIN_DESCRIPTION "Copy MS&YS/MSYS2 Path"
     IDS_MSYS_PATH_PLUGIN_HINT 
                             "Copies the path of the file/folder to the clipboard in MSYS/MSYS2 format."
+    IDS_INVALIDPIPELINE     "<< Invalid custom command >>"
+    IDS_INVALIDPIPELINE_LOOP_DETECTED 
+                            "<< Loop detected in custom command elements >>"
+    IDS_INVALIDPIPELINE_POSSIBLE_DOWNGRADE 
+                            "<< Invalid custom command element (possible downgrade) >>"
 END
 
 #endif    // English (United States) resources

diff --git a/PathCopyCopy/rsrc/resource.h b/PathCopyCopy/rsrc/resource.h
@@ -54,6 +54,9 @@
 #define IDS_SAMBA_PATH_PLUGIN_HINT      148
 #define IDS_MSYS_PATH_PLUGIN_DESCRIPTION 149
 #define IDS_MSYS_PATH_PLUGIN_HINT       150
+#define IDS_INVALIDPIPELINE             151
+#define IDS_INVALIDPIPELINE_LOOP_DETECTED 152
+#define IDS_INVALIDPIPELINE_POSSIBLE_DOWNGRADE 153
 #define IDR_PATHCOPYCOPYCONTEXTMENUEXT  201
 #define IDR_PATHCOPYCOPYDATAHANDLER     202
 #define IDR_PATHCOPYCOPYCONFIGHELPER    203

diff --git a/PathCopyCopy/src/PluginPipeline.cpp b/PathCopyCopy/src/PluginPipeline.cpp
@@ -117,19 +117,20 @@ namespace PCC
     // Validates the pipeline. A pipeline is valid if all its elements
     // are considered valid.
     //
+    // When the pipeline is invalid, an InvalidPipelineException is thrown.
+    //
     // @param p_pPluginProvider Optional plugin provider that can be used
     //                          during validation.
     // @param p_rsSeenPluginIds Set that should be used to store seen plugin IDs.
     //                          Any collision means a loop is detected and
     //                          pipeline should be considered invalid.
-    // @return true if the pipeline is valid.
     //
-    bool Pipeline::Valid(const PluginProvider* const p_pPluginProvider,
-                         GUIDS& p_rsSeenPluginIds) const
+    void Pipeline::Validate(const PluginProvider* const p_pPluginProvider,
+                            GUIDS& p_rsSeenPluginIds) const
     {
-        return std::all_of(m_vspElements.cbegin(), m_vspElements.cend(), [&](const auto& spElement) {
-            return spElement->Valid(p_pPluginProvider, p_rsSeenPluginIds);
-        });
+        for (const auto& spElement : m_vspElements) {
+            spElement->Validate(p_pPluginProvider, p_rsSeenPluginIds);
+        }
     }
 
 
@@ -143,7 +144,7 @@ namespace PCC
     void Pipeline::ModifyPath(std::wstring& p_rPath,
                               const PluginProvider* const p_pPluginProvider) const
     {
-        for (const PipelineElementSP& spElement : m_vspElements) {
+        for (const auto& spElement : m_vspElements) {
             spElement->ModifyPath(p_rPath, p_pPluginProvider);
         }
     }
@@ -156,7 +157,7 @@ namespace PCC
     //
     void Pipeline::ModifyOptions(PipelineOptions& p_rOptions) const
     {
-        for (const PipelineElementSP& spElement : m_vspElements) {
+        for (const auto& spElement : m_vspElements) {
             spElement->ModifyOptions(p_rOptions);
         }
     }
@@ -184,18 +185,19 @@ namespace PCC
     // is implementation-specific, but should be used to detect recursion
     // in plugin usage, for instance.
     //
+    // When the pipeline element is invalid, an InvalidPipelineException
+    // should be thrown.
+    //
     // @param p_pPluginProvider Optional plugin provider that can be used
     //                          during validation.
     // @param p_rsSeenPluginIds Set that should be used to store seen plugin IDs.
     //                          Any collision means a loop is detected and
     //                          pipeline element should be considered invalid.
-    // @return true if pipeline element is valid.
     //
-    bool PipelineElement::Valid(const PluginProvider* const /*p_pPluginProvider*/,
-                                GUIDS& /*p_rsSeenPluginIds*/) const noexcept(false)
+    void PipelineElement::Validate(const PluginProvider* const /*p_pPluginProvider*/,
+                                   GUIDS& /*p_rsSeenPluginIds*/) const noexcept(false)
     {
         // All pipeline elements are considered valid by default.
-        return true;
     }
 
     //
@@ -224,4 +226,22 @@ namespace PCC
         return true;
     }
 
+    //
+    // Default constructor.
+    //
+    InvalidPipelineException::InvalidPipelineException()
+        : std::runtime_error(ATL::CStringA(MAKEINTRESOURCEA(IDS_INVALIDPIPELINE)))
+    {
+    }
+
+    //
+    // Constructor with explanation string.
+    //
+    // @param p_pWhat Explanation string.
+    //
+    InvalidPipelineException::InvalidPipelineException(const char* const p_pWhat)
+        : std::runtime_error(p_pWhat)
+    {
+    }
+
 } // namespace PCC