Implement data_listcontents block

Author: adazem009

src/blocks/listblocks.cpp

@@ -3,6 +3,7 @@
 #include <scratchcpp/iengine.h>
 #include <scratchcpp/compiler.h>
 #include <scratchcpp/compilerconstant.h>
+#include <scratchcpp/block.h>
 #include <scratchcpp/field.h>
 #include <scratchcpp/list.h>
 
@@ -27,6 +28,8 @@ Rgb ListBlocks::color() const
 
 void ListBlocks::registerBlocks(IEngine *engine)
 {
+    // Blocks
+    engine->addCompileFunction(this, "data_listcontents", &compileListContents);
     engine->addCompileFunction(this, "data_addtolist", &compileAddToList);
     engine->addCompileFunction(this, "data_deleteoflist", &compileDeleteOfList);
     engine->addCompileFunction(this, "data_deletealloflist", &compileDeleteAllOfList);
@@ -36,6 +39,24 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_itemnumoflist", &compileItemNumOfList);
     engine->addCompileFunction(this, "data_lengthoflist", &compileLengthOfList);
     engine->addCompileFunction(this, "data_listcontainsitem", &compileListContainsItem);
+
+    // Monitor names
+    engine->addMonitorNameFunction(this, "data_listcontents", &listContentsMonitorName);
+}
+
+CompilerValue *ListBlocks::compileListContents(Compiler *compiler)
+{
+    auto list = compiler->field("LIST")->valuePtr();
+    assert(list);
+
+    // If this block is used in a list monitor, return the list pointer
+    if (compiler->block()->isMonitorBlock()) {
+        // TODO: Refactor this
+        // List monitors expect a reference to the list
+        // We don't have a list reference type, so cast the pointer to number
+        return compiler->addConstValue((uintptr_t)list.get());
+    } else
+        return compiler->addListContents(static_cast<List *>(list.get()));
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -194,3 +215,19 @@ CompilerValue *ListBlocks::compileListContainsItem(Compiler *compiler)
 
     return nullptr;
 }
+
+const std::string &ListBlocks::listContentsMonitorName(Block *block)
+{
+    static const std::string empty = "";
+    auto field = block->fieldAt(block->findField("LIST"));
+
+    if (!field)
+        return empty;
+
+    List *list = dynamic_cast<List *>(field->valuePtr().get());
+
+    if (list)
+        return list->name();
+    else
+        return empty;
+}

src/blocks/listblocks.h

@@ -19,6 +19,7 @@ class ListBlocks : public IExtension
         void registerBlocks(IEngine *engine) override;
 
     private:
+        static CompilerValue *compileListContents(Compiler *compiler);
         static CompilerValue *compileAddToList(Compiler *compiler);
         static CompilerValue *getListIndex(Compiler *compiler, CompilerValue *input, List *list, CompilerValue *listSize);
         static CompilerValue *compileDeleteOfList(Compiler *compiler);
@@ -29,6 +30,8 @@ class ListBlocks : public IExtension
         static CompilerValue *compileItemNumOfList(Compiler *compiler);
         static CompilerValue *compileLengthOfList(Compiler *compiler);
         static CompilerValue *compileListContainsItem(Compiler *compiler);
+
+        static const std::string &listContentsMonitorName(Block *block);
 };
 
 } // namespace libscratchcpp

test/blocks/list_blocks_test.cpp

@@ -8,10 +8,12 @@
 #include <scratchcpp/block.h>
 #include <scratchcpp/input.h>
 #include <scratchcpp/field.h>
+#include <scratchcpp/monitor.h>
 #include <scratchcpp/executioncontext.h>
 #include <scratchcpp/executablecode.h>
 #include <enginemock.h>
 #include <randomgeneratormock.h>
+#include <monitorhandlermock.h>
 
 #include "../common.h"
 #include "util.h"
@@ -21,6 +23,8 @@ using namespace libscratchcpp;
 using namespace libscratchcpp::test;
 
 using ::testing::Return;
+using ::testing::Invoke;
+using ::testing::_;
 
 class ListBlocksTest : public testing::Test
 {
@@ -40,6 +44,81 @@ class ListBlocksTest : public testing::Test
         RandomGeneratorMock m_rng;
 };
 
+TEST_F(ListBlocksTest, ListContents)
+{
+    auto target = std::make_shared<Sprite>();
+    auto list1 = std::make_shared<List>("", "");
+    target->addList(list1);
+    auto list2 = std::make_shared<List>("", "");
+    target->addList(list2);
+
+    list1->append(1);
+    list1->append(2);
+    list1->append(4);
+
+    list2->append("Lorem");
+    list2->append("ipsum");
+    list2->append("dolor");
+    list2->append("sit");
+    list2->append("amet");
+
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    builder.addBlock("data_listcontents");
+    builder.addEntityField("LIST", list1);
+    builder.captureBlockReturnValue();
+
+    builder.addBlock("data_listcontents");
+    builder.addEntityField("LIST", list2);
+    builder.captureBlockReturnValue();
+
+    builder.build();
+
+    builder.run();
+    List *list = builder.capturedValues();
+    ValueData *data = list->data();
+    ASSERT_EQ(list->size(), 2);
+    ASSERT_EQ(Value(data[0]).toString(), "124");
+    ASSERT_EQ(Value(data[1]).toString(), "Lorem ipsum dolor sit amet");
+}
+
+TEST_F(ListBlocksTest, ListMonitor)
+{
+    auto target = std::make_shared<Sprite>();
+    auto list1 = std::make_shared<List>("", "list1");
+    target->addList(list1);
+    auto list2 = std::make_shared<List>("", "list2");
+    target->addList(list2);
+
+    MonitorHandlerMock iface1, iface2;
+    EXPECT_CALL(iface1, init);
+    EXPECT_CALL(iface2, init);
+
+    auto monitor1 = std::make_shared<Monitor>("monitor", "data_listcontents");
+    auto monitor2 = std::make_shared<Monitor>("monitor", "data_listcontents");
+    monitor1->block()->setTarget(target.get());
+    monitor1->setInterface(&iface1);
+    monitor2->block()->setTarget(target.get());
+    monitor2->setInterface(&iface2);
+    m_engine->setMonitors({ monitor1, monitor2 });
+
+    ScriptBuilder builder1(m_extension.get(), m_engine, target);
+    builder1.addBlock(monitor1->block());
+    builder1.addEntityField("LIST", list1);
+
+    ScriptBuilder builder2(m_extension.get(), m_engine, target);
+    builder2.addBlock(monitor2->block());
+    builder2.addEntityField("LIST", list2);
+
+    m_engine->compile();
+    ASSERT_EQ(monitor1->name(), list1->name());
+    ASSERT_EQ(monitor2->name(), list2->name());
+
+    EXPECT_CALL(iface1, onValueChanged(_)).WillOnce(Invoke([list1](const Value &value) { ASSERT_EQ(value.toDouble(), (uintptr_t)list1.get()); }));
+    EXPECT_CALL(iface2, onValueChanged(_)).WillOnce(Invoke([list2](const Value &value) { ASSERT_EQ(value.toDouble(), (uintptr_t)list2.get()); }));
+    m_engine->updateMonitors();
+}
+
 TEST_F(ListBlocksTest, AddToList)
 {
     auto target = std::make_shared<Sprite>();