feat: add arguments for max responses

Author: wash2

Cargo.lock

@@ -18,7 +18,7 @@ enum Event {
 }
 
 pub async fn main() {
-    let (event_tx, event_rx) = flume::bounded::<Event>(8);
+    let (event_tx, event_rx) = flume::bounded::<Event>(20);
 
     // Channel for cancelling searches that are in progress.
     let (interrupt_tx, interrupt_rx) = flume::bounded::<()>(1);

plugins/src/find/mod.rs

@@ -99,7 +99,7 @@ impl App {
     }
 
     async fn reload(&mut self) {
-        let (tx, rx) = flume::bounded::<ScriptInfo>(8);
+        let (tx, rx) = flume::bounded::<ScriptInfo>(20);
 
         let mut queue = VecDeque::new();
 

plugins/src/scripts/mod.rs

@@ -8,6 +8,7 @@ edition.workspace = true
 anyhow.workspace = true
 async-oneshot = "0.5.9"
 async-trait = "0.1.83"
+clap = { version = "4.5.27", features = ["derive"] }
 dirs.workspace = true
 futures.workspace = true
 futures_codec = "0.4.1"

service/Cargo.toml

@@ -8,15 +8,25 @@ use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
 use tokio::process;
 use tokio_stream::wrappers::LinesStream;
 
+use crate::Args;
+
 #[derive(Debug)]
 pub struct IpcClient {
     pub child: process::Child,
     pub stdin: process::ChildStdin,
 }
 
 impl IpcClient {
-    pub fn new() -> io::Result<(Self, impl Stream<Item = Response>)> {
+    pub fn new_with_args(args: Args) -> io::Result<(Self, impl Stream<Item = Response>)> {
         let mut child = process::Command::new("pop-launcher")
+            .args(&[
+                "--max-open",
+                args.max_open.to_string().as_str(),
+                "--max-files",
+                args.max_files.to_string().as_str(),
+                "--max-search",
+                args.max_search.to_string().as_str(),
+            ])
             .stdin(std::process::Stdio::piped())
             .stdout(std::process::Stdio::piped())
             .spawn()?;
@@ -46,6 +56,10 @@ impl IpcClient {
         Ok((client, responses))
     }
 
+    pub fn new() -> io::Result<(Self, impl Stream<Item = Response>)> {
+        Self::new_with_args(Args::default())
+    }
+
     pub async fn send(&mut self, request: Request) -> io::Result<()> {
         let mut request_json = serde_json::to_string(&request)
             .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;

service/src/client.rs

@@ -15,6 +15,7 @@ use crate::plugins::{
 };
 use crate::priority::Priority;
 use crate::recent::RecentUseStorage;
+use clap::Parser;
 use flume::{Receiver, Sender};
 use futures::{future, SinkExt, Stream, StreamExt};
 use pop_launcher::{
@@ -23,6 +24,7 @@ use pop_launcher::{
 };
 use regex::Regex;
 use slab::Slab;
+use std::usize;
 use std::{
     cmp::Ordering,
     collections::{HashMap, HashSet},
@@ -32,6 +34,33 @@ use std::{
 
 pub type PluginKey = usize;
 
+/// Bounds for the number of service responses.
+#[derive(Parser, Debug, Clone, Copy)]
+#[command(version, about, long_about = None)]
+pub struct Args {
+    /// Max number of files in a response.
+    #[arg(short, long, default_value_t = 100)]
+    pub max_files: usize,
+
+    /// Max number of open windows in a response.
+    #[arg(short, long, default_value_t = 8)]
+    pub max_open: usize,
+
+    /// Max number of generic items in a response.
+    #[arg(short, long, default_value_t = 8)]
+    pub max_search: usize,
+}
+
+impl Default for Args {
+    fn default() -> Self {
+        Args {
+            max_files: 100,
+            max_open: 8,
+            max_search: 8,
+        }
+    }
+}
+
 pub enum Event {
     Request(Request),
     Response((PluginKey, PluginResponse)),
@@ -67,6 +96,7 @@ pub fn store_cache(storage: &RecentUseStorage) {
 }
 
 pub async fn main() {
+    let args = Args::parse();
     let cachepath = ensure_cache_path();
     let read_recent = || -> Result<RecentUseStorage, Box<dyn std::error::Error>> {
         let cachepath = std::fs::File::open(cachepath?)?;
@@ -94,7 +124,9 @@ pub async fn main() {
     let (output_tx, output_rx) = flume::bounded(16);
 
     // Service will operate for as long as it is being awaited
-    let service = Service::new(output_tx.into_sink(), recent).exec(input_stream);
+    let service = Service::new(output_tx.into_sink(), recent)
+        .with_args(args)
+        .exec(input_stream);
 
     // Responses from the service will be streamed to stdout
     let responder = async move {
@@ -119,6 +151,7 @@ pub struct Service<O> {
     plugins: Slab<PluginConnector>,
     search_scheduled: bool,
     recent: RecentUseStorage,
+    args: Args,
 }
 
 impl<O: futures::Sink<Response> + Unpin> Service<O> {
@@ -133,9 +166,15 @@ impl<O: futures::Sink<Response> + Unpin> Service<O> {
             plugins: Slab::new(),
             search_scheduled: false,
             recent,
+            args: Args::default(),
         }
     }
 
+    fn with_args(mut self, args: Args) -> Self {
+        self.args = args;
+        self
+    }
+
     pub async fn exec(mut self, input: impl Stream<Item = Request>) {
         let (service_tx, service_rx) = flume::bounded(1);
         let stream = plugins::external::load::from_paths();
@@ -284,7 +323,7 @@ impl<O: futures::Sink<Response> + Unpin> Service<O> {
             regex,
             isolate_with,
             Box::new(move || {
-                let (request_tx, request_rx) = flume::bounded(8);
+                let (request_tx, request_rx) = flume::bounded(20);
 
                 let init = init.clone();
                 let service_tx = service_tx.clone();
@@ -593,10 +632,12 @@ impl<O: futures::Sink<Response> + Unpin> Service<O> {
             });
         }
 
-        let take = if last_query.starts_with('/') | last_query.starts_with('~') {
-            100
+        let take = if last_query.is_empty() {
+            self.args.max_open
+        } else if last_query.starts_with('/') | last_query.starts_with('~') {
+            self.args.max_files
         } else {
-            8
+            self.args.max_search
         };
 
         let mut windows = Vec::with_capacity(take);