Add a way to register image formats

Author: adazem009

include/scratchcpp/scratchconfiguration.h

@@ -11,6 +11,8 @@ namespace libscratchcpp
 {
 
 class IExtension;
+class IImageFormat;
+class IImageFormatFactory;
 class ScratchConfigurationPrivate;
 
 /*! \brief The ScratchConfiguration class provides methods for adding custom extensions. */
@@ -35,6 +37,10 @@ class LIBSCRATCHCPP_EXPORT ScratchConfiguration
             return nullptr;
         };
 
+        static void registerImageFormat(const std::string &name, std::shared_ptr<IImageFormatFactory> formatFactory);
+        static void removeImageFormat(const std::string &name);
+        static std::shared_ptr<IImageFormat> createImageFormat(const std::string &name);
+
     private:
         static const std::vector<std::shared_ptr<IExtension>> getExtensions();
 

src/scratchconfiguration.cpp

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/scratchconfiguration.h>
+#include <scratchcpp/iimageformatfactory.h>
 
 #include "scratchconfiguration_p.h"
 #include "blocks/standardblocks.h"
+#include "imageformats/stub/imageformatstub.h"
 
 using namespace libscratchcpp;
 
@@ -21,6 +23,29 @@ IExtension *ScratchConfiguration::getExtension(const std::string &name)
     return impl->getExtension(name);
 }
 
+/*! Registers the given image format. */
+void ScratchConfiguration::registerImageFormat(const std::string &name, std::shared_ptr<IImageFormatFactory> formatFactory)
+{
+    impl->imageFormats[name] = formatFactory;
+}
+
+/*! Removes the given image format. */
+void ScratchConfiguration::removeImageFormat(const std::string &name)
+{
+    impl->imageFormats.erase(name);
+}
+
+/*! Creates an instance of the given image format. If the format doesn't exist, a "stub" format will be created. */
+std::shared_ptr<IImageFormat> ScratchConfiguration::createImageFormat(const std::string &name)
+{
+    auto it = impl->imageFormats.find(name);
+
+    if (it == impl->imageFormats.cend())
+        return std::make_shared<ImageFormatStub>(); // use stub if the format doesn't exist
+    else
+        return it->second->createInstance();
+}
+
 const std::vector<std::shared_ptr<IExtension>> ScratchConfiguration::getExtensions()
 {
     return impl->extensions;

src/scratchconfiguration_p.h

@@ -7,18 +7,21 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <unordered_map>
 
 namespace libscratchcpp
 {
 
 class IExtension;
+class IImageFormatFactory;
 
 struct ScratchConfigurationPrivate
 {
         void registerExtension(std::shared_ptr<IExtension> extension);
         IExtension *getExtension(std::string name);
 
         std::vector<std::shared_ptr<IExtension>> extensions = { std::make_shared<StandardBlocks>() };
+        std::unordered_map<std::string, std::shared_ptr<IImageFormatFactory>> imageFormats;
 };
 
 } // namespace libscratchcpp

test/mocks/imageformatfactorymock.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <scratchcpp/iimageformatfactory.h>
+#include <gmock/gmock.h>
+
+using namespace libscratchcpp;
+
+class ImageFormatFactoryMock : public IImageFormatFactory
+{
+    public:
+        MOCK_METHOD(std::shared_ptr<IImageFormat>, createInstance, (), (const, override));
+};

test/scratchconfiguration/CMakeLists.txt

@@ -14,7 +14,9 @@ add_executable(
 target_link_libraries(
   scratchconfiguration_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(scratchconfiguration_test)

test/scratchconfiguration/scratchconfiguration_test.cpp

@@ -1,12 +1,16 @@
 #include <scratchcpp/scratchconfiguration.h>
+#include <imageformatfactorymock.h>
 
 #include "../common.h"
+#include "imageformats/stub/imageformatstub.h"
 #include "extension1.h"
 #include "extension2.h"
 #include "extension3.h"
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
 class ScratchConfigurationTest : public testing::Test
 {
     public:
@@ -15,11 +19,15 @@ class ScratchConfigurationTest : public testing::Test
             m_extension1 = std::make_shared<Extension1>();
             m_extension2 = std::make_shared<Extension2>();
             m_extension3 = std::make_shared<Extension3>();
+            m_imageFormatMock1 = std::make_shared<ImageFormatFactoryMock>();
+            m_imageFormatMock2 = std::make_shared<ImageFormatFactoryMock>();
         }
 
         std::shared_ptr<IExtension> m_extension1;
         std::shared_ptr<IExtension> m_extension2;
         std::shared_ptr<IExtension> m_extension3;
+        std::shared_ptr<ImageFormatFactoryMock> m_imageFormatMock1;
+        std::shared_ptr<ImageFormatFactoryMock> m_imageFormatMock2;
 };
 
 TEST_F(ScratchConfigurationTest, Extensions)
@@ -35,3 +43,40 @@ TEST_F(ScratchConfigurationTest, Extensions)
     ASSERT_EQ(ScratchConfiguration::getExtension<Extension2>(), m_extension2.get());
     ASSERT_EQ(ScratchConfiguration::getExtension<Extension3>(), nullptr);
 }
+
+TEST_F(ScratchConfigurationTest, ImageFormats)
+{
+    ScratchConfiguration::registerImageFormat("format1", m_imageFormatMock1);
+    ScratchConfiguration::registerImageFormat("format2", m_imageFormatMock2);
+    auto format1 = std::make_shared<ImageFormatStub>();
+    auto format2 = std::make_shared<ImageFormatStub>();
+
+    EXPECT_CALL(*m_imageFormatMock1, createInstance()).WillOnce(Return(format1));
+    ASSERT_EQ(ScratchConfiguration::createImageFormat("format1"), format1);
+
+    EXPECT_CALL(*m_imageFormatMock2, createInstance()).WillOnce(Return(format2));
+    ASSERT_EQ(ScratchConfiguration::createImageFormat("format2"), format2);
+
+    auto format = ScratchConfiguration::createImageFormat("format3");
+    IImageFormat *unsupportedFormat = format.get();
+    ASSERT_TRUE(unsupportedFormat);
+    ASSERT_TRUE(dynamic_cast<ImageFormatStub *>(unsupportedFormat));
+
+    ScratchConfiguration::removeImageFormat("format1");
+    format = ScratchConfiguration::createImageFormat("format1");
+    unsupportedFormat = format.get();
+    ASSERT_TRUE(unsupportedFormat);
+    ASSERT_TRUE(dynamic_cast<ImageFormatStub *>(unsupportedFormat));
+
+    EXPECT_CALL(*m_imageFormatMock2, createInstance()).WillOnce(Return(format2));
+    ASSERT_EQ(ScratchConfiguration::createImageFormat("format2"), format2);
+
+    ScratchConfiguration::removeImageFormat("format2");
+    format = ScratchConfiguration::createImageFormat("format2");
+    unsupportedFormat = format.get();
+    ASSERT_TRUE(unsupportedFormat);
+    ASSERT_TRUE(dynamic_cast<ImageFormatStub *>(unsupportedFormat));
+
+    testing::Mock::AllowLeak(m_imageFormatMock1.get());
+    testing::Mock::AllowLeak(m_imageFormatMock2.get());
+}