Re: Markup questions: html/body, datatype="", double predicates

Richard Cyganiak wrote:
[snip]
>>
>> Again, this behaviour is actually the right one. Labelling a subtree as
>> a @property means that this subtree is, sort of, removed from the RDFa
>> processing.
> 
> Are you sure?
> 
> Quoting the spec: “Processing generally continues recursively through
> the entire tree of elements available. However, if an author indicates
> that some branch of the tree should be treated as an XML literal, no
> further processing should take place on that branch, and setting this
> flag tofalse would have that effect.”
> 
> It doesn't say anything about stopping when the author indicates that
> some branch should be treated as a plain literal.
> 
> Also relevant: “Once the triple has been created, if the [datatype] of
> the [current object literal] is rdf:XMLLiteral, then the [recurse] flag
> is set to false.”
> 
> Reading this makes me just more confused. I'm not sure how to interpret
> this. Obviously, if I set @datatype to rdf:XMLLiteral, then it should
> not recurse, that's clear.
> 
> But what if I don't specify @datatype at all? This will generate an XML
> literal if there's markup in the child nodes. But does it trigger the
> condition in this sentence? Is the [datatype] rdf:XMLLiteral in that
> case, or is the [datatype] unspecified? The question is if [datatype]
> refers to the @datatype attribute here, or to the RDF datatype of the
> resulting RDF node, in the RDF abstract syntax sense.
> 

Hm. Richard, you should have joined us earlier:-)

- I do not think there is a problem with XMLLiteral case you describe in
your last remark. The text you quote in step 9 of the processing model, ie,

[[[
Once the triple has been created, if the [datatype] of the [current
object literal] is rdf:XMLLiteral, then the [recurse] flag is set to false.
]]] (Section 5.5, step 9)

does not refer, in my view, to the @property value but the datatype of
the generated of [current object literal] which, according to item three
in step nine will be XMLLiteral.

- But, indeed... what happens if @datatype="" is used? Then item two of
the said step 9 enters into effect, which means to generate a plain
literal of the text nodes but, you are absolutely right, the remark
given at the end of step 9 does not give any more information on
recursion! More exactly, the text could be read as saying: one has to
move on with the recursion.

My recollection of the discussion in the group was that recursion is not
required in that case either. But yes, this is not in line with the spec
as it stands now.

To add insult to indjury:-) I do _not_ think there is a test for this! I
looked through:

http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/rdfa-xhtml1-test-manifest.rdf

and I have not found anything:-( Ie, unless I missed a test, we have a
problem!

I attach the test case (0XXX.html) and two possible outputs, namely
0XXX.sparql and 0XXX-a.sparql. 0XXX.sparql works according to my
understanding/recollection of the discussions, ie, @property="" cuts the
recursion altogether, 0XXX-a.sparql may be the correct reading of the
spec. If the latter, than there is a bug in the distiller:-(. In both
cases I think the test case should be expanded...

(actually, my collection says that _any_ @property value cuts recursion,
not only @property="" or XMLLiteral...)

Thanks Richard!

Ben, Mark, Michael, others: what do you think?


Ivan


> Hope there's a test case in the suite that answers this question ;-)
> 
> Richard
> 
> 
> 
>>
>>
>>
>>>
>>> 3. Double predicates. Just to confirm, is it always allowed to have
>>> multiple CURIEs in the CURIE-accepting properties?
>>>
>>> rel="foo:prop1 bar:prop2"
>>> rev="foo:prop1 bar:prop2"
>>> property="foo:prop1 bar:prop2"
>>> typeof="foo:prop1 bar:prop2"
>>>
>>> I assume that all of these are legal and will result in two triples
>>> instead of one?
>>>
>>
>> Yes.
>>
>>>
>>> That's all for now. Finally, in case that some of the folks who
>>> influenced the design of RDFa on this list: Let me say that I'm
>>> impressed with the result.
>>
>> Thank you!
>>
>> Ivan
>>
>>
>>>                            Obviously a lot of thought went into every
>>> detail of the language and the result is pleasing and elegant. Finally,
>>> here's an RDF syntax that does not suck and makes RDF publishing fun!
>>>
>>> Cheers,
>>> Richard
>>>
>>
>> -- 
>>
>> Ivan Herman, W3C Semantic Web Activity Lead
>> Home: http://www.w3.org/People/Ivan/
>> PGP Key: http://www.ivan-herman.net/pgpkey.html
>> FOAF: http://www.ivan-herman.net/foaf.rdf
> 

-- 

Ivan Herman, W3C Semantic Web Activity Lead
Home: http://www.w3.org/People/Ivan/
PGP Key: http://www.ivan-herman.net/pgpkey.html
FOAF: http://www.ivan-herman.net/foaf.rdf

ASK WHERE {
	<http://example.org/node> <http://example.org/property> "outer Literal, ie, the whole thing" .
 }

ASK WHERE {
	<http://example.org/node> <http://example.org/property> "outer Literal, ie, the whole thing" .
	<http://example.org/node> <http://example.org/property2> "Literal" .
 }