allow slop in both directions (#2020)

* allow slop in both directions

allow slop in both directions
so "big wolf"~3 can also match "wolf big"

This also fixes #1934, when the docsets were reordered by size and didn't
match the terms.

* remove count

* add test for repeating tokens, unduplicate tests

Author: PSeitz

src/query/phrase_query/mod.rs

@@ -160,22 +160,7 @@ pub mod tests {
     #[test]
     pub fn test_phrase_score() -> crate::Result<()> {
         let index = create_index(&["a b c", "a b c a b"])?;
-        let schema = index.schema();
-        let text_field = schema.get_field("text").unwrap();
-        let searcher = index.reader()?.searcher();
-        let test_query = |texts: Vec<&str>| {
-            let terms: Vec<Term> = texts
-                .iter()
-                .map(|text| Term::from_field_text(text_field, text))
-                .collect();
-            let phrase_query = PhraseQuery::new(terms);
-            searcher
-                .search(&phrase_query, &TEST_COLLECTOR_WITH_SCORE)
-                .expect("search should succeed")
-                .scores()
-                .to_vec()
-        };
-        let scores = test_query(vec!["a", "b"]);
+        let scores = test_query(0, &index, vec!["a", "b"]);
         assert_nearly_equals!(scores[0], 0.40618482);
         assert_nearly_equals!(scores[1], 0.46844664);
         Ok(())
@@ -185,48 +170,48 @@ pub mod tests {
     #[test]
     pub fn test_phrase_score_with_slop() -> crate::Result<()> {
         let index = create_index(&["a c b", "a b c a b"])?;
-        let schema = index.schema();
-        let text_field = schema.get_field("text").unwrap();
-        let searcher = index.reader().unwrap().searcher();
-        let test_query = |texts: Vec<&str>| {
-            let terms: Vec<Term> = texts
-                .iter()
-                .map(|text| Term::from_field_text(text_field, text))
-                .collect();
-            let mut phrase_query = PhraseQuery::new(terms);
-            phrase_query.set_slop(1);
-            searcher
-                .search(&phrase_query, &TEST_COLLECTOR_WITH_SCORE)
-                .expect("search should succeed")
-                .scores()
-                .to_vec()
-        };
-        let scores = test_query(vec!["a", "b"]);
+        let scores = test_query(1, &index, vec!["a", "b"]);
         assert_nearly_equals!(scores[0], 0.40618482);
         assert_nearly_equals!(scores[1], 0.46844664);
         Ok(())
     }
 
+    #[test]
+    pub fn test_phrase_score_with_slop_bug() -> crate::Result<()> {
+        let index = create_index(&["asdf asdf Captain Subject Wendy", "Captain"])?;
+        let scores = test_query(1, &index, vec!["captain", "wendy"]);
+        assert_eq!(scores.len(), 1);
+        Ok(())
+    }
+
+    fn test_query(slop: u32, index: &Index, texts: Vec<&str>) -> Vec<f32> {
+        let text_field = index.schema().get_field("text").unwrap();
+        let searcher = index.reader().unwrap().searcher();
+        let terms: Vec<Term> = texts
+            .iter()
+            .map(|text| Term::from_field_text(text_field, text))
+            .collect();
+        let mut phrase_query = PhraseQuery::new(terms);
+        phrase_query.set_slop(slop);
+        searcher
+            .search(&phrase_query, &TEST_COLLECTOR_WITH_SCORE)
+            .expect("search should succeed")
+            .scores()
+            .to_vec()
+    }
+
+    #[test]
+    pub fn test_phrase_score_with_slop_repeating() -> crate::Result<()> {
+        let index = create_index(&["wendy subject subject captain", "Captain"])?;
+        let scores = test_query(1, &index, vec!["wendy", "subject", "captain"]);
+        assert_eq!(scores.len(), 1);
+        Ok(())
+    }
+
     #[test]
     pub fn test_phrase_score_with_slop_size() -> crate::Result<()> {
         let index = create_index(&["a b e c", "a e e e c", "a e e e e c"])?;
-        let schema = index.schema();
-        let text_field = schema.get_field("text").unwrap();
-        let searcher = index.reader().unwrap().searcher();
-        let test_query = |texts: Vec<&str>| {
-            let terms: Vec<Term> = texts
-                .iter()
-                .map(|text| Term::from_field_text(text_field, text))
-                .collect();
-            let mut phrase_query = PhraseQuery::new(terms);
-            phrase_query.set_slop(3);
-            searcher
-                .search(&phrase_query, &TEST_COLLECTOR_WITH_SCORE)
-                .expect("search should succeed")
-                .scores()
-                .to_vec()
-        };
-        let scores = test_query(vec!["a", "c"]);
+        let scores = test_query(3, &index, vec!["a", "c"]);
         assert_nearly_equals!(scores[0], 0.29086056);
         assert_nearly_equals!(scores[1], 0.26706287);
         Ok(())
@@ -237,31 +222,16 @@ pub mod tests {
         let index = create_index(&[
             "a e b e c",
             "a e e e e e b e e e e c",
-            "a c b",
+            "a c b", // also matches
             "a c e b e",
             "a e c b",
             "a e b c",
         ])?;
-        let schema = index.schema();
-        let text_field = schema.get_field("text").unwrap();
-        let searcher = index.reader().unwrap().searcher();
-        let test_query = |texts: Vec<&str>| {
-            let terms: Vec<Term> = texts
-                .iter()
-                .map(|text| Term::from_field_text(text_field, text))
-                .collect();
-            let mut phrase_query = PhraseQuery::new(terms);
-            phrase_query.set_slop(3);
-            searcher
-                .search(&phrase_query, &TEST_COLLECTOR_WITH_SCORE)
-                .expect("search should succeed")
-                .scores()
-                .to_vec()
-        };
-        let scores = test_query(vec!["a", "b", "c"]);
+        let scores = test_query(3, &index, vec!["a", "b", "c"]);
         // The first and last matches.
         assert_nearly_equals!(scores[0], 0.23091172);
-        assert_nearly_equals!(scores[1], 0.25024384);
+        assert_nearly_equals!(scores[1], 0.27310878);
+        assert_nearly_equals!(scores[3], 0.25024384);
         Ok(())
     }