2019-05-18 15:59:27 +02:00
#![ crate_name = " fzf " ]
/**
* Return a filtered ` Vec ` of elements that contain the substring ` needle ` .
* /
2019-05-18 15:06:42 +02:00
pub fn filter_substring < ' a > ( needle : & str , haystack : & Vec < & ' a str > ) -> Vec < & ' a str > {
return haystack
. iter ( )
. filter ( | s | s . contains ( needle ) )
. cloned ( )
. collect ( ) ;
}
2019-05-18 15:59:27 +02:00
/**
* Return a filtered ` Vec ` of elements which ` needle ` is a subsequence of .
* ( I know what I ’ m doing . Let me end a sentence with a preposition . ) :^ )
* See ` is_subsequence ` for more information on that .
* /
2019-05-18 15:06:42 +02:00
pub fn filter_subsequence < ' a > ( needle : & str , haystack : & Vec < & ' a str > ) -> Vec < & ' a str > {
return haystack
. iter ( )
. filter ( | s | is_subsequence ( needle , s ) )
. cloned ( )
. collect ( ) ;
}
2019-05-18 15:59:27 +02:00
/**
* Check whether the needle is a subsequence of the string .
* This is the case if string contains all of the characters in needle in the correct order , but
* not necessarily in succession .
*
* ` ` `
* use fzf ::is_subsequence ;
* // ‘as’ is contained in ‘a(d)s’
* assert! ( is_subsequence ( " as " , " ads " ) ) ;
* // but not in ‘sa’
* assert! ( ! is_subsequence ( " as " , " sa " ) ) ;
* ` ` `
* /
pub fn is_subsequence ( needle : & str , string : & str ) -> bool {
2019-05-18 15:06:42 +02:00
let mut chars = string . chars ( ) ;
2019-05-18 15:16:59 +02:00
' needle : for nc in needle . chars ( ) {
for c in & mut chars {
if c = = nc {
continue 'needle ;
2019-05-18 15:06:42 +02:00
}
}
2019-05-18 15:16:59 +02:00
return false ;
2019-05-18 15:06:42 +02:00
}
true
}
#[ cfg(test) ]
mod tests {
2019-05-18 15:16:59 +02:00
use crate ::{ filter_subsequence , filter_substring } ;
2019-05-18 15:06:42 +02:00
#[ test ]
fn test_filter_substring_single ( ) {
let needle = " sdf " ;
let hay = vec! [ " asdf " , " qwer " ] ;
let expected = vec! [ " asdf " ] ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_substring_none ( ) {
let needle = " sdf " ;
let hay = vec! [ " qwertz " ] ;
let expected : Vec < & str > = Vec ::new ( ) ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_substring_multiple ( ) {
let needle = " sdf " ;
let hay = vec! [ " asdf " , " asd " , " sdfg " , " dfgh " ] ;
let expected = vec! [ " asdf " , " sdfg " ] ;
assert_eq! ( filter_substring ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_single ( ) {
let needle = " asa " ;
let hay = vec! [ " aaass " , " aasda " ] ;
let expected = vec! [ " aasda " ] ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_none ( ) {
let needle = " asa " ;
let hay = vec! [ " aas " ] ;
let expected : Vec < & str > = Vec ::new ( ) ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , expected ) ;
}
#[ test ]
fn test_filter_subsequence_multiple ( ) {
let needle = " asa " ;
let hay = vec! [ " asa " , " assa " , " qwerafwfsferfssaas " ] ;
assert_eq! ( filter_subsequence ( & needle , & hay ) , hay ) ;
}
}