+42

README.md

reviewed

··· 20 20 dbus get - Get a D-Bus property 21 21 dbus get-all - Get all D-Bus property for the given objects 22 22 dbus introspect - Introspect a D-Bus object 23 23 + dbus list - List all available connection names on the bus 23 24 dbus set - Get all D-Bus property for the given objects 24 25 25 26 Flags: ··· 196 197 Set the volume of Spotify to 50% 197 198 > dbus set --dest=org.mpris.MediaPlayer2.spotify /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player Volume 0.5 198 199 200 200 + ## `dbus list` 201 201 + 202 202 + List all available connection names on the bus 203 203 + 204 204 + These can be used as arguments for --dest on any of the other commands. 205 205 + 206 206 + Search terms: dbus 207 207 + 208 208 + Usage: 209 209 + > dbus list {flags} (pattern) 210 210 + 211 211 + Flags: 212 212 + -h, --help - Display the help message for this command 213 213 + --session - Send to the session message bus (default) 214 214 + --system - Send to the system message bus 215 215 + --started - Send to the bus that started this process, if applicable 216 216 + --bus <String> - Send to the bus server at the given address 217 217 + --peer <String> - Send to a non-bus D-Bus server at the given address. Will not call the Hello method on initialization. 218 218 + --timeout <Duration> - How long to wait for a response 219 219 + 220 220 + Parameters: 221 221 + pattern <string>: An optional glob-like pattern to filter the result by (optional) 222 222 + 223 223 + Examples: 224 224 + List all names available on the bus 225 225 + > dbus list 226 226 + 227 227 + List top-level freedesktop.org names on the bus (e.g. matches `org.freedesktop.PowerManagement`, but not `org.freedesktop.Management.Inhibit`) 228 228 + > dbus list org.freedesktop.* 229 229 + ╭───┬───────────────────────────────╮ 230 230 + │ 0 │ org.freedesktop.DBus │ 231 231 + │ 1 │ org.freedesktop.Flatpak │ 232 232 + │ 2 │ org.freedesktop.Notifications │ 233 233 + ╰───┴───────────────────────────────╯ 234 234 + 235 235 + List all MPRIS2 media players on the bus 236 236 + > dbus list org.mpris.MediaPlayer2.** 237 237 + ╭───┬────────────────────────────────────────────────╮ 238 238 + │ 0 │ org.mpris.MediaPlayer2.spotify │ 239 239 + │ 1 │ org.mpris.MediaPlayer2.kdeconnect.mpris_000001 │ 240 240 + ╰───┴────────────────────────────────────────────────╯

+27 -1

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}, dbus_type::DbusType, convert::to_message_item, introspection::Node}; 5 5 + use crate::{config::{DbusClientConfig, DbusBusChoice}, dbus_type::DbusType, convert::to_message_item, introspection::Node, pattern::Pattern}; 6 6 7 7 /// Executes D-Bus actions on a connection, handling nushell types 8 8 pub struct DbusClient { ··· 317 317 .map_err(|err| self.error(err, context))?; 318 318 319 319 Ok(()) 320 320 + } 321 321 + 322 322 + pub fn list(&self, pattern: Option<&Pattern>) 323 323 + -> Result<Vec<String>, LabeledError> 324 324 + { 325 325 + let context = "while listing D-Bus connection names"; 326 326 + 327 327 + let message = Message::new_method_call( 328 328 + "org.freedesktop.DBus", 329 329 + "/org/freedesktop/DBus", 330 330 + "org.freedesktop.DBus", 331 331 + "ListNames" 332 332 + ).map_err(|err| self.error(err, context))?; 333 333 + 334 334 + self.conn.send_with_reply_and_block(message, self.config.timeout.item) 335 335 + .map_err(|err| self.error(err, context)) 336 336 + .and_then(|reply| reply.read1().map_err(|err| self.error(err, context))) 337 337 + .map(|names: Vec<String>| { 338 338 + // Filter the names by the pattern 339 339 + if let Some(pattern) = pattern { 340 340 + eprintln!("pattern: {:?}", pattern); 341 341 + names.into_iter().filter(|name| pattern.is_match(name)).collect() 342 342 + } else { 343 343 + names 344 344 + } 345 345 + }) 320 346 } 321 347 }

+58 -5

src/main.rs

reviewed

··· 6 6 mod convert; 7 7 mod dbus_type; 8 8 mod introspection; 9 9 + mod pattern; 9 10 10 11 use config::*; 11 12 use client::*; 13 13 + 14 14 + use crate::pattern::Pattern; 12 15 13 16 fn main() { 14 17 serve_plugin(&mut NuPluginDbus, MsgPackSerializer) ··· 29 32 PluginSignature::build("dbus introspect") 30 33 .is_dbus_command() 31 34 .accepts_dbus_client_options() 35 35 + .accepts_timeout() 32 36 .usage("Introspect a D-Bus object") 33 37 .extra_usage("Returns information about available nodes, interfaces, methods, \ 34 38 signals, and properties on the given object path") 35 35 - .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 36 39 .required_named("dest", SyntaxShape::String, 37 40 "The name of the connection that owns the object", 38 41 None) ··· 63 66 PluginSignature::build("dbus call") 64 67 .is_dbus_command() 65 68 .accepts_dbus_client_options() 69 69 + .accepts_timeout() 66 70 .usage("Call a method and get its response") 67 71 .extra_usage("Returns an array if the method call returns more than one value.") 68 68 - .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 69 72 .named("signature", SyntaxShape::String, 70 73 "Signature of the arguments to send, in D-Bus format.\n \ 71 74 If not provided, they will be determined from introspection.\n \ ··· 105 108 PluginSignature::build("dbus get") 106 109 .is_dbus_command() 107 110 .accepts_dbus_client_options() 111 111 + .accepts_timeout() 108 112 .usage("Get a D-Bus property") 109 109 - .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 110 113 .required_named("dest", SyntaxShape::String, 111 114 "The name of the connection to read the property from", 112 115 None) ··· 135 138 PluginSignature::build("dbus get-all") 136 139 .is_dbus_command() 137 140 .accepts_dbus_client_options() 141 141 + .accepts_timeout() 138 142 .usage("Get all D-Bus property for the given objects") 139 139 - .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 140 143 .required_named("dest", SyntaxShape::String, 141 144 "The name of the connection to read the property from", 142 145 None) ··· 160 163 PluginSignature::build("dbus set") 161 164 .is_dbus_command() 162 165 .accepts_dbus_client_options() 166 166 + .accepts_timeout() 163 167 .usage("Get all D-Bus property for the given objects") 164 164 - .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 165 168 .named("signature", SyntaxShape::String, 166 169 "Signature of the value to set, in D-Bus format.\n \ 167 170 If not provided, it will be determined from introspection.\n \ ··· 187 190 result: None, 188 191 }, 189 192 ]), 193 193 + PluginSignature::build("dbus list") 194 194 + .is_dbus_command() 195 195 + .accepts_dbus_client_options() 196 196 + .accepts_timeout() 197 197 + .usage("List all available connection names on the bus") 198 198 + .extra_usage("These can be used as arguments for --dest on any of the other commands.") 199 199 + .optional("pattern", SyntaxShape::String, 200 200 + "An optional glob-like pattern to filter the result by") 201 201 + .plugin_examples(vec![ 202 202 + PluginExample { 203 203 + example: "dbus list".into(), 204 204 + description: "List all names available on the bus".into(), 205 205 + result: None, 206 206 + }, 207 207 + PluginExample { 208 208 + example: "dbus list org.freedesktop.*".into(), 209 209 + description: "List top-level freedesktop.org names on the bus \ 210 210 + (e.g. matches `org.freedesktop.PowerManagement`, \ 211 211 + but not `org.freedesktop.Management.Inhibit`)".into(), 212 212 + result: Some(Value::list(vec![ 213 213 + str!("org.freedesktop.DBus"), 214 214 + str!("org.freedesktop.Flatpak"), 215 215 + str!("org.freedesktop.Notifications"), 216 216 + ], Span::unknown())), 217 217 + }, 218 218 + PluginExample { 219 219 + example: "dbus list org.mpris.MediaPlayer2.**".into(), 220 220 + description: "List all MPRIS2 media players on the bus".into(), 221 221 + result: Some(Value::list(vec![ 222 222 + str!("org.mpris.MediaPlayer2.spotify"), 223 223 + str!("org.mpris.MediaPlayer2.kdeconnect.mpris_000001"), 224 224 + ], Span::unknown())), 225 225 + }, 226 226 + ]) 190 227 ] 191 228 } 192 229 ··· 208 245 "dbus get" => self.get(call), 209 246 "dbus get-all" => self.get_all(call), 210 247 "dbus set" => self.set(call), 248 248 + "dbus list" => self.list(call), 211 249 212 250 _ => Err(LabeledError { 213 251 label: "Plugin invoked with unknown command name".into(), ··· 222 260 trait DbusSignatureUtilExt { 223 261 fn is_dbus_command(self) -> Self; 224 262 fn accepts_dbus_client_options(self) -> Self; 263 263 + fn accepts_timeout(self) -> Self; 225 264 } 226 265 227 266 impl DbusSignatureUtilExt for PluginSignature { ··· 239 278 "Send to a non-bus D-Bus server at the given address. \ 240 279 Will not call the Hello method on initialization.", 241 280 None) 281 281 + } 282 282 + 283 283 + fn accepts_timeout(self) -> Self { 284 284 + self.named("timeout", SyntaxShape::Duration, "How long to wait for a response", None) 242 285 } 243 286 } 244 287 ··· 309 352 &call.req(3)?, 310 353 )?; 311 354 Ok(Value::nothing(call.head)) 355 355 + } 356 356 + 357 357 + fn list(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> { 358 358 + let config = DbusClientConfig::try_from(call)?; 359 359 + let dbus = DbusClient::new(config)?; 360 360 + let pattern = call.opt::<String>(0)?.map(|pat| Pattern::new(&pat, Some('.'))); 361 361 + let result = dbus.list(pattern.as_ref())?; 362 362 + Ok(Value::list( 363 363 + result.into_iter().map(|s| Value::string(s, call.head)).collect(), 364 364 + call.head)) 312 365 } 313 366 }

+387

src/pattern.rs

reviewed

··· 1 1 + #[derive(Debug, Clone, PartialEq, Eq)] 2 2 + pub struct Pattern { 3 3 + separator: Option<char>, 4 4 + tokens: Vec<PatternToken>, 5 5 + } 6 6 + 7 7 + #[derive(Debug, Clone, PartialEq, Eq)] 8 8 + enum PatternToken { 9 9 + Exact(String), 10 10 + OneWildcard, 11 11 + ManyWildcard, 12 12 + AnyChar, 13 13 + } 14 14 + 15 15 + impl Pattern { 16 16 + pub fn new(pattern: &str, separator: Option<char>) -> Pattern { 17 17 + let mut tokens = vec![]; 18 18 + for ch in pattern.chars() { 19 19 + match ch { 20 20 + '*' => 21 21 + if tokens.last() == Some(&PatternToken::OneWildcard) { 22 22 + *tokens.last_mut().unwrap() = PatternToken::ManyWildcard; 23 23 + } else { 24 24 + tokens.push(PatternToken::OneWildcard); 25 25 + }, 26 26 + '?' => 27 27 + tokens.push(PatternToken::AnyChar), 28 28 + _ => 29 29 + match tokens.last_mut() { 30 30 + Some(PatternToken::Exact(ref mut s)) => s.push(ch), 31 31 + _ => tokens.push(PatternToken::Exact(ch.into())), 32 32 + }, 33 33 + } 34 34 + } 35 35 + Pattern { separator, tokens } 36 36 + } 37 37 + 38 38 + pub fn is_match(&self, string: &str) -> bool { 39 39 + #[derive(Debug)] 40 40 + enum MatchState { 41 41 + Precise, 42 42 + ScanAhead { stop_at_separator: bool }, 43 43 + } 44 44 + let mut state = MatchState::Precise; 45 45 + let mut tokens = &self.tokens[..]; 46 46 + let mut search_str = string; 47 47 + while !tokens.is_empty() { 48 48 + match tokens.first().unwrap() { 49 49 + PatternToken::Exact(s) => { 50 50 + if search_str.starts_with(s) { 51 51 + // Exact match passed. Consume the token and string and continue 52 52 + tokens = &tokens[1..]; 53 53 + search_str = &search_str[s.len()..]; 54 54 + state = MatchState::Precise; 55 55 + } else { 56 56 + match state { 57 57 + MatchState::Precise => { 58 58 + // Can't possibly match 59 59 + return false; 60 60 + }, 61 61 + MatchState::ScanAhead { stop_at_separator } => { 62 62 + if search_str.is_empty() { 63 63 + // End of input, can't match 64 64 + return false; 65 65 + } 66 66 + if stop_at_separator && 67 67 + self.separator.is_some_and(|sep| search_str.starts_with(sep)) { 68 68 + // Found the separator. Consume a char and revert to precise 69 69 + // mode 70 70 + search_str = &search_str[1..]; 71 71 + state = MatchState::Precise; 72 72 + } else { 73 73 + // Skip the non-matching char and continue 74 74 + search_str = &search_str[1..]; 75 75 + } 76 76 + } 77 77 + } 78 78 + } 79 79 + }, 80 80 + PatternToken::OneWildcard => { 81 81 + // Set the mode to ScanAhead, stopping at separator 82 82 + state = MatchState::ScanAhead { stop_at_separator: true }; 83 83 + tokens = &tokens[1..]; 84 84 + }, 85 85 + PatternToken::ManyWildcard => { 86 86 + // Set the mode to ScanAhead, ignoring separator 87 87 + state = MatchState::ScanAhead { stop_at_separator: false }; 88 88 + tokens = &tokens[1..]; 89 89 + }, 90 90 + PatternToken::AnyChar => { 91 91 + if !search_str.is_empty() { 92 92 + // Take a char from the search str and continue 93 93 + search_str = &search_str[1..]; 94 94 + tokens = &tokens[1..]; 95 95 + } else { 96 96 + // End of input 97 97 + return false; 98 98 + } 99 99 + }, 100 100 + } 101 101 + } 102 102 + #[cfg(test)] { 103 103 + println!("end, state={:?}, search_str={:?}, tokens={:?}", state, search_str, tokens); 104 104 + } 105 105 + if !search_str.is_empty() { 106 106 + // If the search str is not empty at the end 107 107 + match state { 108 108 + // We didn't end with a wildcard, so this is a fail 109 109 + MatchState::Precise => false, 110 110 + // This could be a match as long as the separator isn't contained in the remainder 111 111 + MatchState::ScanAhead { stop_at_separator: true } => 112 112 + if let Some(separator) = self.separator { 113 113 + !search_str.contains(separator) 114 114 + } else { 115 115 + // No separator specified, so this is a success 116 116 + true 117 117 + }, 118 118 + // Always a success, no matter what remains 119 119 + MatchState::ScanAhead { stop_at_separator: false } => true, 120 120 + } 121 121 + } else { 122 122 + // The match has succeeded - there is nothing more to match 123 123 + true 124 124 + } 125 125 + } 126 126 + } 127 127 + 128 128 + #[test] 129 129 + fn test_pattern_new() { 130 130 + assert_eq!( 131 131 + Pattern::new("", Some('/')), 132 132 + Pattern { separator: Some('/'), tokens: vec![] } 133 133 + ); 134 134 + assert_eq!( 135 135 + Pattern::new("", None), 136 136 + Pattern { separator: None, tokens: vec![] } 137 137 + ); 138 138 + assert_eq!( 139 139 + Pattern::new("org.freedesktop.DBus", Some('.')), 140 140 + Pattern { separator: Some('.'), tokens: vec![ 141 141 + PatternToken::Exact("org.freedesktop.DBus".into()), 142 142 + ] } 143 143 + ); 144 144 + assert_eq!( 145 145 + Pattern::new("*", Some('.')), 146 146 + Pattern { separator: Some('.'), tokens: vec![ 147 147 + PatternToken::OneWildcard, 148 148 + ] } 149 149 + ); 150 150 + assert_eq!( 151 151 + Pattern::new("**", Some('.')), 152 152 + Pattern { separator: Some('.'), tokens: vec![ 153 153 + PatternToken::ManyWildcard, 154 154 + ] } 155 155 + ); 156 156 + assert_eq!( 157 157 + Pattern::new("?", Some('.')), 158 158 + Pattern { separator: Some('.'), tokens: vec![ 159 159 + PatternToken::AnyChar, 160 160 + ] } 161 161 + ); 162 162 + assert_eq!( 163 163 + Pattern::new("org.freedesktop.*", Some('.')), 164 164 + Pattern { separator: Some('.'), tokens: vec![ 165 165 + PatternToken::Exact("org.freedesktop.".into()), 166 166 + PatternToken::OneWildcard, 167 167 + ] } 168 168 + ); 169 169 + assert_eq!( 170 170 + Pattern::new("org.freedesktop.**", Some('.')), 171 171 + Pattern { separator: Some('.'), tokens: vec![ 172 172 + PatternToken::Exact("org.freedesktop.".into()), 173 173 + PatternToken::ManyWildcard, 174 174 + ] } 175 175 + ); 176 176 + assert_eq!( 177 177 + Pattern::new("org.*.DBus", Some('.')), 178 178 + Pattern { separator: Some('.'), tokens: vec![ 179 179 + PatternToken::Exact("org.".into()), 180 180 + PatternToken::OneWildcard, 181 181 + PatternToken::Exact(".DBus".into()), 182 182 + ] } 183 183 + ); 184 184 + assert_eq!( 185 185 + Pattern::new("org.**.DBus", Some('.')), 186 186 + Pattern { separator: Some('.'), tokens: vec![ 187 187 + PatternToken::Exact("org.".into()), 188 188 + PatternToken::ManyWildcard, 189 189 + PatternToken::Exact(".DBus".into()), 190 190 + ] } 191 191 + ); 192 192 + assert_eq!( 193 193 + Pattern::new("org.**.?Bus", Some('.')), 194 194 + Pattern { separator: Some('.'), tokens: vec![ 195 195 + PatternToken::Exact("org.".into()), 196 196 + PatternToken::ManyWildcard, 197 197 + PatternToken::Exact(".".into()), 198 198 + PatternToken::AnyChar, 199 199 + PatternToken::Exact("Bus".into()), 200 200 + ] } 201 201 + ); 202 202 + assert_eq!( 203 203 + Pattern::new("org.free*top", Some('.')), 204 204 + Pattern { separator: Some('.'), tokens: vec![ 205 205 + PatternToken::Exact("org.free".into()), 206 206 + PatternToken::OneWildcard, 207 207 + PatternToken::Exact("top".into()), 208 208 + ] } 209 209 + ); 210 210 + assert_eq!( 211 211 + Pattern::new("org.free**top", Some('.')), 212 212 + Pattern { separator: Some('.'), tokens: vec![ 213 213 + PatternToken::Exact("org.free".into()), 214 214 + PatternToken::ManyWildcard, 215 215 + PatternToken::Exact("top".into()), 216 216 + ] } 217 217 + ); 218 218 + assert_eq!( 219 219 + Pattern::new("org.**top", Some('.')), 220 220 + Pattern { separator: Some('.'), tokens: vec![ 221 221 + PatternToken::Exact("org.".into()), 222 222 + PatternToken::ManyWildcard, 223 223 + PatternToken::Exact("top".into()), 224 224 + ] } 225 225 + ); 226 226 + assert_eq!( 227 227 + Pattern::new("**top", Some('.')), 228 228 + Pattern { separator: Some('.'), tokens: vec![ 229 229 + PatternToken::ManyWildcard, 230 230 + PatternToken::Exact("top".into()), 231 231 + ] } 232 232 + ); 233 233 + assert_eq!( 234 234 + Pattern::new("org.free**", Some('.')), 235 235 + Pattern { separator: Some('.'), tokens: vec![ 236 236 + PatternToken::Exact("org.free".into()), 237 237 + PatternToken::ManyWildcard, 238 238 + ] } 239 239 + ); 240 240 + } 241 241 + 242 242 + #[test] 243 243 + fn test_pattern_is_match_empty() { 244 244 + let pat = Pattern { separator: Some('.'), tokens: vec![] }; 245 245 + assert!(pat.is_match("")); 246 246 + assert!(!pat.is_match("anystring")); 247 247 + assert!(!pat.is_match("anystring.anyotherstring")); 248 248 + } 249 249 + 250 250 + #[test] 251 251 + fn test_pattern_is_match_exact() { 252 252 + let pat = Pattern { separator: Some('.'), tokens: vec![ 253 253 + PatternToken::Exact("specific".into()), 254 254 + ] }; 255 255 + assert!(pat.is_match("specific")); 256 256 + assert!(!pat.is_match("")); 257 257 + assert!(!pat.is_match("specifi")); 258 258 + assert!(!pat.is_match("specifica")); 259 259 + } 260 260 + 261 261 + #[test] 262 262 + fn test_pattern_is_match_one_wildcard() { 263 263 + let pat = Pattern { separator: Some('.'), tokens: vec![ 264 264 + PatternToken::Exact("foo.".into()), 265 265 + PatternToken::OneWildcard, 266 266 + PatternToken::Exact(".baz".into()), 267 267 + ] }; 268 268 + assert!(pat.is_match("foo.bar.baz")); 269 269 + assert!(pat.is_match("foo.grok.baz")); 270 270 + assert!(pat.is_match("foo..baz")); 271 271 + assert!(!pat.is_match("foo.ono.notmatch.baz")); 272 272 + assert!(!pat.is_match("")); 273 273 + assert!(!pat.is_match("specifi")); 274 274 + assert!(!pat.is_match("specifica.baz")); 275 275 + assert!(!pat.is_match("foo.specifica")); 276 276 + } 277 277 + 278 278 + #[test] 279 279 + fn test_pattern_is_match_one_wildcard_at_end() { 280 280 + let pat = Pattern { separator: Some('.'), tokens: vec![ 281 281 + PatternToken::Exact("foo.".into()), 282 282 + PatternToken::OneWildcard, 283 283 + ] }; 284 284 + assert!(pat.is_match("foo.bar")); 285 285 + assert!(pat.is_match("foo.grok")); 286 286 + assert!(pat.is_match("foo.")); 287 287 + assert!(!pat.is_match("foo.ono.notmatch.baz")); 288 288 + assert!(!pat.is_match("")); 289 289 + assert!(!pat.is_match("specifi")); 290 290 + assert!(!pat.is_match("specifica.baz")); 291 291 + } 292 292 + 293 293 + #[test] 294 294 + fn test_pattern_is_match_one_wildcard_at_start() { 295 295 + let pat = Pattern { separator: Some('.'), tokens: vec![ 296 296 + PatternToken::OneWildcard, 297 297 + PatternToken::Exact(".bar".into()), 298 298 + ] }; 299 299 + assert!(pat.is_match("foo.bar")); 300 300 + assert!(pat.is_match("grok.bar")); 301 301 + assert!(pat.is_match(".bar")); 302 302 + assert!(!pat.is_match("foo.ono.notmatch.bar")); 303 303 + assert!(!pat.is_match("")); 304 304 + assert!(!pat.is_match("specifi")); 305 305 + assert!(!pat.is_match("specifica.baz")); 306 306 + } 307 307 + 308 308 + #[test] 309 309 + fn test_pattern_is_match_one_wildcard_no_separator() { 310 310 + let pat = Pattern { separator: None, tokens: vec![ 311 311 + PatternToken::Exact("foo.".into()), 312 312 + PatternToken::OneWildcard, 313 313 + PatternToken::Exact(".baz".into()), 314 314 + ] }; 315 315 + assert!(pat.is_match("foo.bar.baz")); 316 316 + assert!(pat.is_match("foo.grok.baz")); 317 317 + assert!(pat.is_match("foo..baz")); 318 318 + assert!(pat.is_match("foo.this.shouldmatch.baz")); 319 319 + assert!(pat.is_match("foo.this.should.match.baz")); 320 320 + assert!(!pat.is_match("")); 321 321 + assert!(!pat.is_match("specifi")); 322 322 + assert!(!pat.is_match("specifica.baz")); 323 323 + assert!(!pat.is_match("foo.specifica")); 324 324 + } 325 325 + 326 326 + #[test] 327 327 + fn test_pattern_is_match_many_wildcard() { 328 328 + let pat = Pattern { separator: Some('.'), tokens: vec![ 329 329 + PatternToken::Exact("foo.".into()), 330 330 + PatternToken::ManyWildcard, 331 331 + PatternToken::Exact(".baz".into()), 332 332 + ] }; 333 333 + assert!(pat.is_match("foo.bar.baz")); 334 334 + assert!(pat.is_match("foo.grok.baz")); 335 335 + assert!(pat.is_match("foo..baz")); 336 336 + assert!(pat.is_match("foo.this.shouldmatch.baz")); 337 337 + assert!(pat.is_match("foo.this.should.match.baz")); 338 338 + assert!(!pat.is_match("")); 339 339 + assert!(!pat.is_match("specifi")); 340 340 + assert!(!pat.is_match("specifica.baz")); 341 341 + assert!(!pat.is_match("foo.specifica")); 342 342 + } 343 343 + 344 344 + #[test] 345 345 + fn test_pattern_is_match_many_wildcard_at_end() { 346 346 + let pat = Pattern { separator: Some('.'), tokens: vec![ 347 347 + PatternToken::Exact("foo.".into()), 348 348 + PatternToken::ManyWildcard, 349 349 + ] }; 350 350 + assert!(pat.is_match("foo.bar")); 351 351 + assert!(pat.is_match("foo.grok")); 352 352 + assert!(pat.is_match("foo.")); 353 353 + assert!(pat.is_match("foo.this.should.match")); 354 354 + assert!(!pat.is_match("")); 355 355 + assert!(!pat.is_match("specifi")); 356 356 + assert!(!pat.is_match("specifica.baz")); 357 357 + } 358 358 + 359 359 + #[test] 360 360 + fn test_pattern_is_match_many_wildcard_at_start() { 361 361 + let pat = Pattern { separator: Some('.'), tokens: vec![ 362 362 + PatternToken::ManyWildcard, 363 363 + PatternToken::Exact(".bar".into()), 364 364 + ] }; 365 365 + assert!(pat.is_match("foo.bar")); 366 366 + assert!(pat.is_match("grok.bar")); 367 367 + assert!(pat.is_match("should.match.bar")); 368 368 + assert!(pat.is_match(".bar")); 369 369 + assert!(!pat.is_match("")); 370 370 + assert!(!pat.is_match("specifi")); 371 371 + assert!(!pat.is_match("specifica.baz")); 372 372 + } 373 373 + 374 374 + #[test] 375 375 + fn test_pattern_is_match_any_char() { 376 376 + let pat = Pattern { separator: Some('.'), tokens: vec![ 377 377 + PatternToken::Exact("fo".into()), 378 378 + PatternToken::AnyChar, 379 379 + PatternToken::Exact(".baz".into()), 380 380 + ] }; 381 381 + assert!(pat.is_match("foo.baz")); 382 382 + assert!(pat.is_match("foe.baz")); 383 383 + assert!(pat.is_match("foi.baz")); 384 384 + assert!(!pat.is_match("")); 385 385 + assert!(!pat.is_match("fooo.baz")); 386 386 + assert!(!pat.is_match("fo.baz")); 387 387 + }