chore: update Rust edition to 2024 and reformat, release 0.3.0

Author: KonradHoeffner

Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "hdt"
-version = "0.2.2"
+version = "0.3.0"
 repository = "https://github.com/konradhoeffner/hdt"
 authors = ["Tim Baccaert <tbaccaer@vub.be>", "Konrad Höffner"]
 license = "MIT"
 description = "Library for the Header Dictionary Triples (HDT) RDF compression format."
 keywords = ["rdf", "hdt", "compression", "file-format"]
 categories = ["compression", "filesystem", "parsing", "web-programming"]
-edition = "2021"
+edition = "2024"
 
 [package.metadata."docs.rs"]
 all-features = true

benches/criterion.rs

@@ -1,12 +1,12 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-use hdt::triples::*;
+use criterion::{Criterion, criterion_group, criterion_main};
 use hdt::Hdt;
 use hdt::HdtGraph;
 use hdt::IdKind;
+use hdt::triples::*;
 use sophia::api::graph::Graph;
-use sophia::api::term::matcher::Any;
 use sophia::api::term::IriRef;
 use sophia::api::term::SimpleTerm;
+use sophia::api::term::matcher::Any;
 use std::fs::File;
 
 const VINCENT: &str = "http://dbpedia.org/resource/Vincent_Descombes_Sevoie";

benches/iai.rs

@@ -1,9 +1,9 @@
 use hdt::Hdt;
 use hdt::HdtGraph;
 use sophia::api::graph::Graph;
-use sophia::api::term::matcher::Any;
 use sophia::api::term::IriRef;
 use sophia::api::term::SimpleTerm;
+use sophia::api::term::matcher::Any;
 use std::fs::File;
 
 const TYPE: &str = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";

src/containers/bitmap.rs

@@ -1,14 +1,14 @@
 //! Bitmap with rank and select support read from an HDT file.
 use crate::containers::vbyte::read_vbyte;
 use bytesize::ByteSize;
-use eyre::{eyre, Result};
+use eyre::{Result, eyre};
 #[cfg(feature = "cache")]
 use serde::ser::SerializeStruct;
 use std::fmt;
 use std::io::BufRead;
 use std::mem::size_of;
-use sucds::bit_vectors::{Access, BitVector, Rank, Rank9Sel, Select};
 use sucds::Serializable;
+use sucds::bit_vectors::{Access, BitVector, Rank, Rank9Sel, Select};
 
 /// Compact bitmap representation with rank and select support.
 #[derive(Clone)]

src/containers/control_info.rs

@@ -1,4 +1,4 @@
-use eyre::{eyre, Result};
+use eyre::{Result, eyre};
 use std::collections::HashMap;
 use std::io;
 use std::io::BufRead;

src/containers/sequence.rs

@@ -1,6 +1,6 @@
 use crate::containers::vbyte::read_vbyte;
 use bytesize::ByteSize;
-use eyre::{eyre, Result};
+use eyre::{Result, eyre};
 #[cfg(feature = "cache")]
 use serde::{self, Deserialize, Serialize};
 use std::fmt;

src/dict_sect_pfc.rs

@@ -1,17 +1,17 @@
+use crate::containers::Sequence;
 /// Dictionary section with plain front coding.
 /// See <https://www.rdfhdt.org/hdt-binary-format/#DictionarySectionPlainFrontCoding>.
 use crate::containers::vbyte::{decode_vbyte_delta, read_vbyte};
-use crate::containers::Sequence;
 use crate::triples::Id;
 use bytesize::ByteSize;
-use eyre::{eyre, Result};
+use eyre::{Result, eyre};
 use log::error;
-use std::cmp::{min, Ordering};
+use std::cmp::{Ordering, min};
 use std::fmt;
 use std::io::BufRead;
 use std::str;
 use std::sync::Arc;
-use std::thread::{spawn, JoinHandle};
+use std::thread::{JoinHandle, spawn};
 use thiserror::Error;
 
 /// Dictionary section with plain front coding.
@@ -274,9 +274,9 @@ impl DictSectPFC {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ControlInfo;
     use crate::header::Header;
     use crate::tests::init;
-    use crate::ControlInfo;
     use pretty_assertions::assert_eq;
     use std::fs::File;
     use std::io::BufReader;

src/four_sect_dict.rs

@@ -1,9 +1,9 @@
+use crate::ControlInfo;
+use crate::DictSectPFC;
 /// Four section dictionary.
 use crate::dict_sect_pfc::ExtractError;
 use crate::triples::Id;
-use crate::ControlInfo;
-use crate::DictSectPFC;
-use eyre::{eyre, Result, WrapErr};
+use eyre::{Result, WrapErr, eyre};
 use std::io;
 use std::io::{BufRead, Error, ErrorKind};
 use std::thread::JoinHandle;

src/hdt.rs

@@ -1,8 +1,8 @@
+use crate::FourSectDict;
 use crate::containers::ControlInfo;
 use crate::four_sect_dict::{DictErr, IdKind};
 use crate::header::Header;
 use crate::triples::{ObjectIter, PredicateIter, PredicateObjectIter, SubjectIter, TripleId, TriplesBitmap};
-use crate::FourSectDict;
 use bytesize::ByteSize;
 use eyre::WrapErr;
 use log::{debug, error};

src/hdt_graph.rs

@@ -5,7 +5,7 @@ use crate::hdt::Hdt;
 use crate::triples::{Id, ObjectIter, PredicateIter, PredicateObjectIter, SubjectIter, TripleId};
 use log::debug;
 use sophia::api::graph::Graph;
-use sophia::api::term::{matcher::TermMatcher, BnodeId, IriRef, LanguageTag, Term};
+use sophia::api::term::{BnodeId, IriRef, LanguageTag, Term, matcher::TermMatcher};
 use std::convert::Infallible;
 use std::io::{self, Error, ErrorKind};
 use std::iter;
@@ -114,11 +114,7 @@ fn term_string(t: &HdtTerm) -> String {
         HdtTerm::LiteralDatatype(l, dt) => {
             let xsd_string: &str = "http://www.w3.org/2001/XMLSchema#string";
             let dts = dt.as_str();
-            if dts == xsd_string {
-                format!("\"{l}\"")
-            } else {
-                format!("\"{l}\"^^<{dts}>")
-            }
+            if dts == xsd_string { format!("\"{l}\"") } else { format!("\"{l}\"^^<{dts}>") }
         }
     }
 }
@@ -258,14 +254,16 @@ mod tests {
         let triples: Vec<Result<[HdtTerm; 3], Infallible>> = graph.triples().collect();
         assert_eq!(triples.len(), 328);
         let meta_top = "http://www.snik.eu/ontology/meta/Top";
-        assert!(graph
-            .triples_matching(
-                Some(HdtTerm::Iri(IriRef::new_unchecked(Arc::from("http://www.snik.eu/ontology/meta")))),
-                Any,
-                Any
-            )
-            .next()
-            .is_some());
+        assert!(
+            graph
+                .triples_matching(
+                    Some(HdtTerm::Iri(IriRef::new_unchecked(Arc::from("http://www.snik.eu/ontology/meta")))),
+                    Any,
+                    Any
+                )
+                .next()
+                .is_some()
+        );
         for uri in [meta_top, "http://www.snik.eu/ontology/meta", "doesnotexist"] {
             let term = HdtTerm::Iri(IriRef::new_unchecked(Arc::from(uri)));
             let filtered: Vec<_> = triples

src/hdt_graph/term.rs

@@ -1,7 +1,7 @@
 //! I define [`HdtTerm`], an implementation of [`sophia::api::term::Term`].
+use sophia::api::MownStr;
 use sophia::api::ns::{rdf, xsd};
 use sophia::api::term::{BnodeId, LanguageTag, Term, TermKind};
-use sophia::api::MownStr;
 use sophia::iri::IriRef;
 use std::sync::{Arc, LazyLock};
 

src/header.rs

@@ -1,6 +1,6 @@
-use crate::containers::rdf::{Id, Literal, Term, Triple};
 use crate::containers::ControlInfo;
-use eyre::{eyre, Result, WrapErr};
+use crate::containers::rdf::{Id, Literal, Term, Triple};
+use eyre::{Result, WrapErr, eyre};
 use ntriple::parser::triple_line;
 use std::collections::BTreeSet;
 use std::io::BufRead;

src/triples.rs

@@ -1,16 +1,16 @@
-use crate::containers::{AdjList, Bitmap, Sequence};
 use crate::ControlInfo;
+use crate::containers::{AdjList, Bitmap, Sequence};
 use bytesize::ByteSize;
-use eyre::{eyre, Result, WrapErr};
+use eyre::{Result, WrapErr, eyre};
 use log::{debug, error};
 use std::cmp::Ordering;
 use std::fmt;
 use std::io::BufRead;
 use sucds::{
+    Serializable,
     bit_vectors::{BitVector, Rank9Sel},
     char_sequences::WaveletMatrix,
     int_vectors::CompactVector,
-    Serializable,
 };
 
 mod subject_iter;