+26 -4

src/client.rs

reviewed

··· 2 2 use nu_plugin::LabeledError; 3 3 use nu_protocol::{Spanned, Value}; 4 4 5 5 - use crate::config::{DbusClientConfig, DbusBusChoice}; 5 5 + use crate::{config::{DbusClientConfig, DbusBusChoice}, dbus_type::DbusType, convert::to_message_item}; 6 6 7 7 /// Executes D-Bus actions on a connection, handling nushell types 8 8 pub struct DbusClient { ··· 42 42 object: &Spanned<String>, 43 43 interface: &Spanned<String>, 44 44 method: &Spanned<String>, 45 45 - ) -> Result<Value, LabeledError> { 46 46 - // TODO accept arguments 45 45 + signature: Option<&Spanned<String>>, 46 46 + args: &[Value], 47 47 + ) -> Result<Vec<Value>, LabeledError> { 47 48 macro_rules! error { 48 49 ($label:expr) => (LabeledError { 49 50 label: $label, ··· 67 68 let valid_interface = validate_with!(dbus::strings::Interface, interface)?; 68 69 let valid_method = validate_with!(dbus::strings::Member, method)?; 69 70 71 71 + // Parse the signature 72 72 + let valid_signature = signature.map(|s| DbusType::parse_all(&s.item).map_err(|err| { 73 73 + LabeledError { 74 74 + label: err, 75 75 + msg: "in signature specified here".into(), 76 76 + span: Some(s.span), 77 77 + } 78 78 + })).transpose()?; 79 79 + 80 80 + if let Some(sig) = &valid_signature { 81 81 + if sig.len() != args.len() { 82 82 + error!(format!("expected {} arguments, got {}", sig.len(), args.len())); 83 83 + } 84 84 + } 85 85 + 70 86 // Construct the method call message 71 71 - let message = Message::new_method_call( 87 87 + let mut message = Message::new_method_call( 72 88 valid_dest, 73 89 valid_object, 74 90 valid_interface, 75 91 valid_method, 76 92 ).map_err(|err| error!(err))?; 93 93 + 94 94 + // Convert the args to message items 95 95 + let sigs_iter = valid_signature.iter().flatten().map(Some).chain(std::iter::repeat(None)); 96 96 + for (val, sig) in args.iter().zip(sigs_iter) { 97 97 + message = message.append1(to_message_item(val, sig)?); 98 98 + } 77 99 78 100 // Send it on the channel and get the response 79 101 let resp = self.conn.send_with_reply_and_block(message, self.config.timeout.item)

+167 -9

src/convert.rs

reviewed

··· 1 1 - use dbus::{Message, arg::{ArgType, RefArg}}; 1 1 + use dbus::{Message, arg::{ArgType, RefArg, messageitem::{MessageItemArray, MessageItem, MessageItemDict}}, Signature}; 2 2 + use nu_plugin::LabeledError; 2 3 use nu_protocol::{Value, Span, Record}; 4 4 + use std::str::FromStr; 5 5 + 6 6 + use crate::dbus_type::DbusType; 3 7 4 4 - pub fn from_message(message: &Message) -> Result<Value, String> { 8 8 + /// Get the arguments of a message as nushell Values 9 9 + pub fn from_message(message: &Message) -> Result<Vec<Value>, String> { 5 10 let mut out = vec![]; 6 11 for refarg in message.iter_init() { 7 12 out.push(from_refarg(&refarg)?); 8 13 } 9 9 - Ok(Value::list(out, Span::unknown())) 14 14 + Ok(out) 10 15 } 11 16 12 17 pub fn from_refarg(refarg: &dyn RefArg) -> Result<Value, String> { ··· 15 20 if refarg.signature().starts_with("a{") { 16 21 // This is a dictionary 17 22 let mut record = Record::new(); 18 18 - for entry in refarg.as_iter().unwrap() { 19 19 - let mut entry_iter = entry.as_iter().unwrap(); 20 20 - let key = entry_iter.next().unwrap(); 21 21 - let val = entry_iter.next().unwrap(); 22 22 - if let Some(key) = key.as_str() { 23 23 - record.insert(key, from_refarg(val)?); 23 23 + let mut iter = refarg.as_iter().unwrap(); 24 24 + while let Some(key) = iter.next() { 25 25 + if let Some(val) = iter.next() { 26 26 + if let Some(key_str) = key.as_str() { 27 27 + record.insert(key_str, from_refarg(val)?); 28 28 + } 24 29 } 25 30 } 26 31 Value::record(record, Span::unknown()) ··· 68 73 return Err("Encountered invalid D-Bus value".into()), 69 74 }) 70 75 } 76 76 + 77 77 + pub fn to_message_item(value: &Value, expected_type: Option<&DbusType>) 78 78 + -> Result<MessageItem, LabeledError> 79 79 + { 80 80 + // Report errors from conversion. Error must support Display 81 81 + macro_rules! try_convert { 82 82 + ($result_expr:expr) => ($result_expr.map_err(|err| LabeledError { 83 83 + label: format!("Failed to convert value to the D-Bus `{:?}` type", 84 84 + expected_type.unwrap()), 85 85 + msg: err.to_string(), 86 86 + span: Some(value.span()), 87 87 + })?) 88 88 + } 89 89 + 90 90 + // Try to match values to expected types 91 91 + match (value, expected_type) { 92 92 + // Boolean 93 93 + (Value::Bool { val, .. }, Some(DbusType::Boolean)) => 94 94 + Ok(MessageItem::Bool(*val)), 95 95 + 96 96 + // Strings and specialized strings 97 97 + (Value::String { val, .. }, Some(DbusType::String)) => 98 98 + Ok(MessageItem::Str(val.to_owned())), 99 99 + (Value::String { val, .. }, Some(DbusType::ObjectPath)) => 100 100 + Ok(MessageItem::ObjectPath(try_convert!(dbus::strings::Path::new(val)))), 101 101 + (Value::String { val, .. }, Some(DbusType::Signature)) => 102 102 + Ok(MessageItem::Signature(try_convert!(dbus::strings::Signature::new(val)))), 103 103 + 104 104 + // Signed ints 105 105 + (Value::Int { val, .. }, Some(DbusType::Int64)) => 106 106 + Ok(MessageItem::Int64(*val)), 107 107 + (Value::Int { val, .. }, Some(DbusType::Int32)) => 108 108 + Ok(MessageItem::Int32(try_convert!(i32::try_from(*val)))), 109 109 + (Value::Int { val, .. }, Some(DbusType::Int16)) => 110 110 + Ok(MessageItem::Int16(try_convert!(i16::try_from(*val)))), 111 111 + 112 112 + // Unsigned ints 113 113 + (Value::Int { val, .. }, Some(DbusType::UInt64)) => 114 114 + Ok(MessageItem::UInt64(try_convert!(u64::try_from(*val)))), 115 115 + (Value::Int { val, .. }, Some(DbusType::UInt32)) => 116 116 + Ok(MessageItem::UInt32(try_convert!(u32::try_from(*val)))), 117 117 + (Value::Int { val, .. }, Some(DbusType::UInt16)) => 118 118 + Ok(MessageItem::UInt16(try_convert!(u16::try_from(*val)))), 119 119 + (Value::Int { val, .. }, Some(DbusType::Byte)) => 120 120 + Ok(MessageItem::Byte(try_convert!(u8::try_from(*val)))), 121 121 + 122 122 + // Ints from string 123 123 + (Value::String { val, .. }, Some(DbusType::Int64)) => 124 124 + Ok(MessageItem::Int64(try_convert!(i64::from_str(&val[..])))), 125 125 + (Value::String { val, .. }, Some(DbusType::Int32)) => 126 126 + Ok(MessageItem::Int32(try_convert!(i32::from_str(&val[..])))), 127 127 + (Value::String { val, .. }, Some(DbusType::Int16)) => 128 128 + Ok(MessageItem::Int16(try_convert!(i16::from_str(&val[..])))), 129 129 + (Value::String { val, .. }, Some(DbusType::UInt64)) => 130 130 + Ok(MessageItem::UInt64(try_convert!(u64::from_str(&val[..])))), 131 131 + (Value::String { val, .. }, Some(DbusType::UInt32)) => 132 132 + Ok(MessageItem::UInt32(try_convert!(u32::from_str(&val[..])))), 133 133 + (Value::String { val, .. }, Some(DbusType::UInt16)) => 134 134 + Ok(MessageItem::UInt16(try_convert!(u16::from_str(&val[..])))), 135 135 + (Value::String { val, .. }, Some(DbusType::Byte)) => 136 136 + Ok(MessageItem::Byte(try_convert!(u8::from_str(&val[..])))), 137 137 + 138 138 + // Float 139 139 + (Value::Float { val, .. }, Some(DbusType::Double)) => 140 140 + Ok(MessageItem::Double(*val)), 141 141 + (Value::String { val, .. }, Some(DbusType::Double)) => 142 142 + Ok(MessageItem::Double(try_convert!(f64::from_str(&val[..])))), 143 143 + 144 144 + // List/array 145 145 + (Value::List { vals, .. }, Some(DbusType::Array(content_type))) => { 146 146 + let content_sig = Signature::from(content_type.stringify()); 147 147 + let items = vals.iter() 148 148 + .map(|content| to_message_item(content, Some(content_type))) 149 149 + .collect::<Result<Vec<MessageItem>, _>>()?; 150 150 + Ok(MessageItem::Array(MessageItemArray::new(items, content_sig).unwrap())) 151 151 + }, 152 152 + 153 153 + // Struct 154 154 + (Value::List { vals, .. }, Some(DbusType::Struct(types))) => { 155 155 + if vals.len() != types.len() { 156 156 + return Err(LabeledError { 157 157 + label: format!("expected struct with {} element(s) ({:?})", types.len(), types), 158 158 + msg: format!("this list has {} element(s) instead", vals.len()), 159 159 + span: Some(value.span()) 160 160 + }); 161 161 + } 162 162 + let items = vals.iter().zip(types) 163 163 + .map(|(content, r#type)| to_message_item(content, Some(r#type))) 164 164 + .collect::<Result<Vec<MessageItem>, _>>()?; 165 165 + Ok(MessageItem::Struct(items)) 166 166 + }, 167 167 + 168 168 + // Record/dict 169 169 + (Value::Record { val, .. }, Some(DbusType::Array(content_type))) 170 170 + if matches!(**content_type, DbusType::DictEntry(_, _)) => 171 171 + { 172 172 + if let DbusType::DictEntry(ref key_type, ref val_type) = **content_type { 173 173 + let key_sig = Signature::from(key_type.stringify()); 174 174 + let val_sig = Signature::from(val_type.stringify()); 175 175 + let pairs = val.iter() 176 176 + .map(|(key, val)| { 177 177 + let key_as_value = Value::string(key, value.span()); 178 178 + let key_message_item = to_message_item(&key_as_value, Some(key_type))?; 179 179 + let val_message_item = to_message_item(val, Some(val_type))?; 180 180 + Ok((key_message_item, val_message_item)) 181 181 + }) 182 182 + .collect::<Result<Vec<_>, LabeledError>>()?; 183 183 + Ok(MessageItem::Dict(MessageItemDict::new(pairs, key_sig, val_sig).unwrap())) 184 184 + } else { 185 185 + unreachable!() 186 186 + } 187 187 + }, 188 188 + 189 189 + // Variant - use automatic type 190 190 + (other_value, Some(DbusType::Variant)) => 191 191 + Ok(MessageItem::Variant(Box::new(to_message_item(other_value, None)?))), 192 192 + 193 193 + // Value not compatible with expected type 194 194 + (other_value, Some(expectation)) => 195 195 + Err(LabeledError { 196 196 + label: format!("`{}` can not be converted to the D-Bus `{:?}` type", 197 197 + other_value.get_type(), expectation), 198 198 + msg: format!("expected a `{:?}` here", expectation), 199 199 + span: Some(other_value.span()), 200 200 + }), 201 201 + 202 202 + // Automatic types (with no type expectation) 203 203 + (Value::String { .. }, None) => 204 204 + to_message_item(value, Some(&DbusType::String)), 205 205 + (Value::Int { .. }, None) => 206 206 + to_message_item(value, Some(&DbusType::Int64)), 207 207 + (Value::Float { .. }, None) => 208 208 + to_message_item(value, Some(&DbusType::Double)), 209 209 + (Value::Bool { .. }, None) => 210 210 + to_message_item(value, Some(&DbusType::Boolean)), 211 211 + (Value::List { .. }, None) => 212 212 + to_message_item(value, Some(&DbusType::Array(DbusType::Variant.into()))), 213 213 + (Value::Record { .. }, None) => 214 214 + to_message_item(value, Some(&DbusType::Array( 215 215 + DbusType::DictEntry( 216 216 + DbusType::String.into(), 217 217 + DbusType::Variant.into() 218 218 + ).into()))), 219 219 + 220 220 + // No expected type, but can't handle this type 221 221 + _ => 222 222 + Err(LabeledError { 223 223 + label: format!("can not use values of type `{}` in D-Bus calls", value.get_type()), 224 224 + msg: "use a supported type here instead".into(), 225 225 + span: Some(value.span()), 226 226 + }) 227 227 + } 228 228 + }

+342

src/dbus_type.rs

reviewed

··· 1 1 + /// Representation of fully specified D-Bus types 2 2 + /// 3 3 + /// [dbus::arg::ArgType] does not sufficiently specify the types inside of a container type, 4 4 + /// and also doesn't provide any parse/dump capability 5 5 + #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] 6 6 + pub enum DbusType { 7 7 + Byte, 8 8 + Boolean, 9 9 + Int16, 10 10 + UInt16, 11 11 + Int32, 12 12 + UInt32, 13 13 + Int64, 14 14 + UInt64, 15 15 + Double, 16 16 + String, 17 17 + ObjectPath, 18 18 + Signature, 19 19 + Array(Box<DbusType>), 20 20 + Struct(Vec<DbusType>), 21 21 + Variant, 22 22 + DictEntry(Box<DbusType>, Box<DbusType>), 23 23 + } 24 24 + 25 25 + impl DbusType { 26 26 + /// Parse one type from a D-Bus signature, and return the remainder 27 27 + pub fn parse(input: &str) -> Result<(DbusType, &str), String> { 28 28 + use self::DbusType::*; 29 29 + 30 30 + if input.is_empty() { 31 31 + return Err("unexpected end of D-Bus type string".into()); 32 32 + } 33 33 + 34 34 + match input.chars().nth(0).unwrap() { 35 35 + 'y' => Ok((Byte, &input[1..])), 36 36 + 'b' => Ok((Boolean, &input[1..])), 37 37 + 'n' => Ok((Int16, &input[1..])), 38 38 + 'q' => Ok((UInt16, &input[1..])), 39 39 + 'i' => Ok((Int32, &input[1..])), 40 40 + 'u' => Ok((UInt32, &input[1..])), 41 41 + 'x' => Ok((Int64, &input[1..])), 42 42 + 't' => Ok((UInt64, &input[1..])), 43 43 + 'd' => Ok((Double, &input[1..])), 44 44 + 's' => Ok((String, &input[1..])), 45 45 + 'o' => Ok((ObjectPath, &input[1..])), 46 46 + 'g' => Ok((Signature, &input[1..])), 47 47 + 'a' => { 48 48 + // The next type is the content type of the array 49 49 + let (content_type, remainder) = Self::parse(&input[1..])?; 50 50 + Ok((Array(content_type.into()), remainder)) 51 51 + }, 52 52 + '(' => { 53 53 + // Parse the struct content until we get to the end ) char 54 54 + let mut remainder = &input[1..]; 55 55 + let mut types = vec![]; 56 56 + loop { 57 57 + if remainder.is_empty() { 58 58 + break Err("unexpected end of D-Bus type string \ 59 59 + before end of array".into()); 60 60 + } else if remainder.starts_with(')') { 61 61 + break Ok((DbusType::Struct(types), &remainder[1..])); 62 62 + } else { 63 63 + let (r#type, new_remainder) = Self::parse(remainder)?; 64 64 + types.push(r#type); 65 65 + remainder = new_remainder; 66 66 + } 67 67 + } 68 68 + }, 69 69 + 'v' => Ok((Variant, &input[1..])), 70 70 + '{' => { 71 71 + // Expect two types 72 72 + let (key_type, key_remainder) = Self::parse(&input[1..])?; 73 73 + let (val_type, val_remainder) = Self::parse(key_remainder)?; 74 74 + // Must end with } 75 75 + if val_remainder.starts_with('}') { 76 76 + Ok((DbusType::DictEntry(key_type.into(), val_type.into()), &val_remainder[1..])) 77 77 + } else { 78 78 + Err(format!("expected `}}` char to end dictionary in D-Bus type \ 79 79 + but remainder is {:?}", val_remainder)) 80 80 + } 81 81 + }, 82 82 + other => Err(format!("unexpected char {other:?} in D-Bus type representation")) 83 83 + } 84 84 + } 85 85 + 86 86 + /// Parse multiple types from a D-Bus signature 87 87 + pub fn parse_all(mut input: &str) -> Result<Vec<DbusType>, String> { 88 88 + let mut out = vec![]; 89 89 + while !input.is_empty() { 90 90 + let (parsed, remainder) = Self::parse(input)?; 91 91 + out.push(parsed); 92 92 + input = remainder; 93 93 + } 94 94 + Ok(out) 95 95 + } 96 96 + 97 97 + /// Convert the D-Bus type into a string suitable for the wire format 98 98 + pub fn stringify(&self) -> String { 99 99 + use self::DbusType::*; 100 100 + 101 101 + match self { 102 102 + Byte => 'y'.into(), 103 103 + Boolean => 'b'.into(), 104 104 + Int16 => 'n'.into(), 105 105 + UInt16 => 'q'.into(), 106 106 + Int32 => 'i'.into(), 107 107 + UInt32 => 'u'.into(), 108 108 + Int64 => 'x'.into(), 109 109 + UInt64 => 't'.into(), 110 110 + Double => 'd'.into(), 111 111 + String => 's'.into(), 112 112 + ObjectPath => 'o'.into(), 113 113 + Signature => 'g'.into(), 114 114 + 115 115 + // a<type> 116 116 + Array(content) => format!("a{}", content.stringify()), 117 117 + 118 118 + // (<type1><type2><typeN..>) 119 119 + Struct(types) => std::iter::once("(".to_owned()) 120 120 + .chain(types.iter().map(|t| t.stringify())) 121 121 + .chain(std::iter::once(")".to_owned())) 122 122 + .collect(), 123 123 + 124 124 + Variant => 'v'.into(), 125 125 + 126 126 + // {<key><val>} 127 127 + DictEntry(key, val) => format!("{{{}{}}}", key.stringify(), val.stringify()), 128 128 + } 129 129 + } 130 130 + } 131 131 + 132 132 + #[cfg(test)] 133 133 + macro_rules! should_parse_to { 134 134 + ($str:expr, $result:expr) => ( 135 135 + assert_eq!(DbusType::parse($str), Ok(($result, ""))) 136 136 + ) 137 137 + } 138 138 + 139 139 + #[test] 140 140 + fn test_parse_simple_types() { 141 141 + use self::DbusType::*; 142 142 + should_parse_to!("y", Byte); 143 143 + should_parse_to!("b", Boolean); 144 144 + should_parse_to!("n", Int16); 145 145 + should_parse_to!("q", UInt16); 146 146 + should_parse_to!("i", Int32); 147 147 + should_parse_to!("u", UInt32); 148 148 + should_parse_to!("x", Int64); 149 149 + should_parse_to!("t", UInt64); 150 150 + should_parse_to!("d", Double); 151 151 + should_parse_to!("s", String); 152 152 + should_parse_to!("o", ObjectPath); 153 153 + should_parse_to!("g", Signature); 154 154 + should_parse_to!("v", Variant); 155 155 + } 156 156 + 157 157 + #[test] 158 158 + fn test_parse_simple_type_remainder() -> Result<(), String> { 159 159 + let (_, remainder) = DbusType::parse("gyn")?; 160 160 + assert_eq!(remainder, "yn"); 161 161 + Ok(()) 162 162 + } 163 163 + 164 164 + #[test] 165 165 + fn test_parse_simple_invalid() { 166 166 + assert!(DbusType::parse("*").is_err()); 167 167 + } 168 168 + 169 169 + #[test] 170 170 + fn test_parse_simple_array() { 171 171 + use self::DbusType::*; 172 172 + should_parse_to!("ay", Array(Byte.into())); 173 173 + } 174 174 + 175 175 + #[test] 176 176 + fn test_parse_nested_array() { 177 177 + use self::DbusType::*; 178 178 + should_parse_to!("aai", Array(Array(Int32.into()).into())); 179 179 + } 180 180 + 181 181 + #[test] 182 182 + fn test_parse_array_remainder() -> Result<(), String> { 183 183 + let (_, remainder) = DbusType::parse("ay(oi)")?; 184 184 + assert_eq!(remainder, "(oi)"); 185 185 + Ok(()) 186 186 + } 187 187 + 188 188 + #[test] 189 189 + fn test_parse_array_unclosed() { 190 190 + assert!(DbusType::parse("a").is_err()); 191 191 + } 192 192 + 193 193 + #[test] 194 194 + fn test_parse_simple_struct() { 195 195 + use self::DbusType::*; 196 196 + should_parse_to!("()", Struct(vec![])); 197 197 + should_parse_to!("(y)", Struct(vec![Byte])); 198 198 + should_parse_to!("(sy)", Struct(vec![String, Byte])); 199 199 + should_parse_to!("(xto)", Struct(vec![Int64, UInt64, ObjectPath])); 200 200 + } 201 201 + 202 202 + #[test] 203 203 + fn test_parse_nested_struct() { 204 204 + use self::DbusType::*; 205 205 + should_parse_to!("((xx))", Struct(vec![Struct(vec![Int64, Int64])])); 206 206 + should_parse_to!("(y(xx))", Struct(vec![Byte, Struct(vec![Int64, Int64])])); 207 207 + should_parse_to!("(y(ss)o)", Struct(vec![Byte, Struct(vec![String, String]), ObjectPath])); 208 208 + should_parse_to!("((yy)s)", Struct(vec![Struct(vec![Byte, Byte]), String])); 209 209 + } 210 210 + 211 211 + #[test] 212 212 + fn test_parse_struct_remainder() -> Result<(), String> { 213 213 + let (_, remainder) = DbusType::parse("(oi)ay")?; 214 214 + assert_eq!(remainder, "ay"); 215 215 + Ok(()) 216 216 + } 217 217 + 218 218 + #[test] 219 219 + fn test_parse_struct_unclosed() { 220 220 + assert!(DbusType::parse("(ss").is_err()); 221 221 + } 222 222 + 223 223 + #[test] 224 224 + fn test_parse_dict_entry() { 225 225 + use self::DbusType::*; 226 226 + should_parse_to!("{ss}", DictEntry(String.into(), String.into())); 227 227 + should_parse_to!("{s(bd)}", DictEntry(String.into(), Struct(vec![Boolean, Double]).into())); 228 228 + } 229 229 + 230 230 + #[test] 231 231 + fn test_parse_array_dict() { 232 232 + use self::DbusType::*; 233 233 + should_parse_to!("a{sd}", Array(DictEntry(String.into(), Double.into()).into())); 234 234 + } 235 235 + 236 236 + #[test] 237 237 + fn test_parse_dict_entry_remainder() -> Result<(), String> { 238 238 + let (_, remainder) = DbusType::parse("{sd}{sai}")?; 239 239 + assert_eq!(remainder, "{sai}"); 240 240 + Ok(()) 241 241 + } 242 242 + 243 243 + #[test] 244 244 + fn test_parse_dict_entry_unclosed() { 245 245 + assert!(DbusType::parse("{ss").is_err()); 246 246 + } 247 247 + 248 248 + #[test] 249 249 + fn test_parse_all() { 250 250 + use self::DbusType::*; 251 251 + assert_eq!(DbusType::parse_all(""), Ok(vec![])); 252 252 + assert_eq!( 253 253 + DbusType::parse_all("s"), 254 254 + Ok(vec![ 255 255 + String, 256 256 + ]) 257 257 + ); 258 258 + assert_eq!( 259 259 + DbusType::parse_all("isbb"), 260 260 + Ok(vec![ 261 261 + Int32, 262 262 + String, 263 263 + Boolean, 264 264 + Boolean, 265 265 + ]) 266 266 + ); 267 267 + assert_eq!( 268 268 + DbusType::parse_all("ia{s(bi)}s"), 269 269 + Ok(vec![ 270 270 + Int32, 271 271 + Array(DictEntry(String.into(), Struct(vec![Boolean, Int32]).into()).into()), 272 272 + String, 273 273 + ]) 274 274 + ); 275 275 + } 276 276 + 277 277 + #[cfg(test)] 278 278 + macro_rules! should_stringify_to { 279 279 + ($type:expr, $result:expr) => ( 280 280 + assert_eq!(DbusType::stringify(&$type), $result) 281 281 + ) 282 282 + } 283 283 + 284 284 + #[test] 285 285 + fn test_stringify_simple_types() { 286 286 + use self::DbusType::*; 287 287 + should_stringify_to!(Byte, "y"); 288 288 + should_stringify_to!(Boolean, "b"); 289 289 + should_stringify_to!(Int16, "n"); 290 290 + should_stringify_to!(UInt16, "q"); 291 291 + should_stringify_to!(Int32, "i"); 292 292 + should_stringify_to!(UInt32, "u"); 293 293 + should_stringify_to!(Int64, "x"); 294 294 + should_stringify_to!(UInt64, "t"); 295 295 + should_stringify_to!(Double, "d"); 296 296 + should_stringify_to!(String, "s"); 297 297 + should_stringify_to!(ObjectPath, "o"); 298 298 + should_stringify_to!(Signature, "g"); 299 299 + should_stringify_to!(Variant, "v"); 300 300 + } 301 301 + 302 302 + #[test] 303 303 + fn test_stringify_array() { 304 304 + use self::DbusType::*; 305 305 + should_stringify_to!(Array(Variant.into()), "av"); 306 306 + should_stringify_to!(Array(Array(String.into()).into()), "aas"); 307 307 + } 308 308 + 309 309 + #[test] 310 310 + fn test_stringify_struct() { 311 311 + use self::DbusType::*; 312 312 + should_stringify_to!(Struct(vec![]), "()"); 313 313 + should_stringify_to!(Struct(vec![Int32]), "(i)"); 314 314 + should_stringify_to!(Struct(vec![Int32, String]), "(is)"); 315 315 + should_stringify_to!(Struct(vec![Byte, Int32, String]), "(yis)"); 316 316 + should_stringify_to!(Struct(vec![Byte, Struct(vec![String, Boolean]), String]), "(y(sb)s)"); 317 317 + } 318 318 + 319 319 + #[test] 320 320 + fn test_stringify_dict_entry() { 321 321 + use self::DbusType::*; 322 322 + should_stringify_to!(DictEntry(String.into(), Int32.into()), "{si}"); 323 323 + should_stringify_to!(DictEntry(Int32.into(), String.into()), "{is}"); 324 324 + } 325 325 + 326 326 + #[test] 327 327 + fn test_stringify_nested() { 328 328 + use self::DbusType::*; 329 329 + should_stringify_to!(Array(DictEntry(String.into(), Int32.into()).into()), "a{si}"); 330 330 + should_stringify_to!( 331 331 + Array( 332 332 + DictEntry( 333 333 + String.into(), 334 334 + Struct(vec![ 335 335 + Byte, 336 336 + Array(Int32.into()) 337 337 + ]).into() 338 338 + ).into() 339 339 + ), 340 340 + "a{s(yai)}" 341 341 + ); 342 342 + }

+23 -3

src/main.rs

reviewed

··· 1 1 use nu_plugin::{serve_plugin, MsgPackSerializer, Plugin, EvaluatedCall, LabeledError}; 2 2 - use nu_protocol::{PluginSignature, Value, SyntaxShape, PluginExample}; 2 2 + use nu_protocol::{PluginSignature, Value, SyntaxShape, PluginExample, Span}; 3 3 4 4 mod config; 5 5 mod client; 6 6 mod convert; 7 7 + mod dbus_type; 7 8 8 9 use config::*; 9 10 use client::*; ··· 25 26 .is_dbus_command() 26 27 .accepts_dbus_client_options() 27 28 .usage("Call a method and get its response") 29 29 + .extra_usage("Returns an array if the method call returns more than one value.") 28 30 .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 31 31 + .named("signature", SyntaxShape::String, 32 32 + "Signature of the arguments to send, in D-Bus format\n\ 33 33 + If not provided, they will be guessed automatically (but poorly)", None) 34 34 + .switch("no-flatten", "Always return a list of all return values", None) 29 35 .required_named("dest", SyntaxShape::String, 30 36 "The name of the connection to send the method to", 31 37 None) ··· 35 41 "The name of the interface the method belongs to") 36 42 .required("method", SyntaxShape::String, 37 43 "The name of the method to send") 44 44 + .rest("args", SyntaxShape::Any, 45 45 + "Arguments to send with the method call") 38 46 .plugin_examples(vec![ 39 47 PluginExample { 40 48 example: "dbus call --dest=org.freedesktop.DBus \ ··· 98 106 fn call(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> { 99 107 let config = DbusClientConfig::try_from(call)?; 100 108 let dbus = DbusClient::new(config)?; 101 101 - dbus.call( 109 109 + let values = dbus.call( 102 110 &call.get_flag("dest")?.unwrap(), 103 111 &call.req(0)?, 104 112 &call.req(1)?, 105 113 &call.req(2)?, 106 106 - ) 114 114 + call.get_flag("signature")?.as_ref(), 115 115 + &call.positional[3..] 116 116 + )?; 117 117 + 118 118 + let flatten = !call.get_flag::<bool>("no-flatten")?.unwrap_or(false); 119 119 + 120 120 + // Make the output easier to deal with by returning a list only if there are multiple return 121 121 + // values (not so common) 122 122 + match values.len() { 123 123 + 0 if flatten => Ok(Value::nothing(Span::unknown())), 124 124 + 1 if flatten => Ok(values.into_iter().nth(0).unwrap()), 125 125 + _ => Ok(Value::list(values, Span::unknown())) 126 126 + } 107 127 } 108 128 }