Module:Wikidata/Chemin/parser

local tool = require("Module:Utilitaire") local path = require "Module:Wikidata/Chemin/Path" local parser = require "Module:FParser"

local pparser = {}

--[[

grammar :

letter  ::= "A" | "B" | "C" | "D" | "E" | "F" | "G"

                         | "H" | "I" | "J" | "K" | "L" | "M" | "N"
                         | "O" | "P" | "Q" | "R" | "S" | "T" | "U"
                         | "V" | "W" | "X" | "Y" | "Z" | "a" | "b"
                         | "c" | "d" | "e" | "f" | "g" | "h" | "i"
                         | "j" | "k" | "l" | "m" | "n" | "o" | "p"
                         | "q" | "r" | "s" | "t" | "u" | "v" | "w"
                         | "x" | "y" | "z" ;

digit  ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; space  ::= " " ;

Pid  ::= "P" , digit, { digit } ; Pname  ::= letter, { letter | digit | space | "'" } ;

PathFirstLevel  ::= pathFirstAlternative

-- Rules specific to allow to start from a statement instead of an item on the highest level of a path, variant of PathAlternative and PathSequence

pathFirstAlternative  ::= PathFirstSequence ( '|' PathFirstSequence )* PathFirstSequence

                       ::= ('>' PathQualifier | PathEltOrInverse ) ( '/' PathEltOrInverse | '^' PathElt )*

Path ::= PathAlternative PathAlternative ::= PathSequence ( '|' PathSequence )* PathSequence ::= PathEltOrInverse ( '/' PathEltOrInverse | '^' PathElt )* PathElt ::= PathPrimary PathMod? PathEltOrInverse ::= PathElt | '^' PathElt PathMod ::= ( '*' | '?' | '+' | '{' ( Integer ( ',' ( '}' | Integer '}' ) | '}' ) ) ) PathPrimary ::= ( Prop | 'a' | '(' Path ')'

                           | ( Prop | '!' PathNegatedPropertySet ) '>' PathQualifier
                           | '!' PathNegatedPropertySet )

PathQualifier  ::= ( Prop | '!' PathNegatedPropertySet | PathPropertySet )

Prop  ::= IRIref | Pid | Pname

rules 95 and 96 in https://www.w3.org/TR/2013/REC-sparql11-query-20130321/#rPathNegatedPropertySet

PathNegatedPropertySet  ::= PathOneInPropertySet | '(' ( PathOneInPropertySet ( '|' PathOneInPropertySet )* )? ')' PathOneInPropertySet  ::= iri | 'a' | '^' ( iri | 'a' )

PathPropertySet  ::= '(' Path ( '|' Path )+ ')'

For information, SPARQL property path grammar :

https://www.w3.org/TR/sparql11-property-paths/#path-syntax

TriplesSameSubjectPath  ::= VarOrTerm PropertyListNotEmptyPath | TriplesNode PropertyListPath PropertyListPath  ::= PropertyListNotEmpty? PropertyListNotEmptyPath::= ( VerbPath | VerbSimple ) ObjectList ( ';' ( ( VerbPath | VerbSimple ) ObjectList )? )* VerbPath  ::= Path VerbSimple  ::= Var Path  ::= PathAlternative PathAlternative  ::= PathSequence ( '|' PathSequence )* PathSequence  ::= PathEltOrInverse ( '/' PathEltOrInverse | '^' PathElt )* PathElt  ::= PathPrimary PathMod? PathEltOrInverse  ::= PathElt | '^' PathElt PathMod  ::= ( '*' | '?' | '+' | '{' ( Integer ( ',' ( '}' | Integer '}' ) | '}' ) ) ) PathPrimary  ::= ( IRIref | 'a' | '(' Path ')' )

--]]

local lexer = parser.lexer

local chain = parser.chain local alternative = parser.alternative local plus = parser.plus local idop = parser.idop local nary_op_parser = parser.nary_op_parser local lex_char = lexer.lex_char local parse_epsilon = lexer.lex_epsilon local lex_integer = lexer.lex_integer

---

-- grammar base lexer functions

---

local lex_pid = function(state) local res = lexer.lex_regex(state, "P[0-9]+") if res then res.type="Pid" return res end end

local lex_sparql_prefix = function(state) local res = lexer.lex_regex(state, "[a-z_]*") if res then res.type="prefix" return res end end

local lex_property_name = function(state) local res = lexer.lex_regex(state, "[a-zA-Z][a-z A-Z'-]*") if res then res.type="Plabel" return res end end

---

-- PathElt  ::= PathPrimary PathMod? -- PathMod  ::= ( '*' | '?' | '+' | '{' ( Integer ( ',' ( '}' | Integer '}' ) | '}' ) ) )

function pparser.pathElt(state) local node local prime_node

local min_bound = nil local max_bound = nil

local function create_node(type) return idop( function(state) node = type:create(prime_node, min_bound, max_bound) end ) end

local res = chain{ pparser.pathPrimary, idop(function(state) prime_node = state.node end), alternative{ chain{ lex_char("*"), create_node(path.StarNode) }, chain{ lex_char("+"), create_node(path.PlusNode) }, chain{ lex_char("?"), create_node(path.MaybeNode) }, chain{ lex_char("^"), create_node(path.InverseNode) }, chain{ lex_char("{"), lex_integer, idop(function(state) min_bound = tonumber(state.lexed) end), alternative{ chain{ lex_char(","), lex_integer, idop(function(state) max_bound = tonumber(state.lexed) end) }, chain{ parse_epsilon, idop(function(state) max_bound = nil end) } }, create_node(path.BetweenNode, min_bound, max_bound), lex_char("}"), }, chain{ parse_epsilon, idop(function(state) node = prime_node end) } } }(state)

if res then res.node = node return res end end

-- PathEltOrInverse  ::= PathElt | '^' PathElt pparser.pathEltOrInverse = function(state) return alternative{ pparser.pathElt, chain{ lex_char("^"), pparser.pathElt, function(state) state.node = path.InverseNode(state.node) return state end } }(state) end

--[[

Tests :

plop=p.parse("P31",p.pathElt) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes property=>

  P31

plop=p.parse("P31>P279", p.pathElt) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes property=>

  P279

node=>

  P31

plop=p.parse("P31{1,6}",p.pathElt) ; t = require "Module:Tools" ; t.dump_to_console(plop)

plop=p.parse("(P31|P17>P31)",p.pathElt) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes nodes=>

  1=>
     property=>
        P31
  2=>
     property=>
        P31
     node=>
        P17

--]]

pparser.pathSequence = nary_op_parser( pparser.pathEltOrInverse, alternative{ chain{ lexer.lex_char("/"), pparser.pathEltOrInverse, }, chain{ lexer.lex_char("\^"), pparser.pathElt, function(state) state.node = path.InverseNode:create(state.node) return state end } }, function(acc) return path.SequenceNode:create(acc) end )

--[[ Tests:

plop=p.parse("P31/P31+",p.pathSequence) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes nodes=>

  1=>
     property=>
        P31
  2=>
     node=>
        property=>
           P31

--]]

-- PathAlternative  ::= PathSequence ( '|' PathSequence )*

pparser.pathAlternative = nary_op_parser( pparser.pathSequence, chain{ lex_char("[|]"), pparser.pathSequence }, function(acc) return path.AlternativeNode:create(acc) end )

--[[ plop=p.parse("P31|P17/P279+",p.pathAlternative) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes nodes=>

  1=>
     property=>
        P31
  2=>
     nodes=>
        1=>
           property=>
              P17
        2=>
           node=>
              property=>
                 P279
                 

plop=p.parse("P31|P17>P31/P279+",p.pathAlternative) ; t = require "Module:Tools" ; t.dump_to_console(plop) yes nodes=>

  1=>
     property=>
        P31
  2=>
     nodes=>
        1=>
           property=>
              P31
           node=>
              P17
        2=>
           node=>
              property=>
                 P279

--]]

-- PathSequence  ::= PathEltOrInverse ( '/' PathEltOrInverse | '^' PathElt )*

local instance = function() -- P31/P279* return path.SequenceNode:create( { path.PropertyNode:create("P31"), path.StarNode:create(path.PropertyNode:create("P279")) } ) end

-- PathPrimary  ::= ( Prop | '!' NegatedPropertySet ) ( '>' ( Prop | '!' NegatedPropertySet ) ) ? | 'a' | '(' Path ')'

pparser.pathPrimary = function(state) local node

local res = alternative{ chain{ lex_char('a'), lex_char(' '), idop(function(state) node = instance() end) }, chain{ chain{ alternative{ pparser.prop, chain {lex_char('!'), pparser.negatedPropertySet} }, idop(function(state) node = state.node end) }, alternative{ chain{ pparser.pathQualifier, idop( function(state) node = path.QualifiedStatementNode:create( node, state.node ) end ) }, parse_epsilon } }, chain{ lexer.open_parenthesis, pparser.path, idop( function(state) node = state.node end ), lexer.close_parenthesis }, chain{ lexer.lex_char('!'), pparser.negatedPropertySet, idop( function(state) node = state.node end ) } }(state) if res then res.node = node return res end end

--[[ Tests :

p.parse("a ", p.pathPrimary) => yes p.parse("!P31", p.pathPrimary) => yes p.parse("!(P31|instance of)", p.pathPrimary) => yes

--]]

-- stupid function to be eliminated soon (hum) local function parsePropAndWrap(wrapper) return chain{ pparser.prop, function (state)

local node = state.node local nodes = {} nodes[1] = {} nodes[1].node = node -- TODO: understand why this is needed instead of just "nodes[1] = node" state.node = wrapper(nodes) return state end } end

pparser.pathPropertySetParser = function(final_node_creator)

   return function(state)
   	return chain{

lexer.open_parenthesis, alternative{ nary_op_parser( pparser.pathOneInPropertySet, chain{ lexer.lex_char("|"), pparser.pathOneInPropertySet }, final_node_creator, function (node)

local singlenodes = {} singlenodes[1] = node -- mmm -- singlenodes[1].node = node

return final_node_creator(singlenodes) end ), -- parsePropAndWrap(final_node_creator), -- case for "!(P31)" like patterns, naryopparser or something needs to be fixed to better handle this -- here the solution for negation is to create a negated set with only one property. chain{ parse_epsilon, function(state) state.node = final_node_creator({}) return state end } -- allows emty set (to mimic any qualifer allowed, equiv of «*») }, lexer.close_parenthesis

   	}(state)
   end

end

pparser.propOrSetParser = function(creator) return function(state) return alternative{ parsePropAndWrap(creator), -- case for the pattern !P31 , in case it’s negated this stills need to be wrapped on a negated set pparser.pathPropertySetParser(function(nodes) return creator(nodes) end), }(state) end end

-- '>' ( Prop | '!' NegatedPropertySet | PropertySet ) pparser.pathQualifier = chain{ lex_char(">"), alternative{ chain{ lex_char("!"), pparser.propOrSetParser(function(nodes) return path.NegatedPropertySetNode:create(nodes) end) }, pparser.propOrSetParser(function(nodes) return path.PropertySetNode:create(nodes) end) }, function(state) state.node = path.QualifierSnakNode:create(state.node) return state end } --[[ =p.parse(">!(P31|P31)",p.pathQualifier) =p.parse(">(P31|P31)",p.pathQualifier) =p.parse(">P31",p.pathQualifier) =p.parse(">!P31",p.pathQualifier) --]]

-- PathNegatedPropertySet  ::= PathOneInPropertySet | '(' ( PathOneInPropertySet ( '|' PathOneInPropertySet )* )? ')'

pparser.negatedPropertySet = pparser.pathPropertySetParser( function(nodes) return path.NegatedPropertySetNode:create(nodes) end )

--[[ Tests :

p.parse("!P31",p.negatedPropertySet) p.parse("(P31|P32)",p.negatedPropertySet) => yes p.parse("P31",p.negatedPropertySet) => yes p.parse("^P31",p.negatedPropertySet) => yes p.parse("^(P31)",p.negatedPropertySet) => nope p.parse("(P31)",p.negatedPropertySet) => yes p.parse("(^P31)",p.negatedPropertySet) => yes p.parse("(^P31|a|plop)",p.negatedPropertySet) => yes

All good(?)

--]]

-- PathOneInPropertySet  ::= iri | 'a' | '^' ( iri | 'a' )

pparser.pathOneInPropertySet = function(state) local node = {}

local pElement = alternative{ chain{ lexer.lex_char('a'), idop(function(state) elem = instance() end) }, chain{ pparser.prop, idop(function(state) elem = state.node end) } }

local res = alternative{ chain{ lexer.lex_char("^"), pElement, idop(function(state) node = state.node end) }, chain{ pElement, idop(function(state) node = path.InverseNode:create(state.node) end) } }(state)

if res then res.node = node end return res end

-- Prop ::= IRIref | Pid | Pname pparser.prop = function(state) local res = alternative{ chain{ parser.questionmark( chain{ lex_sparql_prefix, lex_char(":") } ), lex_pid }, lex_property_name }(state)

if res then res.node = path.PropertyNode:create(res.lexed) return res end end --[[

Tests :

p.parse("a ", p.primary) => yes p.parse("P31@", p.prop) => nope p.parse("P31", p.prop) => nope p.parse("P31>P279", p.prop) => nope

--]]

-- PathFirstSequence  ::= '>' PathQualifier ( '/' PathEltOrInverse | '^' PathElt )* pparser.pathFirstSequence = nary_op_parser( -- chain{ pparser.pathQualifier, -- function(state) -- state.node = path.QualifierSnakNode:create(state.node) -- return state -- end -- }, chain{ lex_char("/"), pparser.pathEltOrInverse }, function (acc) return path.SequenceNode:create(acc) end )

pparser.path = function(state) return pparser.pathAlternative(state) end

-- PathFirstAlternative  ::= PathFirstSequence ( '|' PathFirstSequence )* | Path pparser.pathFirstAlternative = alternative{ pparser.path, nary_op_parser( pparser.pathFirstSequence, chain{ lex_char("|"), pparser.pathFirstSequence }, function(acc) return path.AlternativeNode:create(acc) end ), }

-- plop = p.parse_path("P31/P31/P31>P31/P31")

pparser.parse_path = function (property_path) local res = parser.parse(property_path, pparser.pathFirstAlternative) assert(res, "parsing returned a nil obj on path : «" .. property_path .. "»") return res end

-- to test in console pparser.parse = parser.parse

return pparser