From cdafcfc2ccabc7b72a85fa6f775304d985f30015 Mon Sep 17 00:00:00 2001
From: Tpt <thomas@pellissier-tanon.fr>
Date: Tue, 2 Oct 2018 15:16:06 +0200
Subject: [PATCH] Applies Property Path Patterns translation

---
 src/sparql/parser.rs              | 36 +++++++++++++++++++++++++------
 src/sparql/sparql_grammar.rustpeg | 10 ++++-----
 2 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/src/sparql/parser.rs b/src/sparql/parser.rs
index 9291a935..ac9855c6 100644
--- a/src/sparql/parser.rs
+++ b/src/sparql/parser.rs
@@ -63,14 +63,38 @@ mod grammar {
         PropertyPath(PropertyPath),
     }
 
-    fn to_triple_or_path_pattern(
+    impl From<Variable> for VariableOrPropertyPath {
+        fn from(var: Variable) -> Self {
+            VariableOrPropertyPath::Variable(var)
+        }
+    }
+
+    impl From<PropertyPath> for VariableOrPropertyPath {
+        fn from(path: PropertyPath) -> Self {
+            VariableOrPropertyPath::PropertyPath(path)
+        }
+    }
+
+    fn add_to_triple_or_path_patterns(
         s: TermOrVariable,
-        p: VariableOrPropertyPath,
+        p: impl Into<VariableOrPropertyPath>,
         o: TermOrVariable,
-    ) -> TripleOrPathPattern {
-        match p {
-            VariableOrPropertyPath::Variable(p) => TriplePattern::new(s, p, o).into(),
-            VariableOrPropertyPath::PropertyPath(p) => PathPattern::new(s, p, o).into(),
+        patterns: &mut Vec<TripleOrPathPattern>,
+    ) {
+        match p.into() {
+            VariableOrPropertyPath::Variable(p) => {
+                patterns.push(TriplePattern::new(s, p, o).into())
+            }
+            VariableOrPropertyPath::PropertyPath(p) => match p {
+                PropertyPath::PredicatePath(p) => patterns.push(TriplePattern::new(s, p, o).into()),
+                PropertyPath::InversePath(p) => add_to_triple_or_path_patterns(o, *p, s, patterns),
+                PropertyPath::SequencePath(a, b) => {
+                    let middle = Variable::default();
+                    add_to_triple_or_path_patterns(s, *a, middle.clone().into(), patterns);
+                    add_to_triple_or_path_patterns(middle.into(), *b, o, patterns);
+                }
+                p => patterns.push(PathPattern::new(s, p, o).into()),
+            },
         }
     }
 
diff --git a/src/sparql/sparql_grammar.rustpeg b/src/sparql/sparql_grammar.rustpeg
index 729ffded..1f76afad 100644
--- a/src/sparql/sparql_grammar.rustpeg
+++ b/src/sparql/sparql_grammar.rustpeg
@@ -458,7 +458,7 @@ TriplesSameSubjectPath -> Vec<TripleOrPathPattern> =
         let mut patterns = po.patterns;
         for (p, os) in po.focus {
             for o in os {
-                patterns.push(to_triple_or_path_pattern(s.clone(), p.clone(), o))
+                add_to_triple_or_path_patterns(s.clone(), p.clone(), o, &mut patterns);
             }
         }
         patterns
@@ -468,7 +468,7 @@ TriplesSameSubjectPath -> Vec<TripleOrPathPattern> =
             patterns.extend_from_slice(&po.patterns);
         for (p, os) in po.focus {
             for o in os {
-                patterns.push(to_triple_or_path_pattern(s.focus.clone(), p.clone(), o))
+                add_to_triple_or_path_patterns(s.focus.clone(), p.clone(), o, &mut patterns);
             }
         }
         patterns
@@ -502,12 +502,12 @@ PropertyListPathNotEmpty_item_content -> FocusedTriplePattern<(VariableOrPropert
 
 //[84]
 VerbPath -> VariableOrPropertyPath = p:Path {
-    VariableOrPropertyPath::PropertyPath(p)
+    p.into()
 }
 
 //[85]
 VerbSimple -> VariableOrPropertyPath = v:Var {
-    VariableOrPropertyPath::Variable(v)
+    v.into()
 }
 
 //[86]
@@ -625,7 +625,7 @@ BlankNodePropertyListPath -> FocusedTripleOrPathPattern<TermOrVariable> = '[' _
     let mut bnode = TermOrVariable::from(BlankNode::default());
     for (p, os) in po.focus {
         for o in os {
-            patterns.push(to_triple_or_path_pattern(bnode.clone(), p.clone(), o));
+            add_to_triple_or_path_patterns(bnode.clone(), p.clone(), o, &mut patterns);
         }
     }
     FocusedTripleOrPathPattern {