summa-core 0.22.6

Summa Core library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use summa_proto::proto;
use tantivy::query::{DisjunctionMaxQuery, Query, TermQuery};
use tantivy::schema::{Field, FieldType, IndexRecordOption};

mod english;
mod manager;

pub use manager::MorphologyManager;

use crate::components::query_parser::utils::cast_field_to_term;

pub trait Morphology: MorphologyClone + Send + Sync {
    fn derive_tenses(&self, word: &str) -> Option<String>;
    fn derive_spelling(&self, word: &str) -> Option<String>;

    fn derive_query(&self, config: proto::MorphologyConfig, field: &Field, full_path: &str, field_type: &FieldType, text: &str) -> Box<dyn Query> {
        let derive_tenses_coefficient = if let Some(derive_tenses_coefficient) = config.derive_tenses_coefficient {
            derive_tenses_coefficient
        } else {
            let term = cast_field_to_term(field, full_path, field_type, text, false);
            return Box::new(TermQuery::new(term, IndexRecordOption::WithFreqs)) as Box<dyn Query>;
        };
        let mut terms = vec![text.to_string()];
        if let Some(other_tense_text) = self.derive_tenses(text) {
            terms.push(other_tense_text);
        }
        let corrected_spellings: Vec<_> = terms.iter().filter_map(|t| self.derive_spelling(t)).collect();
        terms.extend(corrected_spellings);
        if terms.len() == 1 {
            Box::new(TermQuery::new(
                cast_field_to_term(field, full_path, field_type, &terms[0], false),
                IndexRecordOption::WithFreqs,
            )) as Box<dyn Query>
        } else {
            let queries = terms
                .into_iter()
                .map(|text| {
                    Box::new(TermQuery::new(
                        cast_field_to_term(field, full_path, field_type, &text, false),
                        IndexRecordOption::WithFreqs,
                    )) as Box<dyn Query>
                })
                .collect();
            let disjunction_query = DisjunctionMaxQuery::with_tie_breaker(queries, derive_tenses_coefficient);
            Box::new(disjunction_query) as Box<dyn Query>
        }
    }
    fn detect_ners(&self, phrase: &str) -> Vec<String>;
}

pub trait MorphologyClone {
    fn clone_box(&self) -> Box<dyn Morphology>;
}

impl<T> MorphologyClone for T
where
    T: 'static + Morphology + Clone,
{
    fn clone_box(&self) -> Box<dyn Morphology> {
        Box::new(self.clone())
    }
}

// We can now implement Clone manually by forwarding to clone_box.
impl Clone for Box<dyn Morphology> {
    fn clone(&self) -> Box<dyn Morphology> {
        self.clone_box()
    }
}