Fix formatting, publish and add Travis CI

* rename to rdf library

* upate description formatting

* release 0.1.1

* syntax

* add travis configuration

* format code using cargo-fmt

* update travis build

* fix syntaxes from clippy informations

* fix clone and format

* updte rust syntax

* update syntax

* update indentation

* defines UnsignedLong type

* wrote logn type as integer value

* release 0.1.2

* update formatting

* update turtle formatter for lexical number representation

* bump to 0.1.3

* fix turtle format for bool with type

* bump to 0.1.4

* Update links

* force to install clippy

* add more tested rust versions

* format code

* fix format

* format

* minor syntax fix

Author: MarcAntoine-Arnaud

.travis.yml

@@ -0,0 +1,71 @@
+
+language: rust
+
+rust:
+  - 1.23.0
+  - 1.24.0
+  - 1.25.0
+  - 1.26.0
+  - 1.27.0
+  - 1.28.0
+  - stable
+  - beta
+  - nightly
+
+matrix:
+  allow_failures:
+    - rust: nightly
+  include:
+    # Rustfmt
+    - env: RUSTFMT_VERSION="0.4.1"
+      rust: nightly-2018-04-01
+      install:
+        - rustup component add rustfmt-preview
+        - cargo install rustfmt-nightly --force --version $RUSTFMT_VERSION || echo "rustfmt already installed"
+      before_script:
+        - cargo-fmt fmt -- --version
+      script:
+        - cargo fmt -- --write-mode=diff
+
+    # Clippy
+    - env: CLIPPY_VERSION="0.0.191"
+      rust: nightly-2018-04-01
+      install:
+      - travis_wait cargo install clippy --force --version $CLIPPY_VERSION || echo "clippy already installed"
+      script:
+        # Fail if clippy output contains "error:" or "warning:"
+        - cargo clippy 2>&1 | tee ./clippy.out && ! grep -qe  "error:\|warning:" ./clippy.out
+
+    # Test coverage (with Tarpaulin)
+    - env: TARPAULIN_VERSION="0.5.6"
+      rust: stable
+      # To avoid "Error: EPERM: operation not permitted" error (see https://github.com/valery-barysok/session-file-store/issues/58)
+      sudo: true
+      install:
+        - curl -sL https://github.com/xd009642/tarpaulin/releases/download/$TARPAULIN_VERSION/cargo-tarpaulin-$TARPAULIN_VERSION-travis.tar.gz | tar xvz -C $HOME/.cargo/bin
+      script:
+        - cargo tarpaulin --verbose > ./tarpaulin.out
+
+        # Fetch coverage percentage (integer)
+        - COVERAGE=$(cat ./tarpaulin.out | awk -F '.' '/coverage/ { print $1 }')
+        - echo COVERAGE=${COVERAGE}
+
+        # Print uncoverted lines
+        - 'echo "UNCOVERED LINES" && grep "hits: 0" ./tarpaulin.out'
+
+        # Exit 1, if coverage is less than 89%
+        - if [ $COVERAGE -lt 89 ]; then exit 0; fi
+
+cache:
+  cargo: true
+before_cache:
+  # Travis can't cache files that are not readable by "others"
+  - chmod -R a+r $HOME/.cargo
+
+script:
+  - cargo test
+
+addons:
+  apt:
+    packages:
+      - libssl-dev  # Required for tarpaulin

Cargo.toml

@@ -1,6 +1,12 @@
 [package]
-name = "rdf-rs"
-version = "0.1.0"
-authors = ["Anna Scholtz <[email protected]>"]
+name = "rdf"
+version = "0.1.4"
+authors = ["Anna Scholtz <[email protected]>", "Marc-Antoine Arnaud <[email protected]>"]
+description = """
+rdf is a library for the Resource Description Framework (RDF) and SPARQL implemented in Rust.
+"""
+license = "MIT"
+repository = "https://github.com/scholtzan/rdf-rs"
+documentation = "https://docs.rs/rdf"
 
 [dependencies]

README.md

@@ -2,33 +2,20 @@
 
 > Note: This project is work in progress and currently not stable.
 
-`rdf-rs` is a library for the [Resource Description Framework](https://www.w3.org/RDF/) (RDF) and [SPARQL](https://www.w3.org/TR/rdf-sparql-query/) implemented in Rust.
+`rdf` is a library for the [Resource Description Framework](https://www.w3.org/RDF/) (RDF) and [SPARQL](https://www.w3.org/TR/rdf-sparql-query/) implemented in Rust.
 
 This project is a way for me to learn Rust and combine it with my interests in semantic web technologies.
 
-## Usage
-
-A comprehensive documentation of the API is available [**here**](https://scholtzan.github.io/rdf-rs/doc/rdf_rs/index.html).
-
-### Installation
-
-To use `rdf-rs`, add this to `Cargo.toml`:
-
-```toml
-[dependencies.rdf-rs]
-git = "https://github.com/scholtzan/rdf-rs"
-```
-
 
 ### Basic Examples
 
 
 RDF triples can be stored and represented in a graph.
 
 ```rust
-use rdf_rs::graph::Graph;
-use rdf_rs::uri::Uri;
-use rdf_rs::triple::Triple;
+use rdf::graph::Graph;
+use rdf::uri::Uri;
+use rdf::triple::Triple;
 
 let mut graph = Graph::new(None);
 let subject = graph.create_blank_node();
@@ -42,11 +29,11 @@ graph.add_triple(&triple);
 RDF graphs can be serialized to a supported format.
 
 ```rust
-use rdf_rs::writer::n_triples_writer::NTriplesWriter;
-use rdf_rs::writer::rdf_writer::RdfWriter;
-use rdf_rs::graph::Graph;
-use rdf_rs::uri::Uri;
-use rdf_rs::triple::Triple;
+use rdf::writer::n_triples_writer::NTriplesWriter;
+use rdf::writer::rdf_writer::RdfWriter;
+use rdf::graph::Graph;
+use rdf::uri::Uri;
+use rdf::triple::Triple;
 
 let writer = NTriplesWriter::new();
 
@@ -64,9 +51,9 @@ assert_eq!(writer.write_to_string(&graph).unwrap(),
 RDF syntax can also be parsed and transformed into an RDF graph.
 
 ```rust
-use rdf_rs::reader::turtle_parser::TurtleParser;
-use rdf_rs::reader::rdf_parser::RdfParser;
-use rdf_rs::uri::Uri;
+use rdf::reader::turtle_parser::TurtleParser;
+use rdf::reader::rdf_parser::RdfParser;
+use rdf::uri::Uri;
 
 let input = "@base <http://example.org/> .
 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

src/error.rs

@@ -1,64 +1,62 @@
-use std::fmt;
-use std::error::Error as StdError;
 use reader::input_reader::InputChars;
+use std::error::Error as StdError;
+use std::fmt;
 
 /// Different types of errors that can occur.
 #[derive(Debug)]
 pub enum ErrorType {
-  /// RDF writer produces invalid RDF (e.g. if invalid node types are provided).
-  InvalidWriterOutput,
+    /// RDF writer produces invalid RDF (e.g. if invalid node types are provided).
+    InvalidWriterOutput,
 
-  /// RDF lexer reads invalid RDF (e.g. non-closing string).
-  InvalidReaderInput,
+    /// RDF lexer reads invalid RDF (e.g. non-closing string).
+    InvalidReaderInput,
 
-  /// RDF reader reads an invalid token (e.g. invalid node type).
-  InvalidToken,
+    /// RDF reader reads an invalid token (e.g. invalid node type).
+    InvalidToken,
 
-  /// RDF reader reaches the end of the input and stores the characters that were read last.
-  EndOfInput(InputChars),
+    /// RDF reader reaches the end of the input and stores the characters that were read last.
+    EndOfInput(InputChars),
 
-  /// Input reader encounters invalid byte encoding.
-  InvalidByteEncoding,
+    /// Input reader encounters invalid byte encoding.
+    InvalidByteEncoding,
 
-  /// Incorrect namespace.
-  InvalidNamespace
+    /// Incorrect namespace.
+    InvalidNamespace,
 }
 
-
 /// An error related to the rdf-rs module.
 #[derive(Debug)]
 pub struct Error {
-  error_type: ErrorType,
-  error: Box<StdError>
+    error_type: ErrorType,
+    error: Box<StdError>,
 }
 
-
 impl Error {
-  /// Constructor of `Error`.
-  pub fn new<E>(error_type: ErrorType, error: E) -> Error
-    where E: Into<Box<StdError>> {
-    Error {
-      error_type: error_type,
-      error: error.into()
+    /// Constructor of `Error`.
+    pub fn new<E>(error_type: ErrorType, error: E) -> Error
+    where
+        E: Into<Box<StdError>>,
+    {
+        Error {
+            error_type,
+            error: error.into(),
+        }
     }
-  }
 
-  /// Returns the type of the error.
-  pub fn error_type(&self) -> &ErrorType {
-    &self.error_type
-  }
+    /// Returns the type of the error.
+    pub fn error_type(&self) -> &ErrorType {
+        &self.error_type
+    }
 }
 
-
 impl fmt::Display for Error {
-  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    self.error.fmt(f)
-  }
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.error.fmt(f)
+    }
 }
 
-
 impl StdError for Error {
-  fn description(&self) -> &str {
-    self.error.description()
-  }
-}
+    fn description(&self) -> &str {
+        self.error.description()
+    }
+}