Re: A proposed solution

>>[[[Definition: URI references which identify namespaces are considered
>>identical when they are exactly the same character-for-character. Note
>>that URI references which are not identical in this sense may in fact
be
>>functionally equivalent. Examples include URI references which differ
>>only in case, or which are in external entities which have different
>>effective base URIs.]]]
>
>This paragraph, whilst architecturally objectionable to a small but
>vocal minority was at least more or less clear in its intent.

IMHO this is slightly overstating it - it has been pointed out
repeatedly on this list (and in fact it is the whole reason for the
existence of the list) that it was not clear: compare before or after
expansion etc. etc.

> If I annotate the proposed replacement then perhaps you could
> suggest a clarified wording? (Judging by the responses so far I'm not
> the only one who couldn't decide what this proposal would mean in
> various cases)
>
>>[[[According to RFC 2396 a URI reference can be either a relative or
an
>>absolute URI. The scheme of an absolute URI identifies the URI space
to
>>which that URI belongs. A URI space is typically defined with a set of
>>properties concerning uniqueness, normalization rules etc. as well as
>>one or more default mechanisms for resolving URIs belonging to that
URI
>>space.
>
> Given your previous clarification I would delete this paragraph
> The second part about uri scheme specific normalisation rules and
> properties would seem to indicate that these normalisations are
> intended to be applied to namespace names that are absolute URI.
> As you say that wasn't the intention, it just appears to be confusing.
> (Also the first part would need ammending to mention uri reference
lets
> in #xxxx as well as relative URI.)

I propose that we stay with the existing proposed text asis and clear up
any misunderstandings before even starting to consider rewording. The
purpose of the phrasing above is to clarify that these properties are a
function of the URI space and not of any particular URI. As questions
about this have been brought up in this very thread, I think this is
relevant.

>> An application is also responsible for ensuring that
>> relative identifiers are not treated as unique identifiers across
>> contexts as ignorance of context can make distinct identifiers appear
>> undifferentiated.]]]
>
> which application is this, the one generating the document or the one
> reading it?

For reading. It doesn't make sense to define (generate) a relative URI
without a context - that's the reason why you never see relative URIs
printed on busses and space shuttles. There are certain sanity rules for
applications generating relative links such as updating relative links
when performing a save-as or cut&paste operation where the context
change may affect the relative URIs. However, there is no way that we
can know what the author of the document ultimately had in mind so it
can only be for how to interpret it.

> If the latter, and it comes across a relative URI
> namespace name that it decides breaks this rule?

A relative URI can never break any rule by itself - it might be taken
out of the context in which it was defined but that is not a property of
the relative URI itself.

> How does it "ensure" the relative URI is not treated inappropriately?
>
>  by making the effective namespace name absolute according to the
current base?
>  by raising a fatal error and not processing the document?
>  either, depending on the application?
>  something else entirely?

An application interpreting a document knows what it uses the namespace
identifiers for. Typical examples include

    ignore them
    use them for identification
    use them for comparison
    use them for retrieval

The point of the proposal is to make it clear that whatever the
interpreting application uses the namespace identifiers for, it better
know the semantics of that usage. You can paraphrase this as: "An
application is responsible for knowing what it is doing. Using relative
URIs requires that the application respects the context within which the
relative URI is defined."

It so happens that an application interpreting a single document at a
time - even with literal interpretation of the identifiers - is on safe
ground wrt identification and comparison because it is within the same
context (not taking into account xml base but that it not relevant
here).

As Simon St.Laurent pointed out, this "... doesn't bar the use of
relative URIs, nor does it force _parsers_ to deal with them."

Henrik Frystyk Nielsen,
mailto:frystyk@microsoft.com

Received on Saturday, 10 June 2000 13:42:50 UTC