horned-functional 
horned-functional An OWL2 Functional-style Syntax parser for horned-owl.
This library provides extensions to the horned-owl
crate to work with the OWL Functional-Style syntax.
It provides a parser written with pest and a serializer.
Add the latest versions of horned-owl and horned-functional to the
[dependencies] sections of your Cargo.toml manifest:
toml
[dependencies]
horned-owl = "0.10.0"
horned-functional = "0.3.1"
To easily read an entire OWL document, including prefixes, use the
horned_functional::to_string function:
rust
let s = std::fs::read_to_string("tests/data/ms.obo.ofn")
.expect("failed to read OWL file");
let (ontology, prefixes) = horned_functional::from_str(&s)
.expect("failed to parse OWL file");
All OWL elements can be parsed from functional syntax as well, using the
FromFunctional trait to read a from a serialized string with the from_ofn
method:
```rust use hornedowl::model::Axiom; use hornedfunctional::FromFunctional;
let axiom = Axiom::from_ofn("Declaration(Class(http://purl.obolibrary.org/obo/MS_1000031))") .expect("failed to parse axiom"); ```
If the serialized version contains abbreviated IRIs, you can pass a custom
prefix mapping to the from_ofn_ctx method:
```rust use hornedowl::model::Axiom; use hornedfunctional::FromFunctional;
let mut mapping = curie::PrefixMapping::default(); mapping.add_prefix("obo", "http://purl.obolibrary.org/obo/").ok();
let ctx = hornedfunctional::Context::from(&mapping); let axiom = Axiom::fromofnctx("Declaration(Class(obo:MS1000031))", &ctx) .expect("failed to parse axiom"); ```
To easily serialize an entire OWL document, including prefixes, use the
horned_functional::to_string function:
```rust let mut file = std::fs::File::open("tests/data/ms.owx") .map(std::io::BufReader::new) .expect("failed to open OWL file"); let (ontology, prefixes) = horned_owl::io::owx::reader::read(&mut file) .expect("failed to read OWL file");
// serialize using the same prefixes as the input OWL/XML file let ofn = hornedfunctional::tostring(ontology.iter(), &prefixes);
// serialize without abbreviated IRIs let ofn = hornedfunctional::tostring(ontology.iter(), None); ```
All OWL elements can be displayed in functional syntax as well, using
a custom Display implementation, allowing the functional syntax in
format!,
println! or
write! macros.
Just add the AsFunctional trait to the scope, and use the as_ofn method
to get a displayable type for any supported element:
```rust use hornedowl::model::*; use hornedfunctional::AsFunctional;
let build = Build::new();
// build a Declaration(ObjectProperty(http://purl.obolibrary.org/obo/RO_0002175)) let op = build.objectproperty("http://purl.obolibrary.org/obo/RO0002175"); let axiom = Axiom::from(DeclareObjectProperty(op));
println!("Axiom: {}", axiom.as_ofn()); ```
Found a bug ? Have an enhancement request ? Head over to the GitHub issue tracker of the project if you need to report or ask something. If you are filling in on a bug, please include as much information as you can about the issue, and try to recreate the same bug in a simple, easily reproducible situation.
This project adheres to Semantic Versioning and provides a changelog in the Keep a Changelog format.
This library is provided under the open-source MIT license.
This project was developed by Martin Larralde as part of a Master's Degree internship in the BBOP team of the Lawrence Berkeley National Laboratory, under the supervision of Chris Mungall. Cite this project as:
Larralde M. Developing Python and Rust libraries to improve the ontology ecosystem [version 1; not peer reviewed]. F1000Research 2019, 8(ISCB Comm J):1500 (poster) (https://doi.org/10.7490/f1000research.1117405.1)
