refactor: extract read_time and read_rate plugins from digest.rs

Co-authored-by: aider (openai/andrew/openrouter/qwen/qwen3-coder) <aider@aider.chat>

src/meta_plugin.rs

@@ -7,9 +7,13 @@ pub mod system;
 pub mod magic;
 pub mod binary;
 pub mod text;
+pub mod read_time;
+pub mod read_rate;
 
 use crate::meta_plugin::program::MetaPluginProgram;
-use crate::meta_plugin::digest::{DigestSha256MetaPlugin, ReadTimeMetaPlugin, ReadRateMetaPlugin};
+use crate::meta_plugin::digest::DigestSha256MetaPlugin;
+use crate::meta_plugin::read_time::ReadTimeMetaPlugin;
+use crate::meta_plugin::read_rate::ReadRateMetaPlugin;
 use crate::meta_plugin::system::*;
 use crate::meta_plugin::magic::MagicFileMetaPlugin;
 use crate::meta_plugin::binary::BinaryMetaPlugin;

src/meta_plugin/digest.rs

@@ -146,285 +146,3 @@ impl MetaPlugin for DigestSha256MetaPlugin {
 }
 
 
-#[derive(Debug, Clone, Default)]
-pub struct ReadTimeMetaPlugin {
-    start_time: Option<Instant>,
-    is_finalized: bool,
-    meta_name: String,
-    outputs: std::collections::HashMap<String, serde_yaml::Value>,
-    options: std::collections::HashMap<String, serde_yaml::Value>,
-}
-
-impl ReadTimeMetaPlugin {
-    pub fn new(
-        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
-        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
-    ) -> ReadTimeMetaPlugin {
-        // Start with default options
-        let mut final_options = std::collections::HashMap::new();
-        if let Some(opts) = _options {
-            for (key, value) in opts {
-                final_options.insert(key, value);
-            }
-        }
-        
-        // Start with default outputs
-        let mut final_outputs = std::collections::HashMap::new();
-        let default_outputs = Self::default().default_outputs();
-        for output_name in default_outputs {
-            final_outputs.insert(output_name.clone(), serde_yaml::Value::String(output_name));
-        }
-        if let Some(outs) = outputs {
-            for (key, value) in outs {
-                final_outputs.insert(key, value);
-            }
-        }
-        
-        ReadTimeMetaPlugin {
-            start_time: None,
-            is_finalized: false,
-            meta_name: "read_time".to_string(),
-            outputs: final_outputs,
-            options: final_options,
-        }
-    }
-    
-    pub fn new_simple() -> ReadTimeMetaPlugin {
-        Self::new(None, None)
-    }
-}
-
-impl MetaPlugin for ReadTimeMetaPlugin {
-    fn is_finalized(&self) -> bool {
-        self.is_finalized
-    }
-    
-    fn set_finalized(&mut self, finalized: bool) {
-        self.is_finalized = finalized;
-    }
-    
-    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
-        // If already finalized, don't process again
-        if self.is_finalized {
-            return crate::meta_plugin::MetaPluginResponse {
-                metadata: Vec::new(),
-                is_finalized: true,
-            };
-        }
-        
-        let mut metadata = Vec::new();
-
-        if let Some(start_time) = self.start_time {
-            let duration = start_time.elapsed();
-            let duration_str = format!("{:.3} seconds", duration.as_secs_f64());
-
-            // Use process_metadata_outputs to handle output mapping
-            if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
-                "read_time", 
-                duration_str, 
-                &self.outputs
-            ) {
-                metadata.push(meta_data);
-            }
-        }
-        
-        // Mark as finalized
-        self.is_finalized = true;
-
-        crate::meta_plugin::MetaPluginResponse {
-            metadata,
-            is_finalized: true,
-        }
-    }
-
-    fn update(&mut self, _data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
-        // If already finalized, don't process more data
-        if self.is_finalized {
-            return crate::meta_plugin::MetaPluginResponse {
-                metadata: Vec::new(),
-                is_finalized: true,
-            };
-        }
-        
-        if self.start_time.is_none() {
-            self.start_time = Some(Instant::now());
-        }
-        crate::meta_plugin::MetaPluginResponse {
-            metadata: Vec::new(),
-            is_finalized: false,
-        }
-    }
-
-    fn meta_name(&self) -> String {
-        self.meta_name.clone()
-    }
-    
-    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
-        &self.outputs
-    }
-    
-    fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
-        &mut self.outputs
-    }
-    
-    fn default_outputs(&self) -> Vec<String> {
-        vec!["read_time".to_string()]
-    }
-    
-    fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {
-        std::collections::HashMap::new()
-    }
-    
-    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
-        &self.options
-    }
-    
-    fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
-        &mut self.options
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct ReadRateMetaPlugin {
-    start_time: Option<Instant>,
-    bytes_read: u64,
-    is_finalized: bool,
-    meta_name: String,
-    outputs: std::collections::HashMap<String, serde_yaml::Value>,
-    options: std::collections::HashMap<String, serde_yaml::Value>,
-}
-
-impl ReadRateMetaPlugin {
-    pub fn new(
-        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
-        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
-    ) -> ReadRateMetaPlugin {
-        // Start with default options
-        let mut final_options = std::collections::HashMap::new();
-        if let Some(opts) = _options {
-            for (key, value) in opts {
-                final_options.insert(key, value);
-            }
-        }
-        
-        // Start with default outputs
-        let mut final_outputs = std::collections::HashMap::new();
-        let default_outputs = Self::default().default_outputs();
-        for output_name in default_outputs {
-            final_outputs.insert(output_name.clone(), serde_yaml::Value::String(output_name));
-        }
-        if let Some(outs) = outputs {
-            for (key, value) in outs {
-                final_outputs.insert(key, value);
-            }
-        }
-        
-        ReadRateMetaPlugin {
-            start_time: None,
-            bytes_read: 0,
-            is_finalized: false,
-            meta_name: "read_rate".to_string(),
-            outputs: final_outputs,
-            options: final_options,
-        }
-    }
-    
-    pub fn new_simple() -> ReadRateMetaPlugin {
-        Self::new(None, None)
-    }
-}
-
-impl MetaPlugin for ReadRateMetaPlugin {
-    fn is_finalized(&self) -> bool {
-        self.is_finalized
-    }
-    
-    fn set_finalized(&mut self, finalized: bool) {
-        self.is_finalized = finalized;
-    }
-    
-    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
-        // If already finalized, don't process again
-        if self.is_finalized {
-            return crate::meta_plugin::MetaPluginResponse {
-                metadata: Vec::new(),
-                is_finalized: true,
-            };
-        }
-        
-        let mut metadata = Vec::new();
-
-        if let Some(start_time) = self.start_time {
-            let duration = start_time.elapsed();
-            let rate = if duration.as_secs_f64() > 0.0 {
-                format!("{:.2} KB/s", (self.bytes_read as f64 / 1024.0) / duration.as_secs_f64())
-            } else {
-                "N/A".to_string()
-            };
-
-            // Use process_metadata_outputs to handle output mapping
-            if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
-                "read_rate", 
-                rate, 
-                &self.outputs
-            ) {
-                metadata.push(meta_data);
-            }
-        }
-        
-        // Mark as finalized
-        self.is_finalized = true;
-
-        crate::meta_plugin::MetaPluginResponse {
-            metadata,
-            is_finalized: true,
-        }
-    }
-
-    fn update(&mut self, data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
-        // If already finalized, don't process more data
-        if self.is_finalized {
-            return crate::meta_plugin::MetaPluginResponse {
-                metadata: Vec::new(),
-                is_finalized: true,
-            };
-        }
-        
-        if self.start_time.is_none() {
-            self.start_time = Some(Instant::now());
-        }
-        self.bytes_read += data.len() as u64;
-        crate::meta_plugin::MetaPluginResponse {
-            metadata: Vec::new(),
-            is_finalized: false,
-        }
-    }
-
-    fn meta_name(&self) -> String {
-        self.meta_name.clone()
-    }
-    
-    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
-        &self.outputs
-    }
-    
-    fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
-        &mut self.outputs
-    }
-    
-    fn default_outputs(&self) -> Vec<String> {
-        vec!["read_rate".to_string()]
-    }
-    
-    fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {
-        std::collections::HashMap::new()
-    }
-    
-    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
-        &self.options
-    }
-    
-    fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
-        &mut self.options
-    }
-}

src/meta_plugin/read_rate.rs

@@ -0,0 +1,148 @@
+use std::time::Instant;
+
+use crate::meta_plugin::MetaPlugin;
+
+#[derive(Debug, Clone, Default)]
+pub struct ReadRateMetaPlugin {
+    start_time: Option<Instant>,
+    bytes_read: u64,
+    is_finalized: bool,
+    meta_name: String,
+    outputs: std::collections::HashMap<String, serde_yaml::Value>,
+    options: std::collections::HashMap<String, serde_yaml::Value>,
+}
+
+impl ReadRateMetaPlugin {
+    pub fn new(
+        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+    ) -> ReadRateMetaPlugin {
+        // Start with default options
+        let mut final_options = std::collections::HashMap::new();
+        if let Some(opts) = _options {
+            for (key, value) in opts {
+                final_options.insert(key, value);
+            }
+        }
+        
+        // Start with default outputs
+        let mut final_outputs = std::collections::HashMap::new();
+        let default_outputs = Self::default().default_outputs();
+        for output_name in default_outputs {
+            final_outputs.insert(output_name.clone(), serde_yaml::Value::String(output_name));
+        }
+        if let Some(outs) = outputs {
+            for (key, value) in outs {
+                final_outputs.insert(key, value);
+            }
+        }
+        
+        ReadRateMetaPlugin {
+            start_time: None,
+            bytes_read: 0,
+            is_finalized: false,
+            meta_name: "read_rate".to_string(),
+            outputs: final_outputs,
+            options: final_options,
+        }
+    }
+    
+    pub fn new_simple() -> ReadRateMetaPlugin {
+        Self::new(None, None)
+    }
+}
+
+impl MetaPlugin for ReadRateMetaPlugin {
+    fn is_finalized(&self) -> bool {
+        self.is_finalized
+    }
+    
+    fn set_finalized(&mut self, finalized: bool) {
+        self.is_finalized = finalized;
+    }
+    
+    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process again
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        let mut metadata = Vec::new();
+
+        if let Some(start_time) = self.start_time {
+            let duration = start_time.elapsed();
+            let rate = if duration.as_secs_f64() > 0.0 {
+                format!("{:.2} KB/s", (self.bytes_read as f64 / 1024.0) / duration.as_secs_f64())
+            } else {
+                "N/A".to_string()
+            };
+
+            // Use process_metadata_outputs to handle output mapping
+            if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
+                "read_rate", 
+                rate, 
+                &self.outputs
+            ) {
+                metadata.push(meta_data);
+            }
+        }
+        
+        // Mark as finalized
+        self.is_finalized = true;
+
+        crate::meta_plugin::MetaPluginResponse {
+            metadata,
+            is_finalized: true,
+        }
+    }
+
+    fn update(&mut self, data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process more data
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        if self.start_time.is_none() {
+            self.start_time = Some(Instant::now());
+        }
+        self.bytes_read += data.len() as u64;
+        crate::meta_plugin::MetaPluginResponse {
+            metadata: Vec::new(),
+            is_finalized: false,
+        }
+    }
+
+    fn meta_name(&self) -> String {
+        self.meta_name.clone()
+    }
+    
+    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.outputs
+    }
+    
+    fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.outputs
+    }
+    
+    fn default_outputs(&self) -> Vec<String> {
+        vec!["read_rate".to_string()]
+    }
+    
+    fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {
+        std::collections::HashMap::new()
+    }
+    
+    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.options
+    }
+    
+    fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.options
+    }
+}

src/meta_plugin/read_time.rs

@@ -0,0 +1,141 @@
+use std::time::Instant;
+
+use crate::meta_plugin::MetaPlugin;
+
+#[derive(Debug, Clone, Default)]
+pub struct ReadTimeMetaPlugin {
+    start_time: Option<Instant>,
+    is_finalized: bool,
+    meta_name: String,
+    outputs: std::collections::HashMap<String, serde_yaml::Value>,
+    options: std::collections::HashMap<String, serde_yaml::Value>,
+}
+
+impl ReadTimeMetaPlugin {
+    pub fn new(
+        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
+    ) -> ReadTimeMetaPlugin {
+        // Start with default options
+        let mut final_options = std::collections::HashMap::new();
+        if let Some(opts) = _options {
+            for (key, value) in opts {
+                final_options.insert(key, value);
+            }
+        }
+        
+        // Start with default outputs
+        let mut final_outputs = std::collections::HashMap::new();
+        let default_outputs = Self::default().default_outputs();
+        for output_name in default_outputs {
+            final_outputs.insert(output_name.clone(), serde_yaml::Value::String(output_name));
+        }
+        if let Some(outs) = outputs {
+            for (key, value) in outs {
+                final_outputs.insert(key, value);
+            }
+        }
+        
+        ReadTimeMetaPlugin {
+            start_time: None,
+            is_finalized: false,
+            meta_name: "read_time".to_string(),
+            outputs: final_outputs,
+            options: final_options,
+        }
+    }
+    
+    pub fn new_simple() -> ReadTimeMetaPlugin {
+        Self::new(None, None)
+    }
+}
+
+impl MetaPlugin for ReadTimeMetaPlugin {
+    fn is_finalized(&self) -> bool {
+        self.is_finalized
+    }
+    
+    fn set_finalized(&mut self, finalized: bool) {
+        self.is_finalized = finalized;
+    }
+    
+    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process again
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        let mut metadata = Vec::new();
+
+        if let Some(start_time) = self.start_time {
+            let duration = start_time.elapsed();
+            let duration_str = format!("{:.3} seconds", duration.as_secs_f64());
+
+            // Use process_metadata_outputs to handle output mapping
+            if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
+                "read_time", 
+                duration_str, 
+                &self.outputs
+            ) {
+                metadata.push(meta_data);
+            }
+        }
+        
+        // Mark as finalized
+        self.is_finalized = true;
+
+        crate::meta_plugin::MetaPluginResponse {
+            metadata,
+            is_finalized: true,
+        }
+    }
+
+    fn update(&mut self, _data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
+        // If already finalized, don't process more data
+        if self.is_finalized {
+            return crate::meta_plugin::MetaPluginResponse {
+                metadata: Vec::new(),
+                is_finalized: true,
+            };
+        }
+        
+        if self.start_time.is_none() {
+            self.start_time = Some(Instant::now());
+        }
+        crate::meta_plugin::MetaPluginResponse {
+            metadata: Vec::new(),
+            is_finalized: false,
+        }
+    }
+
+    fn meta_name(&self) -> String {
+        self.meta_name.clone()
+    }
+    
+    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.outputs
+    }
+    
+    fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.outputs
+    }
+    
+    fn default_outputs(&self) -> Vec<String> {
+        vec!["read_time".to_string()]
+    }
+    
+    fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {
+        std::collections::HashMap::new()
+    }
+    
+    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
+        &self.options
+    }
+    
+    fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
+        &mut self.options
+    }
+}