owl-structural-model 2.0.4

Typed OWL 2 structural values for Rust
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
97
98
99
100
101
102

#![doc = include_str!("../README.md")]
#![forbid(unsafe_code)]

//! Typed OWL 2 structural values without an RDF-store dependency.

mod annotation;
mod annotation_axiom;
mod assertion;
mod axiom;
mod axiom_annotations;
mod cardinality;
mod class_axiom;
mod class_boolean;
mod class_expression;
mod class_restriction;
mod data_axiom;
mod data_range;
mod entity;
mod error;
mod individual;
mod key;
mod kind;
mod ontology;
mod operand_set;
mod operands;
mod patch;
mod property_axiom;
mod property_chain;
mod property_schema;
mod vocabulary;

pub use annotation::{Annotation, AnnotationSubject, AnnotationValue, AxiomAnnotations};
pub use axiom::Axiom;
pub use cardinality::Cardinality;
pub use class_expression::{ClassExpression, ObjectPropertyExpression};
pub use data_range::{DataRange, FacetRestriction};
pub use entity::{Entity, EntityKind};
pub use error::StructuralModelError;
pub use individual::Individual;
pub use key::KeyProperties;
pub use kind::{AxiomKind, ClassExpressionKind, DataRangeKind};
pub use ontology::{OntologyId, OntologyIdentity};
pub use operand_set::{OperandSet, UnorderedPair};
pub use operands::OperandList;
pub use patch::{OntologyPatch, OntologyPatchOperation};
pub use property_chain::{ObjectPropertyChain, SubObjectPropertyExpression};
pub use rdf_structural_model::{BlankNodeId, Literal as OwlLiteral};
pub use vocabulary::{OWL_NOTHING, OWL_THING, RDFS_LITERAL};

#[cfg(test)]
mod tests {
    use iri_rfc3987::Iri;

    use super::*;
    type ClassExpression = super::ClassExpression;

    fn iri(value: &str) -> Iri<String> {
        Iri::parse(value).expect("test IRI is valid").into()
    }

    #[test]
    fn constructors_preserve_structural_shape() {
        let axiom: Axiom = Axiom::sub_class_of(
            ClassExpression::named(iri("https://example.org/Customer")),
            ClassExpression::named(iri("https://example.org/Party")),
        );

        assert!(matches!(axiom, Axiom::SubClassOf { .. }));
        assert_eq!(
            Entity::class(iri("https://example.org/Customer")).kind(),
            EntityKind::Class
        );
    }

    #[test]
    fn invalid_structural_values_fail_at_construction() {
        let error = ClassExpression::object_union_of(Vec::new()).unwrap_err();
        assert!(matches!(error, StructuralModelError::InvalidFormat { .. }));

        assert!(rdf_structural_model::LanguageTag::try_new("").is_err());
    }

    #[test]
    fn ontology_identity_rejects_version_without_name() {
        let error = OntologyId::try_new(None, Some(iri("https://example.org/v1"))).unwrap_err();
        assert!(matches!(error, StructuralModelError::InvalidFormat { .. }));
    }

    /// ```
    /// use iri_rfc3987::Iri;
    /// use owl_structural_model::{Axiom, ClassExpression};
    ///
    /// let parse = |value: &str| Iri::parse(value).expect("valid IRI").into();
    /// let axiom: Axiom = Axiom::sub_class_of(
    ///     ClassExpression::named(parse("https://example.org/Customer")),
    ///     ClassExpression::named(parse("https://example.org/Party")),
    /// );
    /// assert!(matches!(axiom, Axiom::SubClassOf { .. }));
    /// ```
    #[test]
    fn doctest_anchor() {}
}