Make sure empty fragment and no fragment are the same in $schema

[gazpachoking]

My idea for the issue in #73

[Julian]

What's this? Is this to handle a uri of ""? If so then it then turns it into None which is almost certainly not what we want.

[gazpachoking]

Yeah, this was to counter a bug? in urlparse.defrag, when an empty uri was passed in it returned a tuple of empty byte strings rather than unicode strings, which could not be concatenated with the unicode '#'. If it returns '' when the uri given was empty is that better?

[Julian]

It looks like it returns whatever type you pass in, no? I get back unicode for unicode uris and bytes for bytes uris on both Py2 and Py3?

[gazpachoking]

I need to double check. I just know it was crashing on the tests without that conditional.

[Julian]

Other than my comment this is fine as is but maybe we should look into a Reference class if that would give us any benefit. E.g. as-is you can't look up a meta schema URI in the meta-schemas dict without knowing what our canonical way of storing it is.

[gazpachoking]

Maybe we should use urlparse.urlsplit(uri).geturl() to create the canonical form, this also gets us some other normalization, like lower casing the scheme.

[Julian]

Sounds good. Makes me even more likely to think that we need to wrap all this somehow though in a way that users can actually transparently use.

[gazpachoking]

I think I agree, not quite sure how you are thinking to do that though.

[Julian]

Haven't thought it fully through yet, but probably with a combination of a Reference class that normalizes the uri you give it (and normalizes uris that are strs that you compare to it), and having the meta_schemas dict have References for keys (and we can decide whether it should be smarter than that and actually wrap strs that you check it for with References as well, though for our purposes right now I doubt we even need that).

Open for better ideas though.

[gazpachoking]

Hmm, yeah, we should probably use something like this when adding and looking up in the RefResolver store too.

[gazpachoking]

What if we made the metaschema dict, and the RefResolver store into something like this:

class URIDict(dict):
    def normalize(self, uri):
        return urlparse.urlsplit(uri).geturl()

    def __getitem__(self, uri):
        return super(URIDict, self).__getitem__(self.normalize(uri))

    def __setitem__(self, uri, value):
        super(URIDict, self).__setitem__(self.normalize(uri), value)

This isn't quite complete, due to not having init, delitem etc. defined, trying to figure if there is an easier way to do all that than just redefine them all.

[Julian]

Right that was what I meant by

(and we can decide whether it should be smarter than that and actually wrap strs that you check it for with References as well, though for our purposes right now I doubt we even need that)

We'd want to do it using collections.abc.MutableMapping as opposed to subclassing though.

[gazpachoking]

Okay, gotcha. Thought you meant something along those lines. Well, I think it's a good plan, sucks something like this has to redefine all the dict methods though, seems like there should be some way to provide a normalization function and get all this functionality.

[gazpachoking]

What do we gain by using MutableMapping? Seems similar, except for we'd have to have our own dict store within it.

[Julian]

Subclassing built in types is unreliable ( for the same reason subclassing
in general is unreliable) because it relies on knowledge about the
implementation of your superclass. E.g. If you implement getitem to
normalize, what happens if you use .get? Or setitem and .update (it
turns out CPython gets that right now in those 2 specific cases).

So MutableMapping makes sure all of that happens correctly as long as you
implement the interface correctly for all the methods it expects.
On Mar 2, 2013 11:14 PM, "Chase Sterling" notifications@github.com wrote:

What do we gain by using MutableMapping? Seems similar, except for we'd
have to have our own dict store within it.

—
Reply to this email directly or view it on GitHubhttps://github.com//pull/77#issuecomment-14341293
.

[gazpachoking]

Okay, MutableMapping gives us those things? I thought we still had to define all of those methods. I'll look into it.

[gazpachoking]

Ahh, seems it does. Nice, well in that case, I'm all for it, good call. :)

[gazpachoking]

Sucks a little that we need that much code for a simple problem, but is this what you were thinking?

[gazpachoking]

Oh, good call. Seems I need to fix something on python 2.7 too.

[Julian]

Yeah it does a bit. But yeah looks like it. We should probably make it private too (So _URIDict). Otherwise looks good.

[Julian]

Looks like this line is unchanged now.

[gazpachoking]

Okay, think I got everything sorted now.