Use view for filtering window actions + window action router spec

6 files changed, 211 insertions, 13 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 07dce10..a01fab3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,14 +15,14 @@ set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib")
 set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
 find_package(PkgConfig REQUIRED)
 
-message(COMMENT "${CMAKE_INSTALL_PREFIX} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}")
+# message(COMMENT "${CMAKE_INSTALL_PREFIX} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}")
 
 # Lua path
 if(NOT DEFINED CMAKE_INSTALL_PREFIX OR NOT CMAKE_INSTALL_PREFIX)
   message(FATAL_ERROR "CMAKE_INSTALL_PREFIX not defined")
 endif()
 set(PROJECT_TARGET_PATH "${CMAKE_INSTALL_PREFIX}")
-message(COMMENT "${PROJECT_TARGET_PATH}")
+message(COMMENT " Installed in: ${PROJECT_TARGET_PATH}")
 add_compile_definitions(PROJECT_LUA_PATH="${PROJECT_TARGET_PATH}/lua"
                         PROJECT_DOCS_PATH="${PROJECT_TARGET_PATH}/docs"
                         PROJECT_ASSETS_PATH="${PROJECT_TARGET_PATH}/assets")
diff --git a/spec/WindowActionRouterSpec.cpp b/spec/WindowActionRouterSpec.cpp
new file mode 100644
index 0000000..71a679d
--- /dev/null
+++ b/spec/WindowActionRouterSpec.cpp
@@ -0,0 +1,177 @@
+#include <optional>
+#include <vector>
+
+#include "Configuration.hpp"
+#include "LuaRuntime.hpp"
+#include "WindowActionRouter.hpp"
+#include "testUtils.h"
+#include "widgets/BrowserWindow.hpp"
+
+// NOLINTBEGIN
+class WindowActionRouterSpec : public QObject {
+  Q_OBJECT
+
+  class WindowActionRouterPub : public WindowActionRouter {
+  public:
+    using WindowActionRouter::WindowActionRouter, WindowActionRouter::get_relevant_windows;
+  };
+
+private slots:
+  void beforeTestCase() { LuaRuntime::instance().start_event_loop(); }
+  void cleanupTestCase() { LuaRuntime::instance().stop_event_loop(); }
+
+  void test_add_window() {
+    describe("#add_window");
+
+    it("adds new window with incrementing assigned ids") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      QCOMPARE(window_action_router.windows(), (WindowMap{{1, &win1}, {2, &win2}, {3, &win3}}));
+      QCOMPARE(win1.get_id(), 1);
+      QCOMPARE(win2.get_id(), 2);
+      QCOMPARE(win3.get_id(), 3);
+    }
+  }
+
+  void test_get_relevant_windows() {
+    describe("#get_relevant_windows");
+
+    context("when no filters are provided");
+    it("returns all defined windows") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      const auto &windows = window_action_router.get_relevant_windows();
+
+      QCOMPARE(windows.size(), 3);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win3, &win2, &win1}));
+    }
+
+    context("when win_id filter is 0");
+    it("returns only the active window") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+      activate_window(&win3);
+
+      const auto &windows = window_action_router.get_relevant_windows(std::make_optional(0));
+
+      QCOMPARE(windows.size(), 1);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win3}));
+    }
+
+    context("when win_id filter is provided (non-zero)");
+    it("returns only the window with that id") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      const auto &windows = window_action_router.get_relevant_windows(std::make_optional(2));
+
+      QCOMPARE(windows.size(), 1);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win2}));
+    }
+
+    context("when view_id filter is provided");
+    it("returns only the window containing the view") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      auto view_id = win2.get_webview_list()[0].id; // Using first view from window 2
+      const auto &windows =
+          window_action_router.get_relevant_windows(std::nullopt, std::make_optional(view_id));
+
+      QCOMPARE(windows.size(), 1);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win2}));
+    }
+
+    context("when both win_id and view_id are provided");
+    context("when given view exists inside given window");
+    it("returns only the window containing the view") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      auto view_id = win2.get_webview_list()[0].id; // Using first view from window 2
+      auto win_id = win2.get_id();
+      const auto &windows = window_action_router.get_relevant_windows(std::make_optional(win_id),
+                                                                      std::make_optional(view_id));
+
+      QCOMPARE(windows.size(), 1);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win2}));
+    }
+
+    context("when both win_id and view_id are provided");
+    context("when given view exists inside given window");
+    it("returns only the window containing the view") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      auto view_id = win2.get_webview_list()[0].id; // Using first view from window 2
+      auto win_id = win2.get_id();
+      const auto &windows = window_action_router.get_relevant_windows(std::make_optional(win_id),
+                                                                      std::make_optional(view_id));
+
+      QCOMPARE(windows.size(), 1);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{&win2}));
+    }
+
+    context("when both win_id and view_id are provided");
+    context("when given view is not inside given window");
+    it("returns only the window containing the view") {
+      WindowActionRouterPub window_action_router;
+      Configuration configuration;
+      window_action_router.initialize(&configuration);
+      BrowserWindow win1(configuration), win2(configuration), win3(configuration);
+      window_action_router.add_window(&win1);
+      window_action_router.add_window(&win2);
+      window_action_router.add_window(&win3);
+
+      auto view_id = win3.get_webview_list()[0].id; // Using first view from window 3
+      auto win_id = win2.get_id();
+      const auto &windows = window_action_router.get_relevant_windows(std::make_optional(win_id),
+                                                                      std::make_optional(view_id));
+
+      QCOMPARE(windows.size(), 0);
+      QCOMPARE(windows, (std::vector<BrowserWindow *>{}));
+    }
+  }
+};
+
+QTEST_REGISTER(WindowActionRouterSpec)
+#include "WindowActionRouterSpec.moc"
+// NOLINTEND
diff --git a/spec/testUtils.cpp b/spec/testUtils.cpp
index c359e91..e5c9e96 100644
--- a/spec/testUtils.cpp
+++ b/spec/testUtils.cpp
@@ -1,6 +1,8 @@
 #include <QtTest/QtTest>
 #include <QtTest/qtestcase.h>
 #include <cstdio>
+#include <qmainwindow.h>
+#include <qtestsupport_widgets.h>
 
 #include "LuaRuntime.hpp"
 
@@ -65,3 +67,9 @@ bool wait_for_lua_to_be_true(QString lua_code) {
     return evaluation_completed_spy.first().first().toBool();
   });
 }
+
+void activate_window(QMainWindow *win) {
+  win->show();
+  QVERIFY(QTest::qWaitForWindowExposed(win));
+  QTRY_VERIFY(win->isActiveWindow());
+}
diff --git a/spec/testUtils.h b/spec/testUtils.h
index 392f0bb..f000c5e 100644
--- a/spec/testUtils.h
+++ b/spec/testUtils.h
@@ -3,6 +3,7 @@
 #include <QtTest/QtTest>
 #include <QtTest/qtestcase.h>
 #include <cstdio>
+#include <qmainwindow.h>
 
 #define NOT !
 
@@ -50,3 +51,4 @@ int run_lua_tests();
   };
 
 bool wait_for_lua_to_be_true(QString lua_code);
+void activate_window(QMainWindow *win);
diff --git a/src/WindowActionRouter.cpp b/src/WindowActionRouter.cpp
index 7971024..8231fa0 100644
--- a/src/WindowActionRouter.cpp
+++ b/src/WindowActionRouter.cpp
@@ -160,8 +160,6 @@ void WindowActionRouter::add_window(BrowserWindow *window) {
           &WindowActionRouter::new_window_requested);
 }
 
-const WindowMap &WindowActionRouter::windows() { return window_map; }
-
 void WindowActionRouter::add_keymap(const QString &mode_string, const QString &keyseq,
                                     std::function<void()> action) {
   auto &keymap_evaluator = KeymapEvaluator::instance();
@@ -199,20 +197,31 @@ std::optional<WebViewId> WindowActionRouter::fetch_get_decoration_view_id(Decora
 }
 
 std::vector<BrowserWindow *>
-WindowActionRouter::get_relevant_windows(std::optional<WindowId> win_id) {
+WindowActionRouter::get_relevant_windows(std::optional<WindowId> win_id,
+                                         std::optional<WebViewId> view_id) {
   const std::lock_guard<std::mutex> lock(window_map_mutex);
   std::vector<BrowserWindow *> windows;
 
   if (!win_id.has_value()) {
-    for (auto &win_pair : window_map)
-      windows.push_back(win_pair.second);
-  } else if (win_id.value() == 0) {
     for (auto &win_pair : window_map) {
-      if (win_pair.second->isActiveWindow())
+      // TODO: If view is 0, use active window
+      if (!view_id.has_value() || win_pair.second->has_webview(view_id.value())) {
         windows.push_back(win_pair.second);
+      }
+    }
+  } else if (win_id.value() == 0) {
+    for (auto &win_pair : window_map) {
+      if (win_pair.second->isActiveWindow()) {
+        if (!view_id.has_value() || win_pair.second->has_webview(view_id.value())) {
+          windows.push_back(win_pair.second);
+        }
+      }
     }
   } else if (win_id.value() > 0 && window_map.contains(win_id.value())) {
-    windows.push_back(window_map.at(win_id.value()));
+    auto *win = window_map.at(win_id.value());
+    if (!view_id.has_value() || win->has_webview(view_id.value())) {
+      windows.push_back(win);
+    }
   }
 
   return windows;
diff --git a/src/WindowActionRouter.hpp b/src/WindowActionRouter.hpp
index efc54ca..7982667 100644
--- a/src/WindowActionRouter.hpp
+++ b/src/WindowActionRouter.hpp
@@ -34,7 +34,7 @@ public:
   void initialize(Configuration *config);
 
   void add_window(BrowserWindow *window);
-  const WindowMap &windows();
+  const WindowMap &windows() { return window_map; }
 
   WebViewId fetch_current_view_id(WindowId win_id = 0);
   QList<WebViewData> fetch_webview_data_list(WindowId win_id = 0);
@@ -49,12 +49,14 @@ public:
   DELEGATE(&event_queue, dispatch_event, dispatch_event)
   DELEGATE(&event_queue, register_event, register_event)
 
-private:
+protected:
   WindowActionRouter() = default;
 
   void add_keymap(const QString &mode_string, const QString &keyseq, std::function<void()> action);
   void find_current_search_text(WebViewId webview_id, bool forward);
-  std::vector<BrowserWindow *> get_relevant_windows(std::optional<WindowId> win_id);
+  std::vector<BrowserWindow *>
+  get_relevant_windows(std::optional<WindowId> win_id = std::nullopt,
+                       std::optional<WebViewId> view_id = std::nullopt);
 
 signals:
   void new_window_requested(const QUrl &url);