Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://rudof-project.github.io/rudof/

RDF data shapes implementation in Rust
https://rudof-project.github.io/rudof/

Last synced: 3 months ago
JSON representation

RDF data shapes implementation in Rust

Awesome Lists containing this project

README 

        
# rudof



[![Latest Version](https://img.shields.io/crates/v/rudof-cli.svg)](https://crates.io/crates/rudof-cli)

[![PyPI](https://img.shields.io/pypi/v/pyrudof)](https://pypi.org/project/pyrudof/)

[![rudof](https://github.com/rudof-project/rudof/actions/workflows/ci.yml/badge.svg)](https://github.com/rudof-project/rudof/actions/workflows/ci.yml)

[![dependency status](https://deps.rs/repo/github/rudof-project/rudof/status.svg)](https://deps.rs/repo/github/rudof-project/rudof)



This repo contains an RDF data shapes library implemented in Rust.

The implementation supports [ShEx](http://shex.io/), [SHACL](https://www.w3.org/TR/shacl/), [DCTap](https://www.dublincore.org/specifications/dctap/) and conversions between different RDF data modeling formalisms.



The code can be used as a Rust library but it also contains a binary called `rudof` which can be used as an RDF playground.



We provide binaries for Linux, Windows, Mac and Docker (see [releases](https://github.com/rudof-project/rudof/releases)), as well as Python bindings.



- [Installation](https://github.com/rudof-project/rudof?tab=readme-ov-file#installation)

- [List of issues](https://github.com/rudof-project/rudof)

- [Discussion](https://github.com/rudof-project/rudof/discussions)

- [FAQ](https://github.com/rudof-project/rudof/wiki/FAQ)

- [How to guides](https://github.com/rudof-project/rudof/wiki/How%E2%80%90to-guides)

- [Roadmap](https://github.com/rudof-project/rudof/issues/1)



## Installation



### Official releases



You can download a binary from the [latest release](https://github.com/rudof-project/rudof/releases/latest) page. There you will also find the compiled packages for the installation on your system using a package manager.



#### Ubuntu



Download the binary from [https://github.com/rudof-project/rudof/releases] and install the `.deb` package running the following commands after replacing X.X.X by the latest version:



```sh

wget https://github.com/rudof-project/rudof/releases/download/vX.X.X/rudof_vX.X.X_amd64.deb

sudo dpkg -i rudof_vX.X.X_amd64.deb

```



#### Windows



The binary can be downloaded from [https://github.com/rudof-project/rudof/releases]



#### Mac



The binary is available at: [https://github.com/rudof-project/rudof/releases] so you can download the corresponding binary to your machine.



The usual way to run/install a binary in Mac is to download it in a folder, add that folder to your PATH and activating the binary using:



```sh

chmod +x 

```



After that, the processor may complain the first time about security and you have to agree to use it. Once you agree, it should work.



Compiling from source



### Compiling from source



`rudof` has been implemented in Rust and is compiled using [cargo](https://doc.rust-lang.org/cargo/). The command `cargo run` can be used to compile and run locally the code.



For example:



```sh

cargo run -- validate --data examples/user.ttl --schema examples/user.shex --shapemap examples/user.sm 

```



### Compiling from source and installing the binary (Debian)



Install `cargo deb` (only the first time)



```sh

cargo install cargo-deb

```



Create the `.deb` package by:



```sh

cargo deb

```



And run:



```sh

sudo dpkg -i target/debian/rudof_0.0.11-1_amd64.deb

```



## Docker



The library is also published as a Docker image.



## Usage



### Some examples



The folder `examples` contains several example files with ShEx schemas and RDF data.



### Validate a simple RDF file with a ShEx schema using a ShapeMap



```sh

rudof validate --data examples/user.ttl --schema examples/user.shex --shapemap examples/user.sm

```



We maintain a Wiki page with some common [Usage scenarios and How-to guides](https://github.com/rudof-project/rudof/wiki/Howto-guides).



### Debugging information



It is possible to change the debug level information with:



```sh

export RUST_LOG=value

```



where `value` can be `debug` to show more verbose information or `info` to show basic information.



## Command line usage



```sh

RDF Data shapes implementation in Rust



Usage: rudof [OPTIONS] [COMMAND]



Commands:

  shapemap        Information about ShEx shapemaps

  shex            Information about ShEx schemas

  validate        RDF Validation using ShEx or SHACL

  shex-validate   RDF Validation using ShEx schemas

  shacl-validate  RDF Validation using SHACL shapes

  data            Information about RDF data

  node            Information about RDF nodes which are part of RDF Graphs

  shacl           Information about SHACL shapes

  dctap           Information and processing of DCTAP files

  convert         Conversion between different Data modeling technologies

  help            Print this message or the help of the given subcommand(s)



Options:

  -d, --debug...  

  -h, --help      Print help (see more with '--help')

  -V, --version   Print version

```



### Obtaining information about a ShEx schema



```sh

$ rudof shex --help

Information about ShEx schemas



Usage: rudof shex [OPTIONS] --schema 



Options:

  -s, --schema 

          

  -f, --format 

          [default: shexc] [possible values: internal, shexc, shexj, turtle, ntriples, rdfxml, trig, n3, nquads]

  -r, --result-format 

          [default: shexj] [possible values: internal, shexc, shexj, turtle, ntriples, rdfxml, trig, n3, nquads]

  -t, --show elapsed time

          

      --statistics

          

  -o, --output-file 

          

  -h, --help

          Print help

```



### Obtaining information about RDF data



```sh

$ rudof data --help

Information about RDF data



Usage: rudof data [OPTIONS] --data 



Options:

  -d, --data 

          

  -t, --data-format 

          [default: turtle] [possible values: turtle, ntriples, rdfxml, trig, n3, nquads]

  -o, --output-file 

          

  -h, --help

          Print help

```



### Obtaining information about a node in RDF data



This command can be useful to obtain the neighbourhood of a node.



```sh

$ rudof node --help

Information about RDF nodes which are part of RDF Graphs



Usage: rudof node [OPTIONS] --node 



Options:

  -n, --node 

          

  -d, --data 

          

  -t, --data-format 

          [default: turtle] [possible values: turtle, ntriples, rdfxml, trig, n3, nquads]

  -e, --endpoint 

          

  -m, --show-node-mode 

          [default: outgoing] [possible values: outgoing, incoming, both]

      --show hyperlinks

          

  -p, --predicates 

          

  -o, --output-file 

          

  -h, --help

          Print help

```



For example, the following command shows the neighbourhood of node `wd:Q80` in the Wikidata endpoint.



```sh

rudof node -e wikidata -n wd:Q80

```



### Validating an RDF node against some data



```sh

$ rudof validate --help

RDF Validation using ShEx or SHACL



Usage: rudof validate [OPTIONS] --schema 



Options:

  -M, --mode 

          [default: shex] [possible values: shex, shacl]

  -s, --schema 

          

  -f, --schema-format 

          [default: shexc] [possible values: internal, shexc, shexj, turtle, ntriples, rdfxml, trig, n3, nquads]

  -m, --shapemap 

          

      --shapemap-format 

          [default: compact] [possible values: compact, internal]

  -n, --node 

          

  -l, --shape-label 

          

  -d, --data 

          

  -t, --data-format 

          [default: turtle] [possible values: turtle, ntriples, rdfxml, trig, n3, nquads]

  -e, --endpoint 

          

      --max-steps 

          [default: 100]

  -o, --output-file 

          

  -h, --help

          Print help

```



Example: Assuming there a ShEx file in `examples/user.shex` and an RDF turtle file in `examples/user.ttl` we can ask to validate node `:a` with shape label `:User` using:



```sh

rudof validate -s examples/user.shex -d examples/user.ttl -n :a -l :User

```



If there is a shapemap in `examples/user.sm`, we can validate using:



```sh

rudof validate -s examples/user.shex -d examples/user.ttl -m examples/user.sm

```



### Validating an RDF node against some SHACL Shape



```sh

rudof shacl-validate --shapes examples/simple_shacl.ttl examples/simple.ttl

```



### Conversion between shapes formalisms



```sh

$ rudof convert --help

Conversion between different Data modeling technologies



Usage: rudof convert [OPTIONS] --input-mode  --source-file  --export-mode 



Options:

  -m, --input-mode 

          [possible values: shex, dctap]

  -s, --source-file 

          

  -f, --format 

          [default: shexc] [possible values: csv, shexc, shexj, turtle]

  -r, --result-format 

          [default: default] [possible values: default, internal, json, shexc, shexj, turtle, plantuml, html, svg, png]

  -o, --output-file 

          

  -t, --target-folder 

          

  -l, --shape-label 

          

  -x, --export-mode 

          [possible values: sparql, shex, uml, html]

  -h, --help

          Print help

```



## Main modules



The repo is divided in the following modules:



- [iri_s](https://github.com/rudof-project/rudof/tree/master/iri_s) defines simple IRIs.

- [srdf](https://github.com/rudof-project/rudof/tree/master/srdf) simple RDF model which will be used for validation.

- [prefixmap](https://github.com/rudof-project/rudof/tree/master/prefixmap) Prefix maps implementation.

- [shapemap](https://github.com/rudof-project/rudof/tree/master/shapemap) ShapeMap implementation.

- [shex_ast](https://github.com/rudof-project/rudof/tree/master/shex_ast) defines the ShEx Abstract syntax

- [shex_compact](https://github.com/rudof-project/rudof/tree/master/shex_compact) contains the code required to handle ShEx compact syntax.

- [shex_validation](https://github.com/rudof-project/rudof/tree/master/shex_validation) contains the code required to validate RDF using ShEx.

- [shex_testsuite](https://github.com/rudof-project/rudof/tree/master/shex_testsuite) contains the code required to run the ShEx testsuite.

- [shacl_ast](https://github.com/rudof-project/rudof/tree/master/shacl_ast) defines the SHACL core Abstract syntax.

- [shacl_validation](https://github.com/rudof-project/rudof/tree/master/shacl_validation) contains the code required to validate RDF using SHACL.

- [dctap](https://github.com/rudof-project/rudof/tree/master/dctap) contains the code required to do handle DCTAP files.

- [shapes_converter](https://github.com/rudof-project/rudof/tree/master/shapes_converter) contains the code required to do conversion between different shapes formalisms.



## Publishing the crates



```sh

cargo workspaces publish 

```



## Worskpaces



The project is using cargo workspaces wihch can be installed with:



```sh

cargo install cargo-workspaces

```



## Unit-testing



In order to test all the sub-projects



```sh

cargo test --all

```



Testing one specific subproject:



```sh

cargo test -p shex_validation

```



## Using the ShEx test-suite



The ShEx testsuite is included in a git submodule. In order to obtain it, it is necessary to do:



```sh

git submodule update --init --recursive

cargo run -p shex_testsuite

```



```sh

Usage: shex_testsuite [OPTIONS]



Options:

  -m, --manifest 

          Name of Manifest file [default: shex_testsuite/shexTest/validation/manifest.jsonld]

  -c, --config 

          [default: shex_testsuite/config.yml]

  -x, --run_mode 

          [default: collect-errors] [possible values: collect-errors, fail-first-error]

  -f, --manifest_mode 

          [possible values: schemas, validation, negative-syntax, negative-structure]

  -p, --print_result_mode 

          [default: basic] [possible values: basic, failed, passed, not-implemented, all]

  -e, --entry 

          

  -t, --trait 

          

  -h, --help

          Print help

  -V, --version

          Print version

```



### Validation conformance tests for ShEx



```sh

cargo run -p shex_testsuite -- -m shex_testsuite/shexTest/validation/manifest.jsonld validation 

```



### Schemas tests



```sh

cargo run -p shex_testsuite -- -m shex_testsuite/shexTest/schemas/manifest.jsonld -f schemas -p failed

```



## License



Licensed under either of



- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or )

- MIT license ([LICENSE-MIT](LICENSE-MIT) or )



at your option.



## Contributors



### Contribution



Unless you explicitly state otherwise,

any contribution intentionally submitted

for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any

additional terms or conditions.