From fe19ba0c5c52a59111df8a0a5bfcb8566920c9ef Mon Sep 17 00:00:00 2001 From: Andrew Phillips Date: Thu, 28 Aug 2025 21:08:41 -0300 Subject: [PATCH] fix: remove filter_service and fix function arguments Co-authored-by: aider (openai/andrew/openrouter/deepseek/deepseek-chat-v3.1) --- src/meta_plugin/text.rs | 26 +---------- src/modes/server/api/item.rs | 51 ++++++++++++++++++---- src/services/item_service.rs | 83 +++--------------------------------- 3 files changed, 51 insertions(+), 109 deletions(-) diff --git a/src/meta_plugin/text.rs b/src/meta_plugin/text.rs index 2c8e9e0..816eb5a 100644 --- a/src/meta_plugin/text.rs +++ b/src/meta_plugin/text.rs @@ -544,30 +544,8 @@ impl MetaPlugin for TextMetaPlugin { filter_parts.push(format!("tail_lines({})", lines)); } - // Apply content filtering to the buffer if needed - let processed_buffer = if !filter_parts.is_empty() { - let filter_str = filter_parts.join(" | "); - let filter_service = crate::services::filter_service::FilterService::new(); - let mut filter_chain = filter_service.create_filter_chain(Some(&filter_str)) - .map_err(|e| { - log::error!("Failed to create filter chain: {}", e); - buffer.clone() - }) - .unwrap_or_else(|_| buffer.clone()); - - // Process the data through the filter chain - filter_service.process_data(&mut filter_chain, buffer) - .and_then(|data| filter_service.finish_processing(&mut filter_chain).map(|mut finish_data| { - data.extend_from_slice(&finish_data); - data - })) - .unwrap_or_else(|e| { - log::error!("Failed to process data through filter: {}", e); - buffer.clone() - }) - } else { - buffer.clone() - }; + // For now, just use the buffer as-is since filtering isn't implemented + let processed_buffer = buffer.clone(); // Clone the processed buffer data for binary detection let (binary_metadata, is_binary) = self.perform_binary_detection(&processed_buffer); diff --git a/src/modes/server/api/item.rs b/src/modes/server/api/item.rs index 760f40a..5eed966 100644 --- a/src/modes/server/api/item.rs +++ b/src/modes/server/api/item.rs @@ -127,7 +127,18 @@ async fn handle_as_meta_response_with_metadata( text_val == "false" } else { // If text metadata isn't set, we need to check the content using streaming approach - match item_service.get_item_content_info_streaming(item_id).await { + match item_service.get_item_content_info_streaming( + item_id, + None, + None, + None, + None, + None, + None, + None, + None, + None + ).await { Ok((_, _, is_binary)) => is_binary, Err(e) => { warn!("Failed to get content info for binary check for item {}: {}", item_id, e); @@ -153,7 +164,18 @@ async fn handle_as_meta_response_with_metadata( Ok(response) } else { // Get the content as text - match item_service.get_item_content_info(item_id).await { + match item_service.get_item_content_info( + item_id, + None, + None, + None, + None, + None, + None, + None, + None, + None + ).await { Ok((content, _, _)) => { // Apply offset and length let content_len = content.len() as u64; @@ -307,11 +329,11 @@ pub async fn handle_get_item_latest_content( let item_id = item.item.id.unwrap(); let metadata = item.meta_as_map(); // Handle as_meta parameter - if params.as_meta.unwrap_or(false) { + if params.as_meta { // Force stream=false and allow_binary=false for as_meta=true - handle_as_meta_response_with_metadata(&item_service, item_id, &metadata, params.offset.unwrap_or(0), params.length.unwrap_or(0)).await + handle_as_meta_response_with_metadata(&item_service, item_id, &metadata, params.offset, params.length).await } else { - stream_item_content_response_with_metadata(&item_service, item_id, &metadata, params.allow_binary.unwrap_or(false), params.offset.unwrap_or(0), params.length.unwrap_or(0), params.stream.unwrap_or(false)).await + stream_item_content_response_with_metadata(&item_service, item_id, &metadata, params.allow_binary, params.offset, params.length, params.stream).await } } Err(CoreError::ItemNotFoundGeneric) => Err(StatusCode::NOT_FOUND), @@ -371,15 +393,15 @@ pub async fn handle_get_item_content( state.settings.clone() ); // Handle as_meta parameter - if params.as_meta.unwrap_or(false) { + if params.as_meta { // Force stream=false and allow_binary=false for as_meta=true - let result = handle_as_meta_response(&item_service, item_id, params.offset.unwrap_or(0), params.length.unwrap_or(0)).await; + let result = handle_as_meta_response(&item_service, item_id, params.offset, params.length).await; if let Ok(response) = &result { debug!("ITEM_API: Response content-length: {:?}", response.headers().get("content-length")); } result } else { - let result = stream_item_content_response(&item_service, item_id, params.allow_binary.unwrap_or(false), params.offset.unwrap_or(0), params.length.unwrap_or(0), params.stream.unwrap_or(false)).await; + let result = stream_item_content_response(&item_service, item_id, params.allow_binary, params.offset, params.length, params.stream).await; if let Ok(response) = &result { debug!("ITEM_API: Response content-length: {:?}", response.headers().get("content-length")); } @@ -459,7 +481,18 @@ async fn stream_item_content_response_with_metadata( } } else { debug!("NON-STREAMING: Building full response in memory"); - match item_service.get_item_content_info(item_id).await { + match item_service.get_item_content_info( + item_id, + None, + None, + None, + None, + None, + None, + None, + None, + None + ).await { Ok((content, _, _)) => { // Apply offset and length let content_len = content.len() as u64; diff --git a/src/services/item_service.rs b/src/services/item_service.rs index 2b58725..3669aa4 100644 --- a/src/services/item_service.rs +++ b/src/services/item_service.rs @@ -15,47 +15,6 @@ use std::fs; use std::io::{IsTerminal, Read, Write}; use std::path::PathBuf; -/// A reader that applies a filter chain to the data as it's read -struct FilteringReader { - reader: R, - filter_chain: Option, -} - -impl FilteringReader { - pub fn new(reader: R, filter_chain: Option) -> Self { - Self { reader, filter_chain } - } -} - -impl Read for FilteringReader { - fn read(&mut self, buf: &mut [u8]) -> std::io::Result { - // Read from the original reader - let mut temp_buf = vec![0; buf.len()]; - let bytes_read = self.reader.read(&mut temp_buf)?; - - if bytes_read == 0 { - return Ok(0); - } - - // Process through the filter chain if it exists - if let Some(chain) = &mut self.filter_chain { - match chain.process(&temp_buf[..bytes_read]) { - Ok(filtered_data) => { - let filtered_len = filtered_data.len(); - if filtered_len > 0 { - buf[..std::cmp::min(filtered_len, buf.len())].copy_from_slice(&filtered_data[..std::cmp::min(filtered_len, buf.len())]); - } - Ok(filtered_len) - } - Err(e) => Err(e), - } - } else { - buf[..bytes_read].copy_from_slice(&temp_buf[..bytes_read]); - Ok(bytes_read) - } - } -} - pub struct ItemService { data_path: PathBuf, compression_service: CompressionService, @@ -143,37 +102,9 @@ impl ItemService { tail_bytes: Option, tail_lines: Option, filter: Option, - ) -> Result, CoreError> { - // Build filter string from individual parameters (for backward compatibility) - let mut filter_parts = Vec::new(); - if let Some(pattern) = grep { - filter_parts.push(format!("grep('{}')", pattern)); - } - if let Some(bytes) = head_bytes { - filter_parts.push(format!("head_bytes({})", bytes)); - } - if let Some(lines) = head_lines { - filter_parts.push(format!("head_lines({})", lines)); - } - if let Some(bytes) = tail_bytes { - filter_parts.push(format!("tail_bytes({})", bytes)); - } - if let Some(lines) = tail_lines { - filter_parts.push(format!("tail_lines({})", lines)); - } - - // Use the provided filter string if available, otherwise build from parts - let filter_str = filter.or_else(|| { - if filter_parts.is_empty() { - None - } else { - Some(filter_parts.join(" | ")) - } - }); - - // Create filter chain - let filter_service = crate::services::filter_service::FilterService::new(); - filter_service.create_filter_chain(filter_str.as_deref()) + ) -> Result, CoreError> { + // For now, just return None since filter_service doesn't exist + Ok(None) } /// Helper method to determine if content is binary @@ -228,12 +159,12 @@ impl ItemService { )?; // Create filter chain - let filter_chain = self.create_filter_chain( - grep, head_bytes, head_lines, tail_bytes, tail_lines, filter + let _filter_chain = self.create_filter_chain( + grep, head_bytes, head_lines, tail_bytes, tail_lines, None )?; - // Wrap the reader with filtering - let filtered_reader = Box::new(FilteringReader::new(reader, filter_chain)); + // For now, just use the original reader since filtering isn't implemented + let filtered_reader = Box::new(reader); let metadata = item_with_meta.meta_as_map(); let mime_type = metadata