Begin isolating Redland API use.

1 files changed, 178 insertions, 176 deletions

diff --git a/lv2specgen/lv2specgen.py b/lv2specgen/lv2specgen.py
index 0bbc6d0..ad1ab9e 100755
--- a/lv2specgen/lv2specgen.py
+++ b/lv2specgen/lv2specgen.py
@@ -87,6 +87,31 @@ foaf = RDF.NS('http://xmlns.com/foaf/0.1/')
 doc_base = '.'
 
 
+def findStatements(model, s, p, o):
+    return model.find_statements(RDF.Statement(s, p, o))
+
+
+def isEnd(s):
+    return not s.current()
+
+
+def findOne(m, s, p, o):
+    l = findStatements(m, s, p, o)
+    return l.current()
+
+
+def getSubject(s):
+    return s.subject
+
+
+def getPredicate(s):
+    return s.predicate
+
+
+def getObject(s):
+    return s.object
+
+
 def niceName(uri):
     regexp = re.compile("^(.*[/#])([^/#]+)$")
     rez = regexp.search(uri)
@@ -105,21 +130,17 @@ def return_name(m, urinode):
 
 
 def getLabel(m, urinode):
-    if (type(urinode) == str):
-        urinode = RDF.Uri(urinode)
-    l = m.find_statements(RDF.Statement(urinode, rdfs.label, None))
-    if l.current():
-        return l.current().object.literal_value['string']
+    l = findOne(m, urinode, rdfs.label, None)
+    if l:
+        return getObject(l).literal_value['string']
     else:
         return ''
 
 
 def getComment(m, urinode):
-    if (type(urinode) == str):
-        urinode = RDF.Uri(urinode)
-    c = m.find_statements(RDF.Statement(urinode, lv2.documentation, None))
-    if c.current():
-        markup = c.current().object.literal_value['string']
+    c = findOne(m, urinode, lv2.documentation, None)
+    if c:
+        markup = getObject(c).literal_value['string']
 
         rgx = re.compile('([^a-zA-Z0-9_:])(' + \
                              '|'.join(map(re.escape, linkmap)) + \
@@ -130,9 +151,9 @@ def getComment(m, urinode):
 
         return rgx.sub(translate, markup)
 
-    c = m.find_statements(RDF.Statement(urinode, rdfs.comment, None))
-    if c.current():
-        text = c.current().object.literal_value['string']
+    c = findOne(m, urinode, rdfs.comment, None)
+    if c:
+        text = getObject(c).literal_value['string']
         return xml.sax.saxutils.escape(text)
 
     return ''
@@ -155,9 +176,9 @@ def endProperties(first):
 
 
 def owlVersionInfo(m):
-    v = m.find_statements(RDF.Statement(None, owl.versionInfo, None))
-    if v.current():
-        return v.current().object.literal_value['string']
+    v = findOne(m, None, owl.versionInfo, None)
+    if v:
+        return getObject(v).literal_value['string']
     else:
         return ""
 
@@ -171,22 +192,22 @@ def rdfsPropertyInfo(term, m):
     domain = ""
 
     # Find subPropertyOf information
-    o = m.find_statements(RDF.Statement(term, rdfs.subPropertyOf, None))
-    if o.current():
+    o = findStatements(m, term, rdfs.subPropertyOf, None)
+    if not isEnd(o):
         rlist = ''
         first = True
         for st in o:
-            k = getTermLink(str(st.object.uri), term, rdfs.subPropertyOf)
+            k = getTermLink(str(getObject(st).uri), term, rdfs.subPropertyOf)
             rlist += getProperty(k, first)
             first = False
         doc += "<tr><th>Sub-property of</th>%s" % rlist
 
     # Domain stuff
-    domains = m.find_statements(RDF.Statement(term, rdfs.domain, None))
+    domains = findStatements(m, term, rdfs.domain, None)
     domainsdoc = ""
     for d in domains:
-        collection = m.find_statements(RDF.Statement(d.object, owl.unionOf, None))
-        if collection.current():
+        collection = findStatements(m, getObject(d), owl.unionOf, None)
+        if not isEnd(collection):
             uris = parseCollection(m, collection)
             first = True
             for uri in uris:
@@ -194,17 +215,17 @@ def rdfsPropertyInfo(term, m):
                 add(classdomains, uri, term.uri)
                 first = False
         else:
-            if not d.object.is_blank():
-                domainsdoc += getProperty(getTermLink(str(d.object.uri), term, rdfs.domain))
+            if not getObject(d).is_blank():
+                domainsdoc += getProperty(getTermLink(str(getObject(d).uri), term, rdfs.domain))
     if (len(domainsdoc) > 0):
         doc += "<tr><th>Domain</th>%s" % domainsdoc
 
     # Range stuff
-    ranges = m.find_statements(RDF.Statement(term, rdfs.range, None))
+    ranges = findStatements(m, term, rdfs.range, None)
     rangesdoc = ""
     for r in ranges:
-        collection = m.find_statements(RDF.Statement(r.object, owl.unionOf, None))
-        if collection.current():
+        collection = findStatements(m, getObject(r), owl.unionOf, None)
+        if not isEnd(collection):
             uris = parseCollection(m, collection)
             first = True
             for uri in uris:
@@ -212,8 +233,8 @@ def rdfsPropertyInfo(term, m):
                 add(classranges, uri, term.uri)
                 first = False
         else:
-            if not r.object.is_blank():
-                rangesdoc += getProperty(getTermLink(str(r.object.uri), term, rdfs.range))
+            if not getObject(r).is_blank():
+                rangesdoc += getProperty(getTermLink(str(getObject(r).uri), term, rdfs.range))
     if (len(rangesdoc) > 0):
         doc += "<tr><th>Range</th>%s" % rangesdoc
 
@@ -222,15 +243,15 @@ def rdfsPropertyInfo(term, m):
 
 def parseCollection(model, collection):
     uris = []
-    rdflist = model.find_statements(RDF.Statement(collection.current().object, None, None))
-    while rdflist and rdflist.current() and not rdflist.current().object.is_blank():
+    rdflist = findStatements(model, collection.current().object, None, None)
+    while (not isEnd(rdflist)) and (not rdflist.current().object.is_blank()):
         one = rdflist.current()
         if not one.object.is_blank():
             uris.append(str(one.object.uri))
         rdflist.next()
         one = rdflist.current()
-        if one.predicate == rdf.rest:
-            rdflist = model.find_statements(RDF.Statement(one.object, None, None))
+        if getPredicate(one) == rdf.rest:
+            rdflist = findStatements(model, one.object, None, None)
 
     return uris
 
@@ -253,60 +274,58 @@ def rdfsClassInfo(term, m):
     doc = ""
 
     # Find subClassOf information
-    o = m.find_statements(RDF.Statement(term, rdfs.subClassOf, None))
     restrictions = []
-    if o.current():
-        superclasses = []
-        for st in o:
-            if not st.object.is_blank():
-                uri = str(st.object.uri)
-                if (not uri in superclasses):
-                    superclasses.append(uri)
-            else:
-                meta_types = m.find_statements(RDF.Statement(o.current().object, rdf.type, None))
-                restrictions.append(meta_types.current().subject)
-
-        if len(superclasses) > 0:
-            doc += "\n<tr><th>Sub-class of</th>"
-            first = True
-            for superclass in superclasses:
-                doc += getProperty(getTermLink(superclass), first)
-                first = False
+    superclasses = []
+    for st in findStatements(m, term, rdfs.subClassOf, None):
+        if not getObject(st).is_blank():
+            uri = str(getObject(st).uri)
+            if (not uri in superclasses):
+                superclasses.append(uri)
+        else:
+            meta_type = findOne(m, getObject(st), rdf.type, None)
+            restrictions.append(getSubject(meta_type))
+            
+    if len(superclasses) > 0:
+        doc += "\n<tr><th>Sub-class of</th>"
+        first = True
+        for superclass in superclasses:
+            doc += getProperty(getTermLink(superclass), first)
+            first = False
 
     for r in restrictions:
-        props = m.find_statements(RDF.Statement(r, None, None))
+        props = findStatements(m, r, None, None)
         onProp = None
         comment = None
         for p in props:
-            if p.predicate == owl.onProperty:
-                onProp = p.object
-            elif p.predicate == rdfs.comment:
-                comment = p.object
+            if getPredicate(p) == owl.onProperty:
+                onProp = getObject(p)
+            elif getPredicate(p) == rdfs.comment:
+                comment = getObject(p)
         if onProp != None:
             doc += '<tr><th>Restriction on %s</th><td>' % getTermLink(onProp.uri)
 
             prop_str = ''
             last_pred = None
             first = True
-            for p in m.find_statements(RDF.Statement(r, None, None)):
-                if (p.predicate == owl.onProperty
-                    or p.predicate == rdfs.comment
-                    or (p.predicate == rdf.type and p.object == owl.Restriction)
-                    or p.predicate == lv2.documentation):
+            for p in findStatements(m, r, None, None):
+                if (getPredicate(p) == owl.onProperty
+                    or getPredicate(p) == rdfs.comment
+                    or (getPredicate(p) == rdf.type and getObject(p) == owl.Restriction)
+                    or getPredicate(p) == lv2.documentation):
                     last_pred = None
                     continue
 
-                if p.predicate != last_pred:
-                    prop_str += '<tr><th>%s</th>\n' % getTermLink(str(p.predicate.uri))
+                if getPredicate(p) != last_pred:
+                    prop_str += '<tr><th>%s</th>\n' % getTermLink(str(getPredicate(p).uri))
                     first = True
-                if p.object.is_resource():
-                    prop_str += getProperty(getTermLink(p.object.uri), first)
+                if getObject(p).is_resource():
+                    prop_str += getProperty(getTermLink(getObject(p).uri), first)
                     first = False
-                elif p.object.is_literal():
-                    prop_str += getProperty(p.object.literal_value['string'], first)
+                elif getObject(p).is_literal():
+                    prop_str += getProperty(getObject(p).literal_value['string'], first)
                     first = False
 
-                last_pred = p.predicate
+                last_pred = getPredicate(p)
 
             prop_str += endProperties(first)
 
@@ -345,21 +364,21 @@ def isSpecial(pred):
 
 
 def blankNodeDesc(node, m):
-    properties = m.find_statements(RDF.Statement(node, None, None))
+    properties = findStatements(m, node, None, None)
     doc = ''
     last_pred = ''
     for p in properties:
-        if isSpecial(p.predicate):
+        if isSpecial(getPredicate(p)):
             continue
         doc += '<tr>'
-        doc += '<td class="blankterm">%s</td>\n' % getTermLink(str(p.predicate.uri))
-        if p.object.is_resource():
-            doc += '<td class="blankdef">%s</td>\n' % getTermLink(str(p.object.uri))
-            # getTermLink(str(p.object.uri), node, p.predicate)
-        elif p.object.is_literal():
-            doc += '<td class="blankdef">%s</td>\n' % str(p.object.literal_value['string'])
-        elif p.object.is_blank():
-            doc += '<td class="blankdef">' + blankNodeDesc(p.object, m) + '</td>\n'
+        doc += '<td class="blankterm">%s</td>\n' % getTermLink(str(getPredicate(p).uri))
+        if getObject(p).is_resource():
+            doc += '<td class="blankdef">%s</td>\n' % getTermLink(str(getObject(p).uri))
+            # getTermLink(str(getObject(p).uri), node, getPredicate(p))
+        elif getObject(p).is_literal():
+            doc += '<td class="blankdef">%s</td>\n' % str(getObject(p).literal_value['string'])
+        elif getObject(p).is_blank():
+            doc += '<td class="blankdef">' + blankNodeDesc(getObject(p), m) + '</td>\n'
         else:
             doc += '<td class="blankdef">?</td>\n'
         doc += '</tr>'
@@ -371,26 +390,26 @@ def blankNodeDesc(node, m):
 def extraInfo(term, m):
     """Generate information about misc. properties of a term"""
     doc = ""
-    properties = m.find_statements(RDF.Statement(term, None, None))
+    properties = findStatements(m, term, None, None)
     last_pred = None
     first = True
     for p in properties:
-        if isSpecial(p.predicate):
+        if isSpecial(getPredicate(p)):
             last_pred = None
             continue
-        if p.predicate != last_pred:
-            doc += '<tr><th>%s</th>\n' % getTermLink(str(p.predicate.uri))
+        if getPredicate(p) != last_pred:
+            doc += '<tr><th>%s</th>\n' % getTermLink(str(getPredicate(p).uri))
             first = True
-        if p.object.is_resource():
-            doc += getProperty(getTermLink(str(p.object.uri), term, p.predicate), first)
-        elif p.object.is_literal():
-            doc += getProperty(str(p.object), first)
-        elif p.object.is_blank():
-            doc += getProperty(str(blankNodeDesc(p.object, m)), first)
+        if getObject(p).is_resource():
+            doc += getProperty(getTermLink(str(getObject(p).uri), term, getPredicate(p)), first)
+        elif getObject(p).is_literal():
+            doc += getProperty(str(getObject(p)), first)
+        elif getObject(p).is_blank():
+            doc += getProperty(str(blankNodeDesc(getObject(p), m)), first)
         else:
             doc += getProperty('?', first)
         first = False
-        last_pred = p.predicate
+        last_pred = getPredicate(p)
 
     #doc += endProperties(first)
 
@@ -401,17 +420,16 @@ def rdfsInstanceInfo(term, m):
     """Generate rdfs-type information for instances"""
     doc = ""
 
-    t = m.find_statements(RDF.Statement(term, rdf.type, None))
-    if t.current():
+    t = findStatements(m, term, rdf.type, None)
+    if not isEnd(t):
         doc += "<tr><th>Type</th>"
     first = True
-    while t.current():
-        doc += getProperty(getTermLink(RDF.Node(t.current().object),
+    for match in t:
+        doc += getProperty(getTermLink(getObject(match),
                                        term,
                                        rdf.type),
                            first)
         first = False
-        t.next()
 
     doc += endProperties(first)
     doc += extraInfo(term, m)
@@ -420,22 +438,22 @@ def rdfsInstanceInfo(term, m):
 
 
 def owlInfo(term, m):
-    """Returns an extra information that is defined about a term (an RDF.Node()) using OWL."""
+    """Returns an extra information that is defined about a term using OWL."""
     res = ''
 
     # Inverse properties ( owl:inverseOf )
-    o = m.find_statements(RDF.Statement(term, owl.inverseOf, None))
-    if o.current():
+    o = findStatements(m, term, owl.inverseOf, None)
+    if not isEnd(o):
         res += "<tr><th>Inverse:</th>\n"
         first = True
         for st in o:
-            res += getProperty(getTermLink(str(st.object.uri)), first)
+            res += getProperty(getTermLink(str(getObject(st).uri)), first)
             first = False
         res += endProperties(first)
 
     def owlTypeInfo(term, propertyType, name):
-        o = m.find_statements(RDF.Statement(term, rdf.type, propertyType))
-        if o.current():
+        o = findStatements(m, term, rdf.type, propertyType)
+        if not isEnd(o):
             return "<tr><th>OWL Type</th><td>%s</td></tr>\n" % name
         else:
             return ""
@@ -551,7 +569,7 @@ def buildIndex(m, classlist, proplist, instalist=None):
         for c in classlist:
             if c in shown:
                 continue
-            if m.find_statements(RDF.Statement(c, rdfs.subClassOf, None)).current():
+            if not isEnd(findStatements(m, c, rdfs.subClassOf, None)):
                 continue
             shown[c] = True
             name = return_name(m, c)
@@ -561,13 +579,13 @@ def buildIndex(m, classlist, proplist, instalist=None):
             def class_tree(c):
                 tree = ''
                 shown[c] = True
-                statements = m.find_statements(RDF.Statement(None, rdfs.subClassOf, c))
-                if statements.current():
+                statements = findStatements(m, None, rdfs.subClassOf, c)
+                if not isEnd(statements):
                     tree += '<ul>'
                     for s in statements:
-                        s_name = return_name(m, s.subject)
+                        s_name = return_name(m, getSubject(s))
                         tree += '<li><a href="#%s">%s</a>\n' % (s_name, s_name)
-                        tree += class_tree(s.subject)
+                        tree += class_tree(getSubject(s))
                         tree += '</li>'
                     tree += '</ul>'
                 return tree
@@ -617,31 +635,19 @@ def specInformation(m, ns):
     classtypes = [rdfs.Class, owl.Class]
     classlist = []
     for onetype in classtypes:
-        for classStatement in m.find_statements(RDF.Statement(None,
-                                                              rdf.type,
-                                                              onetype)):
-            for range in m.find_statements(RDF.Statement(None,
-                                                         rdfs.range,
-                                                         classStatement.subject)):
-                if not m.contains_statement(RDF.Statement(range.subject,
-                                                          rdf.type,
-                                                          owl.DeprecatedProperty)):
-                    if not classStatement.subject.is_blank():
-                        add(classranges,
-                            str(classStatement.subject.uri),
-                            str(range.subject.uri))
-            for domain in m.find_statements(RDF.Statement(None,
-                                                          rdfs.domain,
-                                                          classStatement.subject)):
-                if not m.contains_statement(RDF.Statement(domain.subject,
-                                                          rdf.type,
-                                                          owl.DeprecatedProperty)):
-                    if not classStatement.subject.is_blank():
-                        add(classdomains,
-                            str(classStatement.subject.uri),
-                            str(domain.subject.uri))
-            if not classStatement.subject.is_blank():
-                klass = classStatement.subject
+        for classStatement in findStatements(m, None, rdf.type, onetype):
+            for range in findStatements(m, None, rdfs.range, getSubject(classStatement)):
+                if not getSubject(classStatement).is_blank():
+                    add(classranges,
+                        str(getSubject(classStatement).uri),
+                        str(getSubject(range).uri))
+            for domain in findStatements(m, None, rdfs.domain, getSubject(classStatement)):
+                if not getSubject(classStatement).is_blank():
+                    add(classdomains,
+                        str(getSubject(classStatement).uri),
+                        str(getSubject(domain).uri))
+            if not getSubject(classStatement).is_blank():
+                klass = getSubject(classStatement)
                 if klass not in classlist and str(klass).startswith(ns):
                     classlist.append(klass)
 
@@ -649,8 +655,8 @@ def specInformation(m, ns):
     proptypes = [rdf.Property, owl.ObjectProperty, owl.DatatypeProperty, owl.AnnotationProperty]
     proplist = []
     for onetype in proptypes:
-        for propertyStatement in m.find_statements(RDF.Statement(None, rdf.type, onetype)):
-            prop = propertyStatement.subject
+        for propertyStatement in findStatements(m, None, rdf.type, onetype):
+            prop = getSubject(propertyStatement)
             if prop not in proplist and str(prop).startswith(ns):
                 proplist.append(prop)
 
@@ -659,32 +665,32 @@ def specInformation(m, ns):
 
 def specProperty(m, subject, predicate):
     "Return a property of the spec."
-    for c in m.find_statements(RDF.Statement(None, predicate, None)):
-        if c.subject.is_resource() and str(c.subject.uri) == str(subject):
-            return c.object.literal_value['string']
+    for c in findStatements(m, None, predicate, None):
+        if getSubject(c).is_resource() and str(getSubject(c).uri) == str(subject):
+            return getObject(c).literal_value['string']
     return ''
 
 
 def specProperties(m, subject, predicate):
     "Return a property of the spec."
     properties = []
-    for c in m.find_statements(RDF.Statement(None, predicate, None)):
-        if c.subject.is_resource() and str(c.subject.uri) == str(subject):
-            properties += [c.object]
+    for c in findStatements(m, None, predicate, None):
+        if getSubject(c).is_resource() and str(getSubject(c).uri) == str(subject):
+            properties += [getObject(c)]
     return properties
 
 
 def specAuthors(m, subject):
     "Return an HTML description of the authors of the spec."
     dev = set()
-    for i in m.find_statements(RDF.Statement(None, doap.developer, None)):
-        for j in m.find_statements(RDF.Statement(i.object, foaf.name, None)):
-            dev.add(j.object.literal_value['string'])
+    for i in findStatements(m, None, doap.developer, None):
+        for j in findStatements(m, getObject(i), foaf.name, None):
+            dev.add(getObject(j).literal_value['string'])
 
     maint = set()
-    for i in m.find_statements(RDF.Statement(None, doap.maintainer, None)):
-        for j in m.find_statements(RDF.Statement(i.object, foaf.name, None)):
-            maint.add(j.object.literal_value['string'])
+    for i in findStatements(m, None, doap.maintainer, None):
+        for j in findStatements(m, getObject(i), foaf.name, None):
+            maint.add(getObject(j).literal_value['string'])
 
     doc = ''
     first = True
@@ -716,24 +722,24 @@ def specVersion(m, subject):
     # Get the date from the latest doap release
     latest_doap_revision = ""
     latest_doap_release = None
-    for i in m.find_statements(RDF.Statement(None, doap.release, None)):
-        for j in m.find_statements(RDF.Statement(i.object, doap.revision, None)):
-            revision = j.object.literal_value['string']
+    for i in findStatements(m, None, doap.release, None):
+        for j in findStatements(m, getObject(i), doap.revision, None):
+            revision = getObject(j).literal_value['string']
             if latest_doap_revision == "" or revision > latest_doap_revision:
                 latest_doap_revision = revision
-                latest_doap_release = i.object
+                latest_doap_release = getObject(i)
     date = ""
     if latest_doap_release != None:
-        for i in m.find_statements(RDF.Statement(latest_doap_release, doap.created, None)):
-            date = i.object.literal_value['string']
+        for i in findStatements(m, latest_doap_release, doap.created, None):
+            date = getObject(i).literal_value['string']
 
     # Get the LV2 version
     minor_version = 0
     micro_version = 0
-    for i in m.find_statements(RDF.Statement(None, lv2.minorVersion, None)):
-        minor_version = int(i.object.literal_value['string'])
-    for i in m.find_statements(RDF.Statement(None, lv2.microVersion, None)):
-        micro_version = int(i.object.literal_value['string'])
+    for i in findStatements(m, None, lv2.minorVersion, None):
+        minor_version = int(getObject(i).literal_value['string'])
+    for i in findStatements(m, None, lv2.microVersion, None):
+        micro_version = int(getObject(i).literal_value['string'])
     return (minor_version, micro_version, date)
 
 
@@ -744,21 +750,21 @@ def getInstances(model, classes, properties):
     """
     instances = []
     for c in classes:
-        for i in model.find_statements(RDF.Statement(None, rdf.type, c)):
-            if not i.subject.is_resource():
+        for i in findStatements(model, None, rdf.type, c):
+            if not getSubject(i).is_resource():
                 continue
-            inst = i.subject
+            inst = getSubject(i)
             if inst not in instances and str(inst) != spec_url:
                 instances.append(inst)
-    for i in model.find_statements(RDF.Statement(None, rdf.type, None)):
-        if ((not i.subject.is_resource())
-            or (i.subject in classes)
-            or (i.subject in instances)
-            or (i.subject in properties)):
+    for i in findStatements(model, None, rdf.type, None):
+        if ((not getSubject(i).is_resource())
+            or (getSubject(i) in classes)
+            or (getSubject(i) in instances)
+            or (getSubject(i) in properties)):
             continue
-        full_uri = str(i.subject.uri)
+        full_uri = str(getSubject(i).uri)
         if (full_uri.startswith(spec_ns_str)):
-            instances.append(i.subject)
+            instances.append(getSubject(i))
     return instances
 
 
@@ -791,13 +797,10 @@ def specgen(specloc, docdir, template, doclinks, instances=False, mode="spec"):
         p = RDF.Parser(name="guess")
         p.parse_into_model(m, specloc)
 
-    except IOError:
-        e = sys.exc_info()[1]
-        print('Error reading from ontology:' + str(e))
-        usage()
-    except RDF.RedlandError:
+    except:
         e = sys.exc_info()[1]
-        print('Error parsing the ontology')
+        print('Error reading ontology: ' + str(e))
+        return None
 
     spec_url = getOntologyNS(m)
 
@@ -914,7 +917,7 @@ def specgen(specloc, docdir, template, doclinks, instances=False, mode="spec"):
 
     template = template.replace('@FILES@', other_files)
 
-    comment = getComment(m, spec_url)
+    comment = getComment(m, RDF.Uri(spec_url))
     if comment != '':
         template = template.replace('@COMMENT@', comment)
     else:
@@ -953,11 +956,10 @@ def getNamespaces(parser):
 
 def getOntologyNS(m):
     ns = None
-    o = m.find_statements(RDF.Statement(None, rdf.type, lv2.Specification))
-    if o.current():
-        s = o.current().subject
-        if (not s.is_blank()):
-            ns = str(s.uri)
+    s = findOne(m, None, rdf.type, lv2.Specification)
+    if s:
+        if (not getSubject(s).is_blank()):
+            ns = str(getSubject(s).uri)
 
     if (ns == None):
         sys.exit("Impossible to get ontology's namespace")