mant-engine 0.11.0

Structured manual and Markdown document engine used by ManT
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Full requests compose independent loading and query-view validation.
use super::{
    EntryProjection, LoadPolicy, MAX_NODE_SELECTORS, MAX_SEMANTIC_ENTRY_CHARS, QueryError,
    QueryRequest, QueryValidationError, QueryView, ScopeTextError, SearchQuery,
    validate_scope_text, validate_search_query,
};

/// Validate the complete request before local I/O.
///
/// # Errors
/// Returns the originating loading or query-view validation error.
pub fn validate_query_request(
    request: &QueryRequest,
    policy: LoadPolicy,
) -> Result<(), QueryError> {
    super::validate_load_spec(super::adapter::load_spec(&request.input), policy)?;
    validate_query_view(&request.view).map_err(QueryError::QueryValidation)
}

pub(super) fn validate_query_view(view: &QueryView) -> Result<(), QueryValidationError> {
    match view {
        QueryView::Excerpt { selectors } => {
            if selectors.is_empty() {
                return Err(QueryValidationError::EmptySelection);
            }
            if selectors.len() > MAX_NODE_SELECTORS {
                return Err(QueryValidationError::TooManySelections {
                    maximum: MAX_NODE_SELECTORS,
                });
            }
            for selector in selectors {
                selector
                    .validate()
                    .map_err(|_| QueryValidationError::InvalidContentSelector)?;
            }
        }
        QueryView::Explain { entry, options } => {
            validate_scope_text(entry, MAX_SEMANTIC_ENTRY_CHARS).map_err(|error| {
                if error == ScopeTextError::Empty {
                    QueryValidationError::EmptyEntry
                } else {
                    QueryValidationError::InvalidViewSelector {
                        field: "semantic entry",
                        error,
                    }
                }
            })?;
            mant_query::validate_explanation_query(&mant_protocol::ExplanationQuery {
                entry: entry.clone(),
                options: *options,
            })
            .map_err(QueryValidationError::InvalidExplanation)?;
        }
        QueryView::Search {
            pattern,
            syntax,
            case,
            scope,
            word,
            context_lines,
            limit,
            offset,
        } => validate_search_query(&SearchQuery {
            pattern: pattern.clone(),
            syntax: *syntax,
            case: *case,
            scope: *scope,
            word: *word,
            context_lines: *context_lines,
            limit: *limit,
            offset: *offset,
        })
        .map_err(QueryValidationError::InvalidSearch)?,
        QueryView::Outline {
            entries,
            root,
            references,
        } => {
            references
                .validate()
                .map_err(QueryValidationError::InvalidReferenceProjection)?;
            if let Some(selector) = root {
                selector
                    .validate()
                    .map_err(|_| QueryValidationError::InvalidContentSelector)?;
            }
            if let EntryProjection::Kinds { kinds } = entries
                && (kinds.is_empty() || kinds.len() > 9)
            {
                return Err(QueryValidationError::InvalidEntryKinds);
            }
        }
        QueryView::Full {} => {}
    }
    Ok(())
}