.

graph/src/language.rs

@@ -1,3 +1,4 @@
+use std::env::var;
 use oxigraph::model::{Literal, TermRef};
 use oxilangtag::LanguageTag;
 use std::sync::LazyLock;
@@ -53,7 +54,7 @@ impl LanguageCondition {
     }
 
     pub fn filter(conditions: impl IntoIterator<Item = (String, Self)>) -> String {
-        let exact_expression = |language, variable| Expression::FunctionCall(
+        let exact_expression = |variable: String, language| Expression::FunctionCall(
             Function::LangMatches, vec![
                 Expression::FunctionCall(Function::Lang, vec![
                     Expression::Variable(Variable::new_unchecked(variable))
@@ -70,10 +71,10 @@ impl LanguageCondition {
 
         let condition_to_expression = |variable, condition| match condition {
             LanguageCondition::ExactMatchOnly(language) =>
-                Some(exact_expression(language.to_string(), variable)),
+                Some(exact_expression(variable, language.to_string())),
             LanguageCondition::ExactMatchOrUntagged(language) => {
                 Some(Expression::Or(
-                    Box::new(exact_expression(language.to_string(), variable.clone())),
+                    Box::new(exact_expression(variable.clone(), language.to_string())),
                     Box::new(untagged_expression(variable)),
                 ))
             }
@@ -84,28 +85,15 @@ impl LanguageCondition {
         let mut iter = conditions.into_iter();
         let first_expression = iter.next()
             .and_then(|(variable, condition)| condition_to_expression(variable, condition));
-        let remaining_expressions = iter.filter_map(|(variable, condition)| condition_to_expression(variable, condition))
-            .collect::<Vec<_>>();
-        let concatenated_expressions = if let Some(expression) = first_expression {
-            if remaining_expressions.is_empty() {
-                //Expression::
-            }
-        } else { String::default() }
-    }
-
-    pub fn to_sparql_expression(&self, var: &str) -> String {
-        let foo =
-        debug!("Test: {foo}");
-
-        match self {
-            LanguageCondition::ExactMatchOnly(language) => {
-                format!(r#"FILTER(langMATCHES(LANG(?{var}), "{language}"))"#)
-            }
-            LanguageCondition::ExactMatchOrUntagged(language) => {
-                format!(r#"FILTER(langMATCHES(LANG(?{var}), "{language}") || !hasLANG(?{var}))"#)
-            }
-            LanguageCondition::UntaggedOnly => format!("FILTER(!hasLANG(?{var}))"),
-            LanguageCondition::AnyOrNone => "".to_string(),
+        if let Some(expression) = first_expression {
+            let expr = iter.filter_map(|(variable, condition)| condition_to_expression(variable, condition))
+                .fold(expression, |acc, next_exp| Expression::Or(Box::new(acc), Box::new(next_exp)));
+            GraphPattern::Filter {
+                expr,
+                inner: Box::new(GraphPattern::Bgp { patterns: vec![] }),
+            }.to_string()
+        } else {
+            String::default()
         }
     }
 }