ieql 0.1.4

An open standard and implementation for monitoring Internet content
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

//! This file provides functionality related to responses.

use common::validation::{Issue, Validatable};

/// Represents a response—in other words, the parameters for
/// outputs.
///
/// This type _does not compile_ as it has 'no moving
/// parts'—it is simply information that is passed along
/// to the scanning system to guide it as it generates
/// outputs.
///
/// **This type is parallel, but _different_, from the
/// `Output` type.** You can think of a `Response` as the
/// _parameters_ for _creating_ Outputs; _not_ as the outputs
/// themselves.
#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
pub struct Response {
    /// Represents the _kind_ of the response, which corresponds
    /// to the possible types of `Output`s: `Full` and `Partial`.
    ///
    /// For more information about `Full` and `Partial` responses,
    /// see the documentation for `ResponseKind` and `Output`.
    pub kind: ResponseKind,
    /// Represents the type of information that should be included
    /// in the `Output`.
    ///
    /// For more information about response items, see the
    /// documentation for `ResponseItem` and `OutputItem`.
    pub include: Vec<ResponseItem>,
}

/// Represents the kind of output that should be produced by the
/// query.
///
/// There is one-to-one parity between this type and `output::OutputKind`.
#[derive(Copy, Clone, Serialize, Deserialize, Debug, PartialEq)]
pub enum ResponseKind {
    Full,
    Partial,
}

/// Represents an item type that should be included in the query output.
///
/// There is one-to-one parity between this type and `output::OutputItem`.
#[derive(Copy, Clone, Serialize, Deserialize, Debug, PartialEq)]
pub enum ResponseItem {
    /// Denotes the URL of the document that matched the query, if present, should be included.
    /// There is _no guarantee_ that this will be a valid url; if the mechanism
    /// by which documents are loaded provides a faulty or invalid URL (such as
    /// a local filepath, as the command line interface does when loading documents),
    /// this URL will be unchanged.
    Url,
    /// Denotes that a valid IETF MIME type, as per RFC 2045, should be included.
    Mime,
    /// Denotes that the domain (or hostname) of the `Url` should be included.
    Domain,
    /// Denotes that any number of `PatternMatch`es—in other words, excerpts—should be included.
    Excerpt,
}

impl Validatable for Response {
    /// Validates the Response and ensures that no invalid parameters 
    /// are present.
    /// 
    /// More specifically, this function ensures that `Excerpt` and `Url`,
    /// which are not reducable, are not present in `include`.
    fn validate(&self) -> Option<Vec<Issue>> {
        let mut issues: Vec<Issue> = Vec::new();
        if self.kind == ResponseKind::Partial {
            let disallowed_items = vec![ResponseItem::Excerpt, ResponseItem::Url];
            for item in &self.include {
                if disallowed_items.contains(&item) {
                    issues.push(Issue::Error(format!(
                        "include `{:?}` is not allowed in partial responses",
                        item
                    )))
                }
            }
        }
        if issues.len() == 0 {
            return None;
        } else {
            return Some(issues);
        }
    }
}