Merge pull request #339 from Ph4ntomas/324-output_handle-active_tags

api: add [in]active tags filtering to OutputHandle

Author: Ottatop

api/lua/pinnacle/output.lua

@@ -756,6 +756,62 @@ function OutputHandle:tags()
     return handles
 end
 
+---Gets the active tags this output has.
+---
+---@return pinnacle.tag.TagHandle[]
+function OutputHandle:active_tags()
+    local tags = self:tags()
+
+    ---@type (fun(): boolean)[]
+    local batch = {}
+    for i, tag in ipairs(tags) do
+        batch[i] = function()
+            return tag:active()
+        end
+    end
+
+    local responses = require("pinnacle.util").batch(batch)
+
+    ---@type pinnacle.tag.TagHandle[]
+    local active_tags = {}
+
+    for i, is_active in ipairs(responses) do
+        if is_active then
+            table.insert(active_tags, tags[i])
+        end
+    end
+
+    return active_tags
+end
+
+---Gets the inactive tags this output has.
+---
+---@return pinnacle.tag.TagHandle[]
+function OutputHandle:inactive_tags()
+    local tags = self:tags()
+
+    ---@type (fun(): boolean)[]
+    local batch = {}
+    for i, tag in ipairs(tags) do
+        batch[i] = function()
+            return not tag:active()
+        end
+    end
+
+    local responses = require("pinnacle.util").batch(batch)
+
+    ---@type pinnacle.tag.TagHandle[]
+    local inactive_tags = {}
+
+    for i, is_active in ipairs(responses) do
+        if is_active then
+            table.insert(inactive_tags, tags[i])
+        end
+    end
+
+    return inactive_tags
+end
+
 ---Get this output's scale.
 ---
 ---@return number

api/rust/src/output.rs

@@ -856,6 +856,30 @@ impl OutputHandle {
             .map(|id| TagHandle { id })
     }
 
+    /// Gets handles to all active tags on this output.
+    pub fn active_tags(&self) -> impl Iterator<Item = TagHandle> + use<> {
+        self.active_tags_async().block_on_tokio()
+    }
+
+    /// Async impl for [`Self::active_tags`].
+    pub async fn active_tags_async(&self) -> impl Iterator<Item = TagHandle> + use<> {
+        self.tags_async()
+            .await
+            .batch_filter(|tag| tag.active_async().boxed(), |is_active| is_active)
+    }
+
+    /// Gets handles to all inactive tags on this output.
+    pub fn inactive_tags(&self) -> impl Iterator<Item = TagHandle> + use<> {
+        self.inactive_tags_async().block_on_tokio()
+    }
+
+    /// Async impl for [`Self::active_tags`].
+    pub async fn inactive_tags_async(&self) -> impl Iterator<Item = TagHandle> + use<> {
+        self.tags_async()
+            .await
+            .batch_filter(|tag| tag.active_async().boxed(), |is_active| !is_active)
+    }
+
     /// Gets this output's current scale.
     pub fn scale(&self) -> f32 {
         self.scale_async().block_on_tokio()

tests/integration/api/output.rs

@@ -811,6 +811,107 @@ fn output_handle_tags() {
     }
 }
 
+#[test_log::test]
+fn output_handle_active_tags() {
+    for_each_api(|lang| {
+        let (mut fixture, output, _) = set_up();
+
+        fixture.pinnacle().focus_output(&output);
+
+        output.with_state_mut(|state| {
+            let tag2 = Tag::new("2".to_string());
+            tag2.set_active(false);
+
+            let tag3 = Tag::new("3".to_string());
+            tag3.set_active(true);
+
+            state.add_tags([tag2, tag3]);
+        });
+
+        match lang {
+            Lang::Rust => fixture.spawn_blocking(move || {
+                let mut tags = pinnacle_api::output::get_focused()
+                    .unwrap()
+                    .active_tags()
+                    .map(|t| t.name())
+                    .collect::<Vec<_>>();
+
+                tags.sort();
+
+                assert_eq!(tags.len(), 2);
+                assert_eq!(tags.as_slice(), ["1", "3"]);
+            }),
+            Lang::Lua => spawn_lua_blocking! {
+                fixture,
+                local tags = Output.get_focused():active_tags()
+                assert(#tags == 2)
+
+                local tagnames = {}
+                for k, v in ipairs(tags) do
+                    tagnames[k] = v:name()
+                end
+
+                table.sort(tagnames)
+
+                assert(tagnames[1] == "1")
+                assert(tagnames[2] == "3")
+            },
+        };
+    })
+}
+
+#[test_log::test]
+fn output_handle_inactive_tags() {
+    for_each_api(|lang| {
+        let (mut fixture, output, _) = set_up();
+
+        fixture.pinnacle().focus_output(&output);
+
+        output.with_state_mut(|state| {
+            let tag2 = Tag::new("2".to_string());
+            tag2.set_active(false);
+
+            let tag3 = Tag::new("3".to_string());
+            tag3.set_active(false);
+
+            let tag4 = Tag::new("4".to_string());
+            tag4.set_active(true);
+
+            state.add_tags([tag2, tag3, tag4]);
+        });
+
+        match lang {
+            Lang::Rust => fixture.spawn_blocking(move || {
+                let mut tags = pinnacle_api::output::get_focused()
+                    .unwrap()
+                    .inactive_tags()
+                    .map(|t| t.name())
+                    .collect::<Vec<_>>();
+
+                tags.sort();
+
+                assert_eq!(tags.len(), 2);
+                assert_eq!(tags.as_slice(), ["2", "3"]);
+            }),
+            Lang::Lua => spawn_lua_blocking! {
+                fixture,
+                local tags = Output.get_focused():inactive_tags()
+                assert(#tags == 2)
+
+                local tagnames = {}
+                for k, v in ipairs(tags) do
+                    tagnames[k] = v:name()
+                end
+
+                table.sort(tagnames)
+
+                assert(tagnames[1] == "2")
+                assert(tagnames[2] == "3")
+            },
+        };
+    })
+}
+
 #[test_log::test]
 fn output_handle_scale() {
     let (mut fixture, output, _) = set_up();