Fixes some new clippy warnings

js/src/model.rs

@@ -34,16 +34,16 @@ pub fn literal(
     language_or_datatype: &JsValue,
 ) -> Result<JsLiteral, JsValue> {
     if language_or_datatype.is_null() || language_or_datatype.is_undefined() {
-        Ok(Literal::new_simple_literal(value.unwrap_or_else(String::new)).into())
+        Ok(Literal::new_simple_literal(value.unwrap_or_default()).into())
     } else if language_or_datatype.is_string() {
         Ok(Literal::new_language_tagged_literal(
-            value.unwrap_or_else(String::new),
+            value.unwrap_or_default(),
-            language_or_datatype.as_string().unwrap_or_else(String::new),
+            language_or_datatype.as_string().unwrap_or_default(),
         )
         .map_err(to_err)?
         .into())
     } else if let JsTerm::NamedNode(datatype) = FROM_JS.with(|c| c.to_term(language_or_datatype))? {
-        Ok(Literal::new_typed_literal(value.unwrap_or_else(String::new), datatype).into())
+        Ok(Literal::new_typed_literal(value.unwrap_or_default(), datatype).into())
     } else {
         Err(format_err!("The literal datatype should be a NamedNode"))
     }

lib/oxrdf/src/dataset.rs

@@ -725,7 +725,7 @@ impl Dataset {
                         b
                     })
                 })
-                .unwrap_or_else(Vec::new)
+                .unwrap_or_default()
         } else {
             self.label(hash)
         }

lib/oxrdf/src/parser.rs

@@ -160,7 +160,7 @@ fn read_blank_node(s: &str) -> Result<(BlankNode, &str), TermParseError> {
     if let Some(remain) = s.strip_prefix("_:") {
         let end = remain
             .find(|v: char| v.is_whitespace() || matches!(v, '<' | '_' | '?' | '$' | '"' | '\''))
-            .unwrap_or_else(|| remain.len());
+            .unwrap_or(remain.len());
         let (value, remain) = remain.split_at(end);
         let term = BlankNode::new(value).map_err(|error| TermParseError {
             kind: TermParseErrorKind::BlankNode {
@@ -188,7 +188,7 @@ fn read_literal(s: &str) -> Result<(Literal, &str), TermParseError> {
                     return if let Some(remain) = remain.strip_prefix('@') {
                         let end = remain
                             .find(|v| !matches!(v, 'a'..='z' | 'A'..='Z' | '-'))
-                            .unwrap_or_else(|| remain.len());
+                            .unwrap_or(remain.len());
                         let (language, remain) = remain.split_at(end);
                         Ok((
                             Literal::new_language_tagged_literal(value, language).map_err(

lib/spargebra/src/parser.rs

@@ -1205,8 +1205,8 @@ parser! {
         //[41]
         rule Modify() -> Vec<GraphUpdateOperation> = with:Modify_with()? _ Modify_clear() c:Modify_clauses() _ u:(UsingClause() ** (_)) _ i("WHERE") _ pattern:GroupGraphPattern() {
             let (delete, insert) = c;
-            let mut delete = delete.unwrap_or_else(Vec::new);
+            let mut delete = delete.unwrap_or_default();
-            let mut insert = insert.unwrap_or_else(Vec::new);
+            let mut insert = insert.unwrap_or_default();
             let mut pattern = pattern;
 
             let mut using = if u.is_empty() {
@@ -1325,7 +1325,7 @@ parser! {
 
         //[51]
         rule QuadsNotTriples() -> Vec<QuadPattern> = i("GRAPH") _ g:VarOrIri() _ "{" _ t:TriplesTemplate()? _ "}" {
-            t.unwrap_or_else(Vec::new).into_iter().map(|t| QuadPattern::new(t.subject, t.predicate, t.object, g.clone())).collect()
+            t.unwrap_or_default().into_iter().map(|t| QuadPattern::new(t.subject, t.predicate, t.object, g.clone())).collect()
         }
 
         //[52]

lib/src/sparql/mod.rs

@@ -119,6 +119,7 @@ pub struct QueryOptions {
 impl QueryOptions {
     /// Use a given [`ServiceHandler`] to execute [SPARQL 1.1 Federated Query](https://www.w3.org/TR/sparql11-federated-query/) SERVICE calls.
     #[inline]
+    #[must_use]
     pub fn with_service_handler(mut self, service_handler: impl ServiceHandler + 'static) -> Self {
         self.service_handler = Some(Rc::new(ErrorConversionServiceHandler::wrap(
             service_handler,
@@ -128,6 +129,7 @@ impl QueryOptions {
 
     /// Disables the `SERVICE` calls
     #[inline]
+    #[must_use]
     pub fn without_service_handler(mut self) -> Self {
         self.service_handler = Some(Rc::new(EmptyServiceHandler));
         self
@@ -135,6 +137,7 @@ impl QueryOptions {
 
     /// Sets a timeout for HTTP requests done during SPARQL evaluation
     #[cfg(feature = "http_client")]
+    #[must_use]
     pub fn with_http_timeout(mut self, timeout: Duration) -> Self {
         self.http_timeout = Some(timeout);
         self
@@ -162,6 +165,7 @@ impl QueryOptions {
     /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
     /// ```
     #[inline]
+    #[must_use]
     pub fn with_custom_function(
         mut self,
         name: NamedNode,

lib/src/storage/backend/rocksdb.rs

@@ -80,7 +80,9 @@ pub struct ColumnFamilyDefinition {
 #[derive(Clone)]
 pub struct Db(Arc<DbHandler>);
 
+#[allow(clippy::non_send_fields_in_send_ty)]
 unsafe impl Send for Db {}
+
 unsafe impl Sync for Db {}
 
 struct DbHandler {
@@ -926,7 +928,9 @@ impl Drop for Iter {
     }
 }
 
+#[allow(clippy::non_send_fields_in_send_ty)]
 unsafe impl Send for Iter {}
+
 unsafe impl Sync for Iter {}
 
 impl Iter {

server/src/main.rs

@@ -77,7 +77,7 @@ pub fn main() -> std::io::Result<()> {
                 let file = file.to_string();
                 spawn(move || {
                     let format = file
-                        .rsplit_once(".")
+                        .rsplit_once('.')
                         .and_then(|(_, extension)| {
                             DatasetFormat::from_extension(extension)
                                 .or_else(|| GraphFormat::from_extension(extension)?.try_into().ok())

testsuite/src/files.rs

@@ -79,7 +79,7 @@ pub fn load_to_store<'a>(
 
 pub fn load_to_graph(url: &str, graph: &mut Graph) -> Result<()> {
     let format = url
-        .rsplit_once(".")
+        .rsplit_once('.')
         .and_then(|(_, extension)| GraphFormat::from_extension(extension))
         .ok_or_else(|| anyhow!("Serialization type not found for {}", url))?;
     let parser = GraphParser::from_format(format).with_base_iri(url)?;
@@ -101,7 +101,7 @@ pub fn load_to_dataset<'a>(
     to_graph_name: impl Into<GraphNameRef<'a>>,
 ) -> Result<()> {
     let to_graph_name = to_graph_name.into();
-    let extension = url.rsplit_once(".").map(|(_, ext)| ext);
+    let extension = url.rsplit_once('.').map(|(_, ext)| ext);
     if let Some(format) = extension.and_then(GraphFormat::from_extension) {
         let parser = GraphParser::from_format(format).with_base_iri(url)?;
         for t in parser.read_triples(read_file(url)?)? {