Streamline LDPR creation.

* Remove method that accepts serialized RDF
* Move RDF parsing to LDP endpoint
* Simplify LdpFactory.from_provided logic
* Check fragment URIs for ref. integrity
* Minor unrelated doc amendments

docs/discovery.rst

@@ -27,7 +27,7 @@ LAKEsuperior both as an API and a Web UI.
 
    LAKEsuperior SPARQL Query Window
 
-The UI is based on `YasGUI <http://yasgui.org/>`__.
+The UI is based on `YASGUI <http://about.yasgui.org/>`__.
 
 Note that:
 
@@ -49,7 +49,7 @@ implementation that it is based upon can be quite efficient for certain
 queries but has some downsides. For example, do **not** attempt the following
 query in a graph with more than a few thousands resources::
 
-    SELECT ?s {
+    SELECT ?p ?o {
       GRAPH ?g {
         <info:fcres/my-uid> ?p ?o .
       }

docs/index.rst

@@ -30,7 +30,7 @@ Indices and tables
    :maxdepth: 3
    :caption: User Reference
 
-    Discovery & query <discovery>
+    Discovery & Query <discovery>
     Divergences from Fedora 4 <fcrepo4_deltas>
     Messaging <messaging>
     Migration Guide <migration>

docs/usage.rst

@@ -132,19 +132,7 @@ Or, to specify an alternative configuration::
 Create and replace resources
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Providing a serialized RDF stream::
-
-    >>> from lakesuperior.api import resource as rsrc_api
-    >>> from io import BytesIO
-    >>> from lakesuperior.dictionaries.namespaces import ns_collection as nsc
-    >>> uid = '/rsrc_from_stream'
-    >>> uri = nsc['fcres'][uid]
-    >>> stream = BytesIO(b'<> a <http://ex.org/type#A> .')
-    >>> rsrc_api.create_or_replace(uid, stream=stream, mimetype='text/turtle')
-    '_create_'
-
-
-Providng a Graph object::
+Create an LDP-RS (RDF reseouce) providng a Graph object::
 
     >>> from rdflib import Graph, URIRef
     >>> uid = '/rsrc_from_graph'
@@ -155,7 +143,7 @@ Providng a Graph object::
 Issuing a ``create_or_replace()`` on an existing UID will replace the existing
 property set with the provided one (PUT style).
 
-Create an LDP-NR::
+Create an LDP-NR (non-RDF source)::
 
     >>> uid = '/test_ldpnr01'
     >>> data = b'Hello. This is some dummy content.'

lakesuperior/endpoints/ldp.py

@@ -11,8 +11,7 @@ import arrow
 from flask import (
         Blueprint, g, make_response, render_template,
         request, send_file)
-from rdflib.namespace import XSD
-from rdflib.term import Literal
+from rdflib import Graph
 
 from lakesuperior.api import resource as rsrc_api
 from lakesuperior.dictionaries.namespaces import ns_collection as nsc
@@ -281,14 +280,15 @@ def put_resource(uid):
         # If the content is RDF, localize in-repo URIs.
         global_rdf = stream.read()
         local_rdf = g.tbox.localize_payload(global_rdf)
-        stream = BytesIO(local_rdf)
-        is_rdf = True
+        graph = Graph().parse(
+                data=local_rdf, format=mimetype, publicID=nsc['fcres'][uid])
+        stream = mimetype = None
     else:
-        is_rdf = False
+        graph = None
 
     try:
         evt = rsrc_api.create_or_replace(uid, stream=stream, mimetype=mimetype,
-                handling=handling, disposition=disposition)
+                graph=graph, handling=handling, disposition=disposition)
     except (InvalidResourceError, ResourceExistsError) as e:
         return str(e), 409
     except (ServerManagedTermError, SingleSubjectError) as e:
@@ -302,7 +302,7 @@ def put_resource(uid):
     if evt == RES_CREATED:
         rsp_code = 201
         rsp_headers['Location'] = rsp_body = uri
-        if mimetype and not is_rdf:
+        if mimetype and not graph:
             rsp_headers['Link'] = (
                     '<{0}/fcr:metadata>; rel="describedby"'.format(uri))
     else:

lakesuperior/model/ldp_factory.py

@@ -78,8 +78,7 @@ class LdpFactory:
 
 
     @staticmethod
-    def from_provided(
-            uid, mimetype=None, stream=None, init_gr=None, **kwargs):
+    def from_provided(uid, mimetype=None, stream=None, graph=None, **kwargs):
         r"""
         Create and LDPR instance from provided data.
 
@@ -87,80 +86,65 @@ class LdpFactory:
         passed.
 
         :param str uid: UID of the resource to be created or updated.
-        :param str mimetype: The provided content MIME type.
-        :param stream: The provided data stream. This can be
-            RDF or non-RDF content, or None. In the latter case, an empty
-            container is created.
-        :type stream: IOStream or None
-        :param rdflib.Graph init_gr: Initial graph to populate the
-            resource with, alternatively to ``stream``. This can be
-            used for LDP-RS and LDP-NR types alike.
+        :param str mimetype: The provided content MIME type. If this is
+            specified the resource is considered a LDP-NR and a ``stream``
+            *must* be provided.
+        :param IOStream stream: The provided data stream.
+        :param rdflib.Graph graph: Initial graph to populate the
+            resource with. This can be used for LDP-RS and LDP-NR types alike.
         :param \*\*kwargs: Arguments passed to the LDP class constructor.
+
+        :raise ValueError: if ``mimetype`` is specified but no data stream is
+            provided.
         """
         uri = nsc['fcres'][uid]
 
-        # If no content or MIME type is passed, create an empty LDPC.
-        if not any((stream, mimetype, init_gr)):
-            logger.info('No data received in request. '
-                    'Creating empty container.')
-            inst = Ldpc(uid, provided_imr=Graph(identifier=uri), **kwargs)
+        provided_imr = Graph(identifier=uri)
+        if graph:
+            provided_imr += graph
+        #logger.debug('Provided graph: {}'.format(
+        #        pformat(set(provided_imr))))
+
+        if stream is None:
+            # Resource is a LDP-RS.
+            if mimetype:
+                raise ValueError(
+                    'Binary stream must be provided if mimetype is specified.')
+
+            # Determine whether it is a basic, direct or indirect container.
+            if Ldpr.MBR_RSRC_URI in provided_imr.predicates() and \
+                    Ldpr.MBR_REL_URI in provided_imr.predicates():
+                if Ldpr.INS_CNT_REL_URI in provided_imr.predicates():
+                    cls = LdpIc
+                else:
+                    cls = LdpDc
+            else:
+                cls = Ldpc
+
+            inst = cls(uid, provided_imr=provided_imr, **kwargs)
 
             # Make sure we are not updating an LDP-NR with an LDP-RS.
             if inst.is_stored and LDP_NR_TYPE in inst.ldp_types:
                 raise IncompatibleLdpTypeError(uid, mimetype)
 
-        # Otherwise, determine LDP type from provided content.
-        else:
-            # If the stream is RDF, or an IMR is provided, create a container
-            # and populate it with provided RDF data.
-            provided_imr = Graph(identifier=uri)
-            # Provided RDF stream overrides provided IMR.
-            if __class__.is_rdf_parsable(mimetype) :
-                provided_imr.parse(
-                        data=stream.read(), format=mimetype, publicID=uri)
-            elif init_gr:
-                provided_imr += init_gr
-            #logger.debug('Provided graph: {}'.format(
-            #        pformat(set(provided_imr))))
-
-            if not mimetype or __class__.is_rdf_parsable(mimetype):
-                # Determine whether it is a basic, direct or indirect
-                # container.
-                if Ldpr.MBR_RSRC_URI in provided_imr.predicates() and \
-                        Ldpr.MBR_REL_URI in provided_imr.predicates():
-                    if Ldpr.INS_CNT_REL_URI in provided_imr.predicates():
-                        cls = LdpIc
-                    else:
-                        cls = LdpDc
-                else:
-                    cls = Ldpc
-
-                inst = cls(uid, provided_imr=provided_imr, **kwargs)
+            if kwargs.get('handling', 'strict') != 'none':
+                inst._check_mgd_terms(inst.provided_imr)
 
-                # Make sure we are not updating an LDP-NR with an LDP-RS.
-                if inst.is_stored and LDP_NR_TYPE in inst.ldp_types:
-                    raise IncompatibleLdpTypeError(uid, mimetype)
-
-                if kwargs.get('handling', 'strict') != 'none':
-                    inst._check_mgd_terms(inst.provided_imr)
+        else:
+            # Resource is a LDP-NR.
+            if not mimetype:
+                mimetype = 'application/octet-stream'
 
-            else:
-                # Create a LDP-NR and equip it with the binary file provided.
-                inst = LdpNr(uid, stream=stream, mimetype=mimetype,
-                        provided_imr=provided_imr, **kwargs)
+            inst = LdpNr(uid, stream=stream, mimetype=mimetype,
+                    provided_imr=provided_imr, **kwargs)
 
-                # Make sure we are not updating an LDP-RS with an LDP-NR.
-                if inst.is_stored and LDP_RS_TYPE in inst.ldp_types:
-                    raise IncompatibleLdpTypeError(uid, mimetype)
+            # Make sure we are not updating an LDP-RS with an LDP-NR.
+            if inst.is_stored and LDP_RS_TYPE in inst.ldp_types:
+                raise IncompatibleLdpTypeError(uid, mimetype)
 
-        logger.info('Creating resource of type: {}'.format(
+        logger.debug('Creating resource of type: {}'.format(
                 inst.__class__.__name__))
 
-        try:
-            types = inst.types
-        except (TombstoneError, ResourceNotExistsError):
-            types = set()
-
         return inst
 
 

lakesuperior/model/ldpr.py

@@ -2,6 +2,7 @@ import logging
 
 from abc import ABCMeta
 from collections import defaultdict
+from urllib.parse import urldefrag
 from uuid import uuid4
 
 import arrow
@@ -641,7 +642,10 @@ class Ldpr(metaclass=ABCMeta):
            Otherwise, the violation is simply logged.
         """
         for o in self.provided_imr.objects():
-            if isinstance(o, URIRef) and str(o).startswith(nsc['fcres']):
+            if(
+                    isinstance(o, URIRef) and
+                    str(o).startswith(nsc['fcres']) and
+                    urldefrag(o).url.rstrip('/') != str(self.uri)):
                 obj_uid = rdfly.uri_to_uid(o)
                 if not rdfly.ask_rsrc_exists(obj_uid):
                     if config == 'strict':

tests/test_resource_api.py

@@ -69,9 +69,9 @@ class TestResourceApi:
             gr = rsrc_api.get('/{}'.format(uuid4()))
 
 
-    def test_create_from_graph(self):
+    def test_create_ldp_rs(self):
         """
-        Create a resource from a provided graph.
+        Create an RDF resource (LDP-RS) from a provided graph.
         """
         uid = '/rsrc_from_graph'
         uri = nsc['fcres'][uid]
@@ -79,7 +79,7 @@ class TestResourceApi:
             data='<> a <http://ex.org/type#A> .', format='turtle',
             publicID=uri)
         #pdb.set_trace()
-        evt = rsrc_api.create_or_replace(uid, init_gr=gr)
+        evt = rsrc_api.create_or_replace(uid, graph=gr)
 
         rsrc = rsrc_api.get(uid)
         assert rsrc.imr[
@@ -88,26 +88,6 @@ class TestResourceApi:
                 rsrc.uri : nsc['rdf'].type : nsc['ldp'].RDFSource]
 
 
-    def test_create_from_rdf_stream(self):
-        """
-        Create a resource from a RDF stream (Turtle).
-
-        This is the same method used by the LDP endpoint.
-        """
-        uid = '/rsrc_from_stream'
-        uri = nsc['fcres'][uid]
-        stream = BytesIO(b'<> a <http://ex.org/type#B> .')
-        #pdb.set_trace()
-        evt = rsrc_api.create_or_replace(
-            uid, stream=stream, mimetype='text/turtle')
-
-        rsrc = rsrc_api.get(uid)
-        assert rsrc.imr[
-                rsrc.uri : nsc['rdf'].type : URIRef('http://ex.org/type#B')]
-        assert rsrc.imr[
-                rsrc.uri : nsc['rdf'].type : nsc['ldp'].RDFSource]
-
-
     def test_create_ldp_nr(self):
         """
         Create a non-RDF resource (LDP-NR).
@@ -127,7 +107,7 @@ class TestResourceApi:
         gr1 = Graph().parse(
             data='<> a <http://ex.org/type#A> .', format='turtle',
             publicID=uri)
-        evt = rsrc_api.create_or_replace(uid, init_gr=gr1)
+        evt = rsrc_api.create_or_replace(uid, graph=gr1)
         assert evt == RES_CREATED
 
         rsrc = rsrc_api.get(uid)
@@ -140,7 +120,7 @@ class TestResourceApi:
             data='<> a <http://ex.org/type#B> .', format='turtle',
             publicID=uri)
         #pdb.set_trace()
-        evt = rsrc_api.create_or_replace(uid, init_gr=gr2)
+        evt = rsrc_api.create_or_replace(uid, graph=gr2)
         assert evt == RES_UPDATED
 
         rsrc = rsrc_api.get(uid)
@@ -165,12 +145,12 @@ class TestResourceApi:
             data='<> a <http://ex.org/type#A> .', format='turtle',
             publicID=nsc['fcres'][uid_rs])
 
-        rsrc_api.create_or_replace(uid_rs, init_gr=gr)
+        rsrc_api.create_or_replace(uid_rs, graph=gr)
         rsrc_api.create_or_replace(
             uid_nr, stream=BytesIO(data), mimetype='text/plain')
 
         with pytest.raises(IncompatibleLdpTypeError):
-            rsrc_api.create_or_replace(uid_nr, init_gr=gr)
+            rsrc_api.create_or_replace(uid_nr, graph=gr)
 
         with pytest.raises(IncompatibleLdpTypeError):
             rsrc_api.create_or_replace(