PubbyIRIEscaper Class Reference

IRI rewriter that implements special behaviour for Pubby: Any IRI within a certain namespace (the namespace that Pubby is serving) will have characters that interfer with IRI derferencing %-escaped. More...

Inheritance diagram for PubbyIRIEscaper:

Collaboration diagram for PubbyIRIEscaper:

Public Member Functions
	PubbyIRIEscaper (String namespace, boolean encodeURIsToIRIs)
String	rewrite (String absoluteIRI)
	Rewrites an IRI. More...
String	unrewrite (String absoluteIRI)
	Rewrites an IRI. More...
Property	rewrite (Property original)
Resource	rewrite (Resource original)
Model	rewrite (Model original)
	Rewrites the RDF graph in a Jena model by returning a new in-memory model that contains all statements from the original with any IRIs rewritten. More...
Map< Property, Integer >	rewrite (Map< Property, Integer > original)
Property	unrewrite (Property rewritten)
Resource	unrewrite (Resource rewritten)

Static Public Member Functions
static String	escapeSpecialCharacters (String absoluteIRI)
	Escapes any characters that have special meaning in IRIs so that they are safe for use in a Pubby path. More...
static String	unescapeSpecialCharacters (String absoluteIRI)
	Reverses the escaping done by unescapeSpecialCharacters(String). More...
static IRIRewriter	createNamespaceBased (final String originalNamespace, final String rewrittenNamespace)
	Creates a new rewriter that rewrites all IRIs starting with a given namespace by replacing that namespace with another namespace. More...
static IRIRewriter	chain (final IRIRewriter rewriter1, final IRIRewriter rewriter2)
	Creates an IRIRewriter that applies two existing IRIRewriters. More...

Static Public Attributes
static final IRIRewriter	identity
	The trivial IRI rewriter that returns IRIs unmodified. More...

Private Attributes
final boolean	encodeURIsToIRIs

Detailed Description

IRI rewriter that implements special behaviour for Pubby: Any IRI within a certain namespace (the namespace that Pubby is serving) will have characters that interfer with IRI derferencing %-escaped.

Any IRI outside that namespace is left alone. The escaped characters are '#' and '?'.

This rewriter can also encode URIs to IRIs as part of the rewriting process. Pubby always wants to work on IRIs. Most data sources use IRIs. Some don't, and all characters outside US-ASCII appear %-encoded in their IRIs. If configured to encode URIs to IRIs, then in the rewritten identifiers we will see proper Unicode characters instead of %-encoded sequences. Note that we do this only within the namespace.

TODO: The URI-to-IRI rewriting should probably be a separate class.

Constructor & Destructor Documentation

PubbyIRIEscaper()

PubbyIRIEscaper	(	String	namespace,
		boolean	encodeURIsToIRIs
	)

                                                                           {
                this.namespace = namespace;
                this.encodeURIsToIRIs = encodeURIsToIRIs;
        }

References PubbyIRIEscaper.encodeURIsToIRIs.

Member Function Documentation

chain()

static IRIRewriter chain ( final IRIRewriter  rewriter1, final IRIRewriter  rewriter2  )

staticinherited

Creates an IRIRewriter that applies two existing IRIRewriters.

                                                     {
                if (rewriter1 == identity) return rewriter2;
                if (rewriter2 == identity) return rewriter1;
                return new IRIRewriter() {
                        @Override
                        public String rewrite(String absoluteIRI) {
                                return rewriter2.rewrite(rewriter1.rewrite(absoluteIRI));
                        }
                        @Override
                        public String unrewrite(String absoluteIRI) {
                                return rewriter1.unrewrite(rewriter2.unrewrite(absoluteIRI));
                        }
                };
        }

References IRIRewriter.identity, IRIRewriter.rewrite(), and IRIRewriter.unrewrite().

Referenced by Dataset.buildDataSource().

createNamespaceBased()

static IRIRewriter createNamespaceBased ( final String  originalNamespace, final String  rewrittenNamespace  )

staticinherited

Creates a new rewriter that rewrites all IRIs starting with a given namespace by replacing that namespace with another namespace.

Any IRIs that don't start with theat namespace are returned unchanged. For example, if original namespace is https://example.com/ and replacement namespace is http://localhost:8080/, then the IRI https://example.com/foo/bar will be rewritten to http://localhost:8080/foo/bar, and the IRI https://foo.example.org/bar will be rewritten to itself as it doesn't start with the original namespace.

Parameters

originalNamespace	The namespace to be replaced
rewrittenNamespace	The replacement namespace

Returns

                                                                                         {
                if (originalNamespace.equals(rewrittenNamespace)) {
                        return identity;
                }
                if (originalNamespace.startsWith(rewrittenNamespace) ||
                                rewrittenNamespace.startsWith(originalNamespace)) {
                        throw new IllegalArgumentException(
                                        "Cannot rewrite overlapping namespaces, " + 
                                        "this would be ambiguous: " + originalNamespace + 
                                        " => " + rewrittenNamespace);
                }
                return new IRIRewriter() {
                        @Override
                        public String rewrite(String absoluteIRI) {
                                if (absoluteIRI.startsWith(originalNamespace)) {
                                        return rewrittenNamespace + absoluteIRI.substring(
                                                        originalNamespace.length());
                                }
                                if (absoluteIRI.startsWith(rewrittenNamespace)) {
                                        throw new IllegalArgumentException(
                                                        "Can't rewrite already rewritten IRI: " + absoluteIRI);
                                }
                                return absoluteIRI;
                        }
                        @Override
                        public String unrewrite(String absoluteIRI) {
                                if (absoluteIRI.startsWith(rewrittenNamespace)) {
                                        return originalNamespace + absoluteIRI.substring(
                                                        rewrittenNamespace.length());
                                }
                                if (absoluteIRI.startsWith(originalNamespace)) {
                                        throw new IllegalArgumentException(
                                                        "Can't unrewrite IRI that already is in the original namespace: " + absoluteIRI);
                                }
                                return absoluteIRI;
                        }
                };
        }

References IRIRewriter.identity, IRIRewriter.rewrite(), and IRIRewriter.unrewrite().

Referenced by Dataset.buildDataSource().

escapeSpecialCharacters()

static String escapeSpecialCharacters ( String  absoluteIRI )

static

Escapes any characters that have special meaning in IRIs so that they are safe for use in a Pubby path.

                                                                         {
                return absoluteIRI.replace("#", "%23").replace("?", "%3F");             
        }

Referenced by HypermediaControls.getPathURL(), HypermediaControls.getPubbyPath(), and PubbyIRIEscaper.rewrite().

rewrite() [1/5]

Map<Property, Integer> rewrite ( Map< Property, Integer >  original )

inherited

                                                                               {
                if (original == null) return null;
                Map<Property, Integer> result = new HashMap<Property, Integer>();
                for (Property p: original.keySet()) {
                        result.put(rewrite(p), original.get(p));
                }
                return result;
        }

References IRIRewriter.rewrite().

rewrite() [2/5]

Model rewrite ( Model  original )

inherited

Rewrites the RDF graph in a Jena model by returning a new in-memory model that contains all statements from the original with any IRIs rewritten.

It rewrites IRIs in subject, predicate, and object position. Also rewrites the namespace prefix mappings, if any are present.

Parameters

original

An RDF graph in Jena model form

Returns

Rewritten version of the graph

                                             {
                Model result = ModelFactory.createDefaultModel();
                for (String prefix: original.getNsPrefixMap().keySet()) {
                        String uri = original.getNsPrefixURI(prefix);
                        result.setNsPrefix(prefix, rewrite(uri));
                }
                StmtIterator it = original.listStatements();
                while (it.hasNext()) {
                        Statement stmt = it.nextStatement();
                        Resource s = stmt.getSubject();
                        if (s.isURIResource()) {
                                s = result.createResource(rewrite(s.getURI()));
                        }
                        Property p = result.createProperty(
                                        rewrite(stmt.getPredicate().getURI()));
                        RDFNode o = stmt.getObject();
                        if (o.isURIResource()) {
                                o = result.createResource(rewrite(o.asResource().getURI()));
                        }
                        result.add(s, p, o);
                }
                return result;
        }

References IRIRewriter.rewrite().

rewrite() [3/5]

Property rewrite ( Property  original )

inherited

                                                   {
                String rewritten = rewrite(original.getURI());
                if (rewritten.equals(original.getURI())) {
                        return original;
                }
                return ResourceFactory.createProperty(rewritten);
        }

References IRIRewriter.rewrite().

rewrite() [4/5]

Resource rewrite ( Resource  original )

inherited

                                                   {
                String rewritten = rewrite(original.getURI());
                if (rewritten.equals(original.getURI())) {
                        return original;
                }
                return ResourceFactory.createResource(rewritten);
        }

References IRIRewriter.rewrite().

rewrite() [5/5]

String rewrite

(

String

absoluteIRI

)

Rewrites an IRI.

Parameters

Any	absolute IRI

Returns

The rewritten form of the IRI

Reimplemented from IRIRewriter.

                                                  {
                if (absoluteIRI.startsWith(namespace)) {
                        if (encodeURIsToIRIs) {
                                // absoluteIRI is really a URI
                                absoluteIRI = IRIEncoder.toIRI(absoluteIRI);
                        }
                        return escapeSpecialCharacters(absoluteIRI);
                }
                return absoluteIRI;
        }

References PubbyIRIEscaper.encodeURIsToIRIs, PubbyIRIEscaper.escapeSpecialCharacters(), and IRIEncoder.toIRI().

unescapeSpecialCharacters()

static String unescapeSpecialCharacters ( String  absoluteIRI )

static

Reverses the escaping done by unescapeSpecialCharacters(String).

                                                                           {
                return absoluteIRI.replace("%23", "#").replace("%3F", "?");
        }

Referenced by HypermediaControls.createFromPubbyPath(), ValuesBaseServlet.doGet(), and PubbyIRIEscaper.unrewrite().

unrewrite() [1/3]

Property unrewrite ( Property  rewritten )

inherited

                                                      {
                String original = unrewrite(rewritten.getURI());
                if (original.equals(rewritten.getURI())) {
                        return rewritten;
                }
                return ResourceFactory.createProperty(original);
        }

References IRIRewriter.unrewrite().

unrewrite() [2/3]

Resource unrewrite ( Resource  rewritten )

inherited

                                                      {
                String original = unrewrite(rewritten.getURI());
                if (original.equals(rewritten.getURI())) {
                        return rewritten;
                }
                return ResourceFactory.createResource(original);
        }

References IRIRewriter.unrewrite().

unrewrite() [3/3]

String unrewrite

(

String

absoluteIRI

)

Rewrites an IRI.

For any valid IRI,

Parameters

Any	absolute IRI

Returns

The rewritten form of the IRI

Reimplemented from IRIRewriter.

                                                    {
                if (absoluteIRI.startsWith(namespace)) {
                        if (encodeURIsToIRIs) {
                                absoluteIRI = IRIEncoder.toURI(absoluteIRI);
                                // It's now really a URI, not an IRI
                        }
                        return unescapeSpecialCharacters(absoluteIRI);
                }
                return absoluteIRI;
        }

References PubbyIRIEscaper.encodeURIsToIRIs, IRIEncoder.toURI(), and PubbyIRIEscaper.unescapeSpecialCharacters().

Member Data Documentation

encodeURIsToIRIs

final boolean encodeURIsToIRIs

private

Referenced by PubbyIRIEscaper.PubbyIRIEscaper(), PubbyIRIEscaper.rewrite(), and PubbyIRIEscaper.unrewrite().

identity

final IRIRewriter identity

staticinherited

The trivial IRI rewriter that returns IRIs unmodified.

We override all methods for efficiency.

Referenced by Dataset.buildDataSource(), IRIRewriter.chain(), and IRIRewriter.createNamespaceBased().