refactor: improve code quality based on clippy

.github/workflows/ci.yml

@@ -61,7 +61,6 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - name: Clippy check
         uses: actions-rs/cargo@v1
-        continue-on-error: true
         with:
           command: clippy
           args: --all-targets --all-features --workspace -- -D warnings

Cargo.toml

@@ -3,17 +3,17 @@ name = "shapes-rs"
 version = "0.0.11"
 description = "RDF Data shapes implementation in Rust"
 license = "GPL-3.0-or-later"
-authors = [ 
-    "Jose Emilio Labra Gayo",
-    "Ángel Iglesias Préstamo <[email protected]>", 
+authors = [
+    "Jose Emilio Labra Gayo <[email protected]>",
+    "Ángel Iglesias Préstamo <[email protected]>",
 ]
 repository = "https://github.com/weso/shapes-rs"
 homepage = "https://www.weso.es/shapes-rs/"
 
 
 [[bin]]
 path = "sx_cli/src/main.rs"
-name = "sx"  
+name = "sx"
 
 [workspace]
 members = [
@@ -47,15 +47,16 @@ exclude = [
 # version = "0.0.6"
 edition = "2021"
 license = "MIT OR Apache-2.0"
-authors = ["Jose Emilio Labra Gayo <[email protected]>",
-    "Ángel Iglesias Préstamo <[email protected]>", 
+authors = [
+    "Jose Emilio Labra Gayo <[email protected]>",
+    "Ángel Iglesias Préstamo <[email protected]>",
 ]
 description = "RDF data shapes implementation in Rust"
-repository = "https://github.com/weso/shapes_rs"
+repository = "https://github.com/weso/shapes-rs"
 homepage = "https://www.weso.es/shapes-rs/"
 
 readme = "./README.md"
-keywords = ["rdf", "linked-data", "semantic-web", "shex"] 
+keywords = ["rdf", "linked-data", "semantic-web", "shex"]
 categories = ["rdf"]
 
 [workspace.dependencies]
@@ -89,4 +90,4 @@ oxrdf = "0.2.0-alpha.2"
 serde_json = "1.0"
 regex = "1.10.4"
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = [ "env-filter" ] }
+tracing-subscriber = { version = "0.3", features = [ "env-filter" ] }

dctap/src/dctap.rs

@@ -1,6 +1,6 @@
 use crate::{tap_config::TapConfig, tap_error::TapError};
 use serde_derive::{Deserialize, Serialize};
-use std::path::PathBuf;
+use std::path::Path;
 use tracing::debug;
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -11,14 +11,20 @@ pub struct DCTap {
     version: String,
 }
 
+impl Default for DCTap {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl DCTap {
     pub fn new() -> DCTap {
         DCTap {
             version: "0.1".to_string(),
         }
     }
 
-    pub fn read_buf(path_buf: &PathBuf, config: TapConfig) -> Result<DCTap, TapError> {
+    pub fn read_buf(_path: &Path, _config: TapConfig) -> Result<DCTap, TapError> {
         let dctap = DCTap::new();
         debug!("DCTap parsed: {:?}", dctap);
         Ok(dctap)

dctap/src/lib.rs

@@ -13,8 +13,6 @@ pub mod tap_statement;
 
 pub use crate::tap_config::*;
 pub use crate::tap_error::*;
-pub use crate::tap_error::*;
 pub use crate::tap_shape::*;
 pub use crate::tap_statement::*;
 pub use dctap::*;
-pub use dctap::*;

dctap/src/tap_config.rs

@@ -1,10 +1,4 @@
 use serde_derive::{Deserialize, Serialize};
 
-#[derive(Deserialize, Serialize, Debug, PartialEq, Clone)]
+#[derive(Deserialize, Serialize, Debug, PartialEq, Clone, Default)]
 pub struct TapConfig {}
-
-impl Default for TapConfig {
-    fn default() -> Self {
-        Self {}
-    }
-}

rbe_testsuite/Cargo.toml

@@ -18,4 +18,3 @@ tracing = "0.1"
 
 [dev-dependencies]
 indoc = "2"
-

shex_ast/src/ast/iri.rs

@@ -46,9 +46,9 @@ impl Display for Iri {
 }
 
 // This is required by serde serialization
-impl Into<String> for Iri {
-    fn into(self) -> String {
-        match self {
+impl From<Iri> for String {
+    fn from(val: Iri) -> Self {
+        match val {
             Iri::String(s) => s,
             Iri::IriS(iri_s) => iri_s.as_str().to_string(),
         }

shex_ast/src/ast/mod.rs

@@ -165,7 +165,7 @@ mod tests {
 
         let shape_expr = serde_json::from_str::<ShapeExpr>(str);
         if let Ok(v) = &shape_expr {
-            let serialized = serde_json::to_string(v).unwrap();
+            let _serialized = serde_json::to_string(v).unwrap();
         }
         assert!(shape_expr.is_ok())
     }

shex_ast/src/ast/shape_expr.rs

@@ -93,7 +93,7 @@ impl ShapeExpr {
         ShapeExpr::External
     }
 
-    pub fn not(se: ShapeExpr) -> ShapeExpr {
+    pub fn shape_not(se: ShapeExpr) -> ShapeExpr {
         ShapeExpr::ShapeNot {
             shape_expr: Box::new(ShapeExprWrapper { se }),
         }

shex_ast/src/ast/shape_expr_label.rs

@@ -108,9 +108,9 @@ impl Display for ShapeExprLabel {
     }
 }
 
-impl Into<String> for ShapeExprLabel {
-    fn into(self) -> String {
-        self.to_string()
+impl From<ShapeExprLabel> for String {
+    fn from(val: ShapeExprLabel) -> Self {
+        val.to_string()
     }
 }
 

shex_ast/src/ast/triple_expr_label.rs

@@ -53,8 +53,8 @@ impl Display for TripleExprLabel {
     }
 }
 
-impl Into<String> for TripleExprLabel {
-    fn into(self) -> String {
-        self.to_string()
+impl From<TripleExprLabel> for String {
+    fn from(val: TripleExprLabel) -> Self {
+        val.to_string()
     }
 }

shex_compact/benches/regex.rs

@@ -1,12 +1,10 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use nom_locate::LocatedSpan;
-use pprof::criterion::{Output, PProfProfiler};
-use shex_compact::ShExParser;
 use shex_compact::{hex, hex_refactor};
 
 fn regex_compare(c: &mut Criterion) {
     let mut group = c.benchmark_group("Regex compare");
-    for i in 1..1 {
+    for i in 1..2 {
         let txt = LocatedSpan::new("A");
         group.bench_with_input(BenchmarkId::new("No_regex", i), &txt, |b, txt| {
             b.iter(|| hex(*txt))

shex_compact/benches/shex_parse.rs

@@ -16,7 +16,7 @@ fn shex_parse_benchmark(c: &mut Criterion) {
     // test once to make sure it parses correctly the first time
     parse();
     // real benchmark
-    c.bench_function("shex_parse", |b| b.iter(|| parse()));
+    c.bench_function("shex_parse", |b| b.iter(parse));
 }
 
 criterion_group! {

shex_compact/src/compact_printer.rs

@@ -1,16 +1,11 @@
 use colored::*;
 use iri_s::IriS;
 use prefixmap::{IriRef, PrefixMap};
-use pretty::{Arena, DocAllocator, DocBuilder, RefDoc};
-use rust_decimal::Decimal;
+use pretty::{Arena, DocAllocator, DocBuilder};
 use shex_ast::{object_value::ObjectValue, BNode, ShapeExprLabel};
 use srdf::literal::Literal;
 use std::borrow::Cow;
 
-pub(crate) fn space<'a, A>(doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    doc.space()
-}
-
 pub(crate) fn pp_object_value<'a, A>(
     v: &ObjectValue,
     doc: &'a Arena<'a, A>,
@@ -47,22 +42,6 @@ pub(crate) fn pp_bnode<'a, A>(
     doc.text(format!("{value}"))
 }
 
-fn pp_isize<'a, A>(value: &isize, doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    doc.text(value.to_string())
-}
-
-fn pp_decimal<'a, A>(value: &Decimal, doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    doc.text(value.to_string())
-}
-
-fn pp_double<'a, A>(value: &f64, doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    doc.text(value.to_string())
-}
-
-fn pp_usize<'a, A>(value: &usize, doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    doc.text(value.to_string())
-}
-
 fn pp_iri_ref<'a, A>(
     value: &IriRef,
     doc: &'a Arena<'a, A>,
@@ -98,84 +77,10 @@ where
     }
 }
 
-fn pp_iri_unqualified<'a, A>(iri: &IriS, doc: &'a Arena<'a, A>) -> DocBuilder<'a, Arena<'a, A>, A> {
-    let str = format!("<{iri}>");
-    doc.text(str)
-}
-
 fn pp_iri<'a, A>(
     iri: &IriS,
     doc: &'a Arena<'a, A>,
     prefixmap: &PrefixMap,
 ) -> DocBuilder<'a, Arena<'a, A>, A> {
     doc.text(prefixmap.qualify(iri))
 }
-
-fn is_empty<'a, A>(d: &DocBuilder<'a, Arena<'a, A>, A>) -> bool {
-    use pretty::Doc::*;
-    match &**d {
-        Nil => true,
-        FlatAlt(t1, t2) => is_empty_ref(t1) && is_empty_ref(t2),
-        Group(t) => is_empty_ref(t),
-        Nest(_, t) => is_empty_ref(t),
-        Union(t1, t2) => is_empty_ref(t1) && is_empty_ref(t2),
-        Annotated(_, t) => is_empty_ref(t),
-        _ => false,
-    }
-}
-
-fn is_empty_ref<A>(rd: &RefDoc<'_, A>) -> bool {
-    use pretty::Doc::*;
-
-    match &**rd {
-        Nil => true,
-        FlatAlt(t1, t2) => is_empty_ref(t1) && is_empty_ref(t2),
-        Group(t) => is_empty_ref(t),
-        Nest(_, t) => is_empty_ref(t),
-        Union(t1, t2) => is_empty_ref(t1) && is_empty_ref(t2),
-        Annotated(_, t) => is_empty_ref(t),
-        _ => false,
-    }
-}
-
-pub(crate) fn enclose<'a, A>(
-    left: &'a str,
-    doc: DocBuilder<'a, Arena<'a, A>, A>,
-    right: &'a str,
-    arena: &'a Arena<'a, A>,
-    indent: isize,
-) -> DocBuilder<'a, Arena<'a, A>, A> {
-    if is_empty(&doc) {
-        arena.text(left).append(right)
-    } else {
-        arena
-            .text(left)
-            .append(arena.line_())
-            .append(doc)
-            .nest(indent)
-            .append(arena.line_())
-            .append(right)
-            .group()
-    }
-}
-
-pub(crate) fn enclose_space<'a, A>(
-    left: &'a str,
-    middle: DocBuilder<'a, Arena<'a, A>, A>,
-    right: &'a str,
-    arena: &'a Arena<'a, A>,
-    indent: isize,
-) -> DocBuilder<'a, Arena<'a, A>, A> {
-    if is_empty(&middle) {
-        arena.text(left).append(right)
-    } else {
-        arena
-            .text(left)
-            .append(arena.line())
-            .append(middle)
-            .nest(indent)
-            .append(arena.line())
-            .append(right)
-            .group()
-    }
-}