Upgrades formatting to 1.31

lib/src/sparql/algebra.rs

@@ -747,7 +747,8 @@ impl<'a> fmt::Display for SparqlExpression<'a> {
                         SparqlExpression(&*b),
                         SparqlExpression(cv)
                     )
-                }).unwrap_or_else(|| {
+                })
+                .unwrap_or_else(|| {
                     write!(
                         f,
                         "SUBSTR({}, {})",
@@ -1130,12 +1131,15 @@ impl<'a> fmt::Display for SparqlGraphPattern<'a> {
                 SparqlGraphPattern(&*a),
                 SparqlGraphPattern(&*b)
             ),
-            GraphPattern::Service(n, p, s) => if *s {
+            GraphPattern::Service(n, p, s) => {
+                if *s {
                     write!(f, "SERVICE SILENT {} {{ {} }}", n, SparqlGraphPattern(&*p))
                 } else {
                     write!(f, "SERVICE {} {{ {} }}", n, SparqlGraphPattern(&*p))
-            },
-            GraphPattern::Data(bs) => if bs.is_empty() {
+                }
+            }
+            GraphPattern::Data(bs) => {
+                if bs.is_empty() {
                     Ok(())
                 } else {
                     write!(f, "VALUES ( ")?;
@@ -1154,7 +1158,8 @@ impl<'a> fmt::Display for SparqlGraphPattern<'a> {
                         write!(f, ") ")?;
                     }
                     write!(f, " }}")
-            },
+                }
+            }
             GraphPattern::AggregateJoin(GroupPattern(group, p), agg) => write!(
                 f,
                 "{{ SELECT {} WHERE {{ {} }} GROUP BY {} }}",
@@ -1301,7 +1306,8 @@ pub enum Aggregation {
 impl fmt::Display for Aggregation {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Aggregation::Count(e, distinct) => if *distinct {
+            Aggregation::Count(e, distinct) => {
+                if *distinct {
                     e.as_ref()
                         .map(|ex| write!(f, "COUNT(DISTINCT {})", ex))
                         .unwrap_or_else(|| write!(f, "COUNT(DISTINCT *)"))
@@ -1309,33 +1315,45 @@ impl fmt::Display for Aggregation {
                     e.as_ref()
                         .map(|ex| write!(f, "COUNT({})", ex))
                         .unwrap_or_else(|| write!(f, "COUNT(*)"))
-            },
-            Aggregation::Sum(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Sum(e, distinct) => {
+                if *distinct {
                     write!(f, "Aggregation(Distinct({}), Sum, {{}})", e)
                 } else {
                     write!(f, "Aggregation({}, Sum, {{}})", e)
-            },
-            Aggregation::Min(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Min(e, distinct) => {
+                if *distinct {
                     write!(f, "Aggregation(Distinct({}), Min, {{}})", e)
                 } else {
                     write!(f, "Aggregation({}, Min, {{}})", e)
-            },
-            Aggregation::Max(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Max(e, distinct) => {
+                if *distinct {
                     write!(f, "Aggregation(Distinct({}), Max, {{}})", e)
                 } else {
                     write!(f, "Aggregation({}, Max, {{}})", e)
-            },
-            Aggregation::Avg(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Avg(e, distinct) => {
+                if *distinct {
                     write!(f, "Aggregation(Distinct({}), Avg, {{}})", e)
                 } else {
                     write!(f, "Aggregation({}, Avg, {{}})", e)
-            },
-            Aggregation::Sample(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Sample(e, distinct) => {
+                if *distinct {
                     write!(f, "Aggregation(Distinct({}), Sum, {{}})", e)
                 } else {
                     write!(f, "Aggregation({}, Sample, {{}})", e)
-            },
-            Aggregation::GroupConcat(e, distinct, sep) => if *distinct {
+                }
+            }
+            Aggregation::GroupConcat(e, distinct, sep) => {
+                if *distinct {
                     sep.as_ref()
                         .map(|s| {
                             write!(
@@ -1345,7 +1363,9 @@ impl fmt::Display for Aggregation {
                             s.escape()
                         )
                         })
-                    .unwrap_or_else(|| write!(f, "Aggregation(Distinct({}), GroupConcat, {{}})", e))
+                        .unwrap_or_else(|| {
+                            write!(f, "Aggregation(Distinct({}), GroupConcat, {{}})", e)
+                        })
                 } else {
                     sep.as_ref()
                         .map(|s| {
@@ -1356,8 +1376,11 @@ impl fmt::Display for Aggregation {
                                 s.escape()
                             )
                         })
-                    .unwrap_or_else(|| write!(f, "Aggregation(Distinct({}), GroupConcat, {{}})", e))
-            },
+                        .unwrap_or_else(|| {
+                            write!(f, "Aggregation(Distinct({}), GroupConcat, {{}})", e)
+                        })
+                }
+            }
         }
     }
 }
@@ -1367,7 +1390,8 @@ struct SparqlAggregation<'a>(&'a Aggregation);
 impl<'a> fmt::Display for SparqlAggregation<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.0 {
-            Aggregation::Count(e, distinct) => if *distinct {
+            Aggregation::Count(e, distinct) => {
+                if *distinct {
                     if let Some(e) = e {
                         write!(f, "COUNT(DISTINCT {})", SparqlExpression(e))
                     } else {
@@ -1377,33 +1401,45 @@ impl<'a> fmt::Display for SparqlAggregation<'a> {
                     write!(f, "COUNT({})", SparqlExpression(e))
                 } else {
                     write!(f, "COUNT(*)")
-            },
-            Aggregation::Sum(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Sum(e, distinct) => {
+                if *distinct {
                     write!(f, "SUM(DISTINCT {})", SparqlExpression(e))
                 } else {
                     write!(f, "SUM({})", SparqlExpression(e))
-            },
-            Aggregation::Min(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Min(e, distinct) => {
+                if *distinct {
                     write!(f, "MIN(DISTINCT {})", SparqlExpression(e))
                 } else {
                     write!(f, "MIN({})", SparqlExpression(e))
-            },
-            Aggregation::Max(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Max(e, distinct) => {
+                if *distinct {
                     write!(f, "MAX(DISTINCT {})", SparqlExpression(e))
                 } else {
                     write!(f, "MAX({})", SparqlExpression(e))
-            },
-            Aggregation::Avg(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Avg(e, distinct) => {
+                if *distinct {
                     write!(f, "AVG(DISTINCT {})", SparqlExpression(e))
                 } else {
                     write!(f, "AVG({})", SparqlExpression(e))
-            },
-            Aggregation::Sample(e, distinct) => if *distinct {
+                }
+            }
+            Aggregation::Sample(e, distinct) => {
+                if *distinct {
                     write!(f, "SAMPLE(DISTINCT {})", SparqlExpression(e))
                 } else {
                     write!(f, "SAMPLE({})", SparqlExpression(e))
-            },
-            Aggregation::GroupConcat(e, distinct, sep) => if *distinct {
+                }
+            }
+            Aggregation::GroupConcat(e, distinct, sep) => {
+                if *distinct {
                     if let Some(sep) = sep {
                         write!(
                             f,
@@ -1423,7 +1459,8 @@ impl<'a> fmt::Display for SparqlAggregation<'a> {
                     )
                 } else {
                     write!(f, "GROUP_CONCAT({})", SparqlExpression(e))
-            },
+                }
+            }
         }
     }
 }

lib/src/sparql/eval.rs

@@ -358,7 +358,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                 )? {
                     Ordering::Greater | Ordering::Equal => true,
                     Ordering::Less => false,
-                }.into(),
+                }
+                .into(),
             ),
             PlanExpression::Lower(a, b) => Some(
                 (self.partial_cmp_literals(
@@ -374,7 +375,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                 )? {
                     Ordering::Less | Ordering::Equal => true,
                     Ordering::Greater => false,
-                }.into(),
+                }
+                .into(),
             ),
             PlanExpression::In(e, l) => {
                 let needed = self.eval_expression(e, tuple)?;
@@ -493,11 +495,13 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                 }
                 None
             }
-            PlanExpression::If(a, b, c) => if self.to_bool(self.eval_expression(a, tuple)?)? {
+            PlanExpression::If(a, b, c) => {
+                if self.to_bool(self.eval_expression(a, tuple)?)? {
                     self.eval_expression(b, tuple)
                 } else {
                     self.eval_expression(c, tuple)
-            },
+                }
+            }
             PlanExpression::StrLang(lexical_form, lang_tag) => {
                 Some(EncodedTerm::LangStringLiteral {
                     value_id: self
@@ -525,7 +529,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                     | EncodedTerm::IntegerLiteral(_)
                     | EncodedTerm::DecimalLiteral(_) => true,
                     _ => false,
-                }.into(),
+                }
+                .into(),
             ),
             PlanExpression::LangMatches(language_tag, language_range) => {
                 let language_tag =
@@ -539,7 +544,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                         LanguageTag::from_str(&language_range)
                             .ok()?
                             .matches(&LanguageTag::from_str(&language_tag).ok()?)
-                    }.into(),
+                    }
+                    .into(),
                 )
             }
             PlanExpression::Regex(text, pattern, flags) => {
@@ -634,7 +640,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                         Decimal::one()
                     } else {
                         Decimal::zero()
-                    }.into(),
+                    }
+                    .into(),
                 ),
                 EncodedTerm::SimpleLiteral { value_id }
                 | EncodedTerm::StringLiteral { value_id } => Some(EncodedTerm::DecimalLiteral(
@@ -802,7 +809,8 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
                             Some(term) => Some(encoder.decode_term(term)?),
                             None => None,
                         })
-                    }).collect()
+                    })
+                    .collect()
             })),
         )
     }
@@ -826,11 +834,13 @@ impl<S: EncodedQuadsStore> SimpleEvaluator<S> {
             self.eval_expression(expression, tuple_b),
         ) {
             (Some(a), Some(b)) => match a {
-                EncodedTerm::BlankNode(a) => if let EncodedTerm::BlankNode(b) = b {
+                EncodedTerm::BlankNode(a) => {
+                    if let EncodedTerm::BlankNode(b) = b {
                         a.cmp(&b)
                     } else {
                         Ordering::Less
-                },
+                    }
+                }
                 EncodedTerm::NamedNode { iri_id: a } => match b {
                     EncodedTerm::NamedNode { iri_id: b } => {
                         self.compare_str_ids(a, b).unwrap_or(Ordering::Equal)
@@ -970,9 +980,11 @@ fn combine_tuples(a: &[Option<EncodedTerm>], b: &[Option<EncodedTerm>]) -> Optio
         for (key, a_value) in a.into_iter().enumerate() {
             if let Some(a_value) = a_value {
                 match b[key] {
-                    Some(ref b_value) => if a_value != b_value {
+                    Some(ref b_value) => {
+                        if a_value != b_value {
                             return None;
-                    },
+                        }
+                    }
                     None => result[key] = Some(*a_value),
                 }
             }
@@ -983,9 +995,11 @@ fn combine_tuples(a: &[Option<EncodedTerm>], b: &[Option<EncodedTerm>]) -> Optio
         for (key, b_value) in b.into_iter().enumerate() {
             if let Some(b_value) = b_value {
                 match a[key] {
-                    Some(ref a_value) => if a_value != b_value {
+                    Some(ref a_value) => {
+                        if a_value != b_value {
                             return None;
-                    },
+                        }
+                    }
                     None => result[key] = Some(*b_value),
                 }
             }
@@ -1128,11 +1142,13 @@ impl<'a> Iterator for HashDeduplicateIterator<'a> {
 
     fn next(&mut self) -> Option<Result<EncodedTuple>> {
         match self.iter.next()? {
-            Ok(tuple) => if self.already_seen.insert(tuple.clone()) {
+            Ok(tuple) => {
+                if self.already_seen.insert(tuple.clone()) {
                     Some(Ok(tuple))
                 } else {
                     self.next()
-            },
+                }
+            }
             Err(error) => Some(Err(error)),
         }
     }

lib/src/sparql/parser.rs

@@ -179,7 +179,8 @@ mod grammar {
         iter.fold(None, |a, b| match a {
             Some(av) => Some(combine(av, b)),
             None => Some(b),
-        }).ok_or("The iterator should not be empty")
+        })
+        .ok_or("The iterator should not be empty")
     }
 
     enum SelectionOption {
@@ -253,12 +254,14 @@ mod grammar {
                 for sel_item in sel_items {
                     match sel_item {
                         SelectionMember::Variable(v) => pv.push(v),
-                        SelectionMember::Expression(e, v) => if pv.contains(&v) {
+                        SelectionMember::Expression(e, v) => {
+                            if pv.contains(&v) {
                                 //TODO: fail
                             } else {
                                 p = GraphPattern::Extend(Box::new(p), v.clone(), e);
                                 pv.push(v);
-                        },
+                            }
+                        }
                     }
                 }
             }

lib/src/sparql/plan.rs

@@ -483,7 +483,8 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
                         OrderComparator::Desc(e) => {
                             Ok(Comparator::Desc(self.build_for_expression(e, variables)?))
                         }
-                    }).collect();
+                    })
+                    .collect();
                 PlanNode::Sort {
                     child: Box::new(self.build_for_graph_pattern(l, input, variables, graph_name)?),
                     by: by?,
@@ -662,7 +663,8 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
                     None => None,
                 },
             ),
-            Expression::CustomFunctionCall(name, parameters) => if *name == *xsd::BOOLEAN {
+            Expression::CustomFunctionCall(name, parameters) => {
+                if *name == *xsd::BOOLEAN {
                     self.build_cast(
                         parameters,
                         PlanExpression::BooleanCast,
@@ -698,7 +700,8 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
                     self.build_cast(parameters, PlanExpression::StringCast, variables, "string")?
                 } else {
                     Err(format_err!("Not supported custom function {}", expression))?
-            },
+                }
+            }
             _ => unimplemented!(),
         })
     }
@@ -780,7 +783,8 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
                     }
                 }
                 Ok(result)
-            }).collect()
+            })
+            .collect()
     }
 
     fn build_for_graph_template(
@@ -809,7 +813,8 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
                         &mut bnodes,
                     )?,
                 })
-            }).collect()
+            })
+            .collect()
     }
 
     fn template_value_from_term_or_variable(
@@ -822,11 +827,13 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
             TermOrVariable::Term(term) => {
                 TripleTemplateValue::Constant(self.store.encoder().encode_term(term)?)
             }
-            TermOrVariable::Variable(variable) => if variable.has_name() {
+            TermOrVariable::Variable(variable) => {
+                if variable.has_name() {
                     TripleTemplateValue::Variable(variable_key(variables, variable))
                 } else {
                     TripleTemplateValue::BlankNode(variable_key(bnodes, variable))
-            },
+                }
+            }
         })
     }
 
@@ -840,11 +847,13 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
             NamedNodeOrVariable::NamedNode(term) => {
                 TripleTemplateValue::Constant(self.store.encoder().encode_named_node(term)?)
             }
-            NamedNodeOrVariable::Variable(variable) => if variable.has_name() {
+            NamedNodeOrVariable::Variable(variable) => {
+                if variable.has_name() {
                     TripleTemplateValue::Variable(variable_key(variables, variable))
                 } else {
                     TripleTemplateValue::BlankNode(variable_key(bnodes, variable))
-            },
+                }
+            }
         })
     }
 }

lib/src/sparql/xml_results.rs

@@ -285,15 +285,18 @@ impl<R: BufRead> Iterator for ResultsIterator<R> {
             }
             match event {
                 Event::Start(event) => match state {
-                    State::Start => if event.name() == b"result" {
+                    State::Start => {
+                        if event.name() == b"result" {
                             state = State::Result;
                         } else {
                             return Some(Err(format_err!(
                                 "Expecting <result>, found {}",
                                 self.reader.decode(event.name())
                             )));
-                    },
-                    State::Result => if event.name() == b"binding" {
+                        }
+                    }
+                    State::Result => {
+                        if event.name() == b"binding" {
                             match event
                                 .attributes()
                                 .filter_map(|attr| attr.ok())
@@ -315,7 +318,8 @@ impl<R: BufRead> Iterator for ResultsIterator<R> {
                                 "Expecting <binding>, found {}",
                                 self.reader.decode(event.name())
                             )));
-                    },
+                        }
+                    }
                     State::Binding => {
                         if term.is_some() {
                             return Some(Err(format_err!(

lib/src/store/encoded.rs

@@ -845,7 +845,8 @@ impl<S: EncodedQuadsStore> Graph for StoreUnionGraph<S> {
                 encoder.encode_named_or_blank_node(triple.subject())?,
                 encoder.encode_named_node(triple.predicate())?,
                 encoder.encode_term(triple.object())?,
-            )?.any(|_| true))
+            )?
+            .any(|_| true))
     }
 
     fn insert(&self, _triple: &Triple) -> Result<()> {

lib/src/store/numeric_encoder.rs

@@ -380,7 +380,8 @@ impl<R: Read> TermReader for R {
                 NaiveDateTime::from_timestamp_opt(
                     self.read_i64::<LittleEndian>()?,
                     self.read_u32::<LittleEndian>()?,
-                ).ok_or_else(|| format_err!("Invalid date time serialization"))?,
+                )
+                .ok_or_else(|| format_err!("Invalid date time serialization"))?,
                 FixedOffset::east_opt(self.read_i32::<LittleEndian>()?)
                     .ok_or_else(|| format_err!("Invalid timezone offset"))?,
             ))),
@@ -388,7 +389,8 @@ impl<R: Read> TermReader for R {
                 NaiveDateTime::from_timestamp_opt(
                     self.read_i64::<LittleEndian>()?,
                     self.read_u32::<LittleEndian>()?,
-                ).ok_or_else(|| format_err!("Invalid date time serialization"))?,
+                )
+                .ok_or_else(|| format_err!("Invalid date time serialization"))?,
             )),
             _ => Err(format_err!("the term buffer has an invalid type id")),
         }
@@ -644,14 +646,16 @@ impl<S: StringStore> Encoder<S> {
             } => Ok(Literal::new_language_tagged_literal(
                 self.string_store.get_str(value_id)?,
                 self.string_store.get_str(language_id)?,
-            ).into()),
+            )
+            .into()),
             EncodedTerm::TypedLiteral {
                 value_id,
                 datatype_id,
             } => Ok(Literal::new_typed_literal(
                 self.string_store.get_str(value_id)?,
                 NamedNode::from(self.string_store.get_url(datatype_id)?),
-            ).into()),
+            )
+            .into()),
             EncodedTerm::StringLiteral { value_id } => {
                 Ok(Literal::from(self.string_store.get_str(value_id)?).into())
             }

lib/tests/rdf_test_cases.rs

@@ -96,7 +96,8 @@ fn turtle_w3c_testsuite() {
                 .map(|r| client.load_turtle(r))
                 .unwrap_or_else(|| Ok(MemoryGraph::default()));
             assert!(
-                action_graph.is_err() || !action_graph
+                action_graph.is_err()
+                    || !action_graph
                         .unwrap()
                         .is_isomorphic(&result_graph.unwrap())
                         .unwrap(),
@@ -210,12 +211,13 @@ impl RDFClient {
     fn get(&self, url: &Url) -> Result<Response> {
         match self.client.get(url.clone()).send() {
             Ok(response) => Ok(response),
-            Err(error) => if error.description() == "parsed HTTP message from remote is incomplete"
-            {
+            Err(error) => {
+                if error.description() == "parsed HTTP message from remote is incomplete" {
                     self.get(url)
                 } else {
                     Err(format_err!("HTTP request error: {}", error.description()))
-            },
+                }
+            }
         }
     }
 }

lib/tests/sparql_test_cases.rs

@@ -37,7 +37,8 @@ fn sparql_w3c_syntax_testsuite() {
             .unwrap();
     let manifest_11_url = Url::parse(
         "http://www.w3.org/2009/sparql/docs/tests/data-sparql11/syntax-query/manifest.ttl",
-    ).unwrap();
+    )
+    .unwrap();
     let test_blacklist = vec![
         NamedNode::from_str("http://www.w3.org/2001/sw/DataAccess/tests/data-r2/syntax-sparql2/manifest#syntax-form-construct02").unwrap(),
         //TODO: Deserialization of the serialization failing:
@@ -308,12 +309,13 @@ impl RDFClient {
     fn get(&self, url: &Url) -> Result<Response> {
         match self.client.get(url.clone()).send() {
             Ok(response) => Ok(response),
-            Err(error) => if error.description() == "parsed HTTP message from remote is incomplete"
-            {
+            Err(error) => {
+                if error.description() == "parsed HTTP message from remote is incomplete" {
                     self.get(url)
                 } else {
                     Err(format_err!("HTTP request error: {}", error.description()))
-            },
+                }
+            }
         }
     }
 }
@@ -328,7 +330,8 @@ mod rs {
                 .unwrap();
         pub static ref RESULT_VARIABLE: NamedNode = NamedNode::from_str(
             "http://www.w3.org/2001/sw/DataAccess/tests/result-set#resultVariable"
-        ).unwrap();
+        )
+        .unwrap();
         pub static ref SOLUTION: NamedNode =
             NamedNode::from_str("http://www.w3.org/2001/sw/DataAccess/tests/result-set#solution")
                 .unwrap();
@@ -583,7 +586,8 @@ impl<'a> Iterator for TestManifest<'a> {
                             .filter_map(|g| match g {
                                 Ok(Term::NamedNode(q)) => Some(q.into()),
                                 _ => None,
-                            }).collect();
+                            })
+                            .collect();
                         (query, data, graph_data)
                     }
                     Some(_) => return Some(Err(format_err!("invalid action"))),

python/src/lib.rs

@@ -1,7 +1,4 @@
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(zero_ptr, transmute_ptr_to_ptr)
-)]
+#![cfg_attr(feature = "cargo-clippy", allow(zero_ptr, transmute_ptr_to_ptr))]
 
 #[macro_use]
 extern crate cpython;

server/src/main.rs

@@ -79,18 +79,21 @@ pub fn main() -> Result<(), failure::Error> {
                 .long("bind")
                 .help("Specify a server socket to bind using the format $(HOST):$(PORT)")
                 .takes_value(true),
-        ).arg(
+        )
+        .arg(
             Arg::with_name("ntriples")
                 .long("ntriples")
                 .help("Load a N-Triples file in the server at startup")
                 .takes_value(true),
-        ).arg(
+        )
+        .arg(
             Arg::with_name("file")
                 .long("file")
                 .short("f")
                 .help("File in which persist the dataset")
                 .takes_value(true),
-        ).get_matches();
+        )
+        .get_matches();
 
     let file = matches.value_of("file").map(|v| v.to_string());
     if let Some(file) = file {
@@ -233,7 +236,8 @@ fn parse_urlencoded_query_request(query: &[u8]) -> Result<QueryRequest, failure:
         .find(|(key, _)| key == "query")
         .map(|(_, value)| QueryRequest {
             query: value.to_string(),
-        }).ok_or_else(|| format_err!("'query' parameter not found"))
+        })
+        .ok_or_else(|| format_err!("'query' parameter not found"))
 }
 
 fn evaluate_sparql_query<D: SparqlDataset + Send + Sync + RefUnwindSafe + 'static>(
@@ -309,7 +313,8 @@ mod tests {
                 "http://localhost/query",
                 "SELECT * WHERE { ?s ?p ?o }",
                 Mime::from_str("application/sparql-query").unwrap(),
-            ).perform()
+            )
+            .perform()
             .unwrap();
         assert_eq!(response.status(), StatusCode::OK);
     }