refactor: consolidate user-related plugins into single UserMetaPlugin

Co-authored-by: aider (openai/andrew/openrouter/deepseek/deepseek-chat-v3.1) <aider@aider.chat>
This commit is contained in:
Andrew Phillips
2025-08-26 17:55:18 -03:00
parent bedf000632
commit 77bd3f09a3
3 changed files with 89 additions and 381 deletions

View File

@@ -87,147 +87,27 @@ impl MetaPlugin for CwdMetaPlugin {
}
#[derive(Debug, Clone, Default)]
pub struct UidMetaPlugin {
meta_name: String,
is_saved: bool,
base: crate::meta_plugin::BaseMetaPlugin,
}
impl UidMetaPlugin {
pub fn new(
_options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> UidMetaPlugin {
// 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 = vec!["uid".to_string()];
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);
}
}
let mut base = crate::meta_plugin::BaseMetaPlugin::new();
base.outputs = final_outputs;
base.options = final_options;
UidMetaPlugin {
meta_name: "uid".to_string(),
is_saved: false,
base,
}
}
pub fn new_simple() -> UidMetaPlugin {
Self::new(None, None)
}
}
impl MetaPlugin for UidMetaPlugin {
fn finalize(&mut self, _conn: &Connection) -> Result<()> {
// Since we save during initialize(), return Ok to avoid duplicate saves
Ok(())
}
fn update(&mut self, _data: &[u8], _conn: &Connection) {
// No update needed
}
fn meta_name(&self) -> String {
self.meta_name.clone()
}
fn initialize(&mut self, item_id: i64) -> Result<PluginResponse> {
let mut metadata = Vec::new();
let uid = get_current_uid().to_string();
if let Some(meta) = self.create_meta(item_id, "uid", uid) {
metadata.push(meta);
}
Ok(MetaPluginResponse {
metadata: Some(metadata),
is_finalized: true,
})
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
&self.base.outputs
}
fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
&mut self.base.outputs
}
fn default_outputs(&self) -> Vec<String> {
vec!["uid".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.base.options
}
fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
&mut self.options
}
}
#[derive(Debug, Clone, Default)]
pub struct UserMetaPlugin {
meta_name: String,
is_saved: bool,
base: crate::meta_plugin::BaseMetaPlugin,
}
impl UserMetaPlugin {
pub fn new(
_options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> UserMetaPlugin {
// 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 = vec!["user".to_string()];
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);
}
}
let mut base = crate::meta_plugin::BaseMetaPlugin::new();
base.outputs = final_outputs;
base.options = final_options;
base.meta_name = "user".to_string();
// Initialize with helper function
base.initialize_plugin(
&["user_uid", "user_gid", "user_name", "user_group"],
options,
outputs,
);
UserMetaPlugin {
meta_name: "user".to_string(),
is_saved: false,
base,
}
}
@@ -235,31 +115,54 @@ impl UserMetaPlugin {
pub fn new_simple() -> UserMetaPlugin {
Self::new(None, None)
}
fn get_current_username() -> Option<String> {
uzers::get_user_by_uid(uzers::get_current_uid())
.map(|user| user.name().to_string_lossy().to_string())
}
fn get_current_groupname() -> Option<String> {
uzers::get_group_by_gid(uzers::get_current_gid())
.map(|group| group.name().to_string_lossy().to_string())
}
}
impl MetaPlugin for UserMetaPlugin {
fn finalize(&mut self, _conn: &Connection) -> Result<()> {
// Since we save during initialize(), return Ok to avoid duplicate saves
Ok(())
}
fn update(&mut self, _data: &[u8], _conn: &Connection) {
// No update needed
fn initialize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
let mut metadata = Vec::new();
// Get user info
let uid = uzers::get_current_uid().to_string();
let gid = uzers::get_current_gid().to_string();
let username = Self::get_current_username().unwrap_or_else(|| "unknown".to_string());
let groupname = Self::get_current_groupname().unwrap_or_else(|| "unknown".to_string());
// Process each output
let values = [
("user_uid", uid),
("user_gid", gid),
("user_name", username),
("user_group", groupname),
];
for (name, value) in values {
if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
name,
value,
self.base.outputs()
) {
metadata.push(meta_data);
}
}
crate::meta_plugin::MetaPluginResponse {
metadata,
is_finalized: true,
}
}
fn meta_name(&self) -> String {
self.meta_name.clone()
}
fn initialize(&mut self, conn: &Connection, item_id: i64) -> Result<()> {
let user = match get_current_username() {
Some(username) => username.to_string_lossy().to_string(),
None => "unknown".to_string(),
};
self.save_meta(conn, item_id, "user", user)?;
self.is_saved = true;
Ok(())
self.base.meta_name.clone()
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
@@ -271,200 +174,7 @@ impl MetaPlugin for UserMetaPlugin {
}
fn default_outputs(&self) -> Vec<String> {
vec!["user".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.base.options()
}
fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.options_mut()
}
}
#[derive(Debug, Clone, Default)]
pub struct GidMetaPlugin {
meta_name: String,
is_saved: bool,
base: crate::meta_plugin::BaseMetaPlugin,
}
impl GidMetaPlugin {
pub fn new(
_options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> GidMetaPlugin {
// 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 = vec!["gid".to_string()];
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);
}
}
let mut base = crate::meta_plugin::BaseMetaPlugin::new();
base.outputs = final_outputs;
base.options = final_options;
GidMetaPlugin {
meta_name: "gid".to_string(),
is_saved: false,
base,
}
}
pub fn new_simple() -> GidMetaPlugin {
Self::new(None, None)
}
}
impl MetaPlugin for GidMetaPlugin {
fn finalize(&mut self, _conn: &Connection) -> Result<()> {
// Since we save during initialize(), return Ok to avoid duplicate saves
Ok(())
}
fn update(&mut self, _data: &[u8], _conn: &Connection) {
// No update needed
}
fn meta_name(&self) -> String {
self.meta_name.clone()
}
fn initialize(&mut self, conn: &Connection, item_id: i64) -> Result<()> {
let gid = get_current_gid().to_string();
self.save_meta(conn, item_id, "gid", gid)?;
self.is_saved = true;
Ok(())
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs()
}
fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs_mut()
}
fn default_outputs(&self) -> Vec<String> {
vec!["gid".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.base.options()
}
fn options_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.options_mut()
}
}
#[derive(Debug, Clone, Default)]
pub struct GroupMetaPlugin {
meta_name: String,
is_saved: bool,
base: crate::meta_plugin::BaseMetaPlugin,
}
impl GroupMetaPlugin {
pub fn new(
_options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
) -> GroupMetaPlugin {
// 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 = vec!["group".to_string()];
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);
}
}
let mut base = crate::meta_plugin::BaseMetaPlugin::new();
base.outputs = final_outputs;
base.options = final_options;
GroupMetaPlugin {
meta_name: "group".to_string(),
is_saved: false,
base,
}
}
pub fn new_simple() -> GroupMetaPlugin {
Self::new(None, None)
}
}
impl MetaPlugin for GroupMetaPlugin {
fn finalize(&mut self, _conn: &Connection) -> Result<()> {
// Since we save during initialize(), return Ok to avoid duplicate saves
Ok(())
}
fn update(&mut self, _data: &[u8], _conn: &Connection) {
// No update needed
}
fn meta_name(&self) -> String {
self.meta_name.clone()
}
fn initialize(&mut self, conn: &Connection, item_id: i64) -> Result<()> {
let group = match get_current_groupname() {
Some(groupname) => groupname.to_string_lossy().to_string(),
None => "unknown".to_string(),
};
self.save_meta(conn, item_id, "group", group)?;
self.is_saved = true;
Ok(())
}
fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs()
}
fn outputs_mut(&mut self) -> &mut std::collections::HashMap<String, serde_yaml::Value> {
self.base.outputs_mut()
}
fn default_outputs(&self) -> Vec<String> {
vec!["group".to_string()]
vec!["user_uid".to_string(), "user_gid".to_string(), "user_name".to_string(), "user_group".to_string()]
}
fn default_options(&self) -> std::collections::HashMap<String, serde_yaml::Value> {