pius-rena 0.0.1

data/lib/rena/rdfxmlparser.rb

@@ -0,0 +1,182 @@
+require 'rena/uriref'
+require 'rena/graph'
+require 'rena/literal'
+require 'rena/exceptions/uri_relative_exception'
+require 'rena/exceptions/about_each_exception'
+require 'rena/rexml_hacks'
+
+class RdfXmlParser
+  attr_accessor :xml, :graph
+  def initialize (xml_str, uri = nil)
+    @excl = ["http://www.w3.org/1999/02/22-rdf-syntax-ns#resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#nodeID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#about", "http://www.w3.org/1999/02/22-rdf-syntax-ns#ID"]
+    if uri != nil
+      @uri = Addressable::URI.parse(uri)
+    end
+    @xml = REXML::Document.new(xml_str)
+#    self.iterator @xml.root.children
+    if self.is_rdf?
+      @graph = Graph.new
+      @xml.root.each_element { |e|
+        self.parse_element e
+      }
+#      puts @graph.size
+    end
+  end
+  
+  def is_rdf?
+    trigger = false
+    @xml.each_element do |e|
+      if e.namespaces.has_value? "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        trigger = true
+      end
+    end
+    return trigger
+  end
+  
+  protected
+  def get_uri_from_atts (element, aboutmode = false)
+    if aboutmode == false
+      resourceuri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#resource"
+    else
+      resourceuri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#about"
+    end
+    
+    subject = nil
+    element.attributes.each_attribute { |att|
+      uri = att.namespace + att.name
+      value = att.to_s
+      if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEach"
+        raise AboutEachException, "Failed as per RDFMS-AboutEach-Error001.rdf test from 2004 test suite"
+      end
+      if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEachPrefix"
+        raise AboutEachException, "Failed as per RDFMS-AboutEach-Error002.rdf test from 2004 test suite"
+      end
+      if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#bagID"
+        raise
+        if name =~ /^[a-zA-Z_][a-zA-Z0-9]*$/
+          # TODO: do something intelligent with the bagID
+        else
+          raise
+        end
+      end
+      
+      if uri == resourceuri #specified resource
+        begin
+          possible_subject = URIRef.new(value)
+        rescue UriRelativeException
+          if value[0..0].to_s != "#"
+            value = "#" + value
+          end
+          begin
+            value = URIRef.new(element.base + value)
+          rescue UriRelativeException
+            # still not a URI
+            raise
+          else
+            subject = value
+          end
+        else
+          subject = possible_subject
+          break
+        end
+      end
+      
+      if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#nodeID" #BNode with ID
+        # we have a BNode with an identifier. First, we need to do syntax checking.
+        if value =~ /^[a-zA-Z_][a-zA-Z0-9]*$/
+          # now we check to see if the graph has the value
+          if @graph.has_bnode_identifier?(value)
+            # if so, pull it in - no need to recreate objects.
+            subject = @graph.get_bnode_by_identifier(value)
+          else
+            # if not, create a new one.
+            subject = BNode.new(value)
+          end
+        end
+      end
+      
+      if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#ID"
+        begin
+          # check for base
+          if att.element.base?
+            subject = att.element.base.to_s + value
+          elsif @uri != nil
+            compound = @uri.to_s + "#" + value
+            subject = compound.to_s
+          else
+            raise "Needs to have an ID"
+          end
+#        rescue UriRelativeException
+        end
+      end
+
+      # add other subject detection subroutines here
+    }
+    if subject.class == NilClass
+      subject = BNode.new
+    end
+    return subject
+  end
+  
+  protected
+  def parse_element (element, subject = nil, resource = false)
+    if subject == nil
+      # figure out subject
+      subject = self.get_uri_from_atts(element, true)
+    end
+
+    # type parsing
+    if resource == true
+      type = URIRef.new(element.namespace + element.name)
+      unless type.to_s == "http://www.w3.org/1999/02/22-rdf-syntax-ns#Description"
+        @graph.add_triple(subject, URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), type)
+      end
+    end
+    
+    # attribute parsing
+    element.attributes.each_attribute { |att|
+      uri = att.namespace + att.name
+      value = att.to_s
+      
+      unless @excl.member? uri
+        @graph.add_triple(subject, URIRef.new(uri), Literal.new(value))
+      end
+    }
+
+    # element parsing
+    element.each_element { |e|
+      self.parse_resource_element e, subject
+    }
+  end
+  
+  def parse_resource_element e, subject
+    uri = e.namespace + e.name
+    if e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "parseType").to_s == "Literal"
+      @graph.add_triple(subject, URIRef.new(uri), TypedLiteral.new(e.children.to_s.strip, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"))
+    elsif e.has_elements?
+      # subparsing
+      e.each_element { |se| #se = 'striped element'
+        if e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "parseType").to_s == "Resource"
+          object = BNode.new
+        else
+          object = self.get_uri_from_atts(se, true)
+        end
+        @graph.add_triple(subject, URIRef.new(uri), object)
+        self.parse_element(se, object, true)
+      }
+    elsif e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "datatype")
+      @graph.add_triple(subject, URIRef.new(uri), TypedLiteral.new(e.text, e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "datatype").to_s.strip))
+    elsif e.has_attributes?
+      # get object out
+      object = self.get_uri_from_atts(e)
+      @graph.add_triple(subject, URIRef.new(uri), object)
+    elsif e.has_text?
+      if e.lang?
+        @graph.add_triple(subject, URIRef.new(uri), Literal.new(e.text, e.lang))
+      else
+        @graph.add_triple(subject, URIRef.new(uri), Literal.new(e.text))                    
+      end
+    end
+  end
+  
+end

data/lib/rena/rexml_hacks.rb

@@ -0,0 +1,70 @@
+require 'rexml/document'
+
+# def subdocument_writer(el)
+#   el.prefixes.each { |ns|
+#     el.add_attribute('xmlns:' + ns, el.namespaces[ns].to_s)
+#   }
+#   return el.to_s
+# end
+
+class REXML::Element
+  public
+  def lang?
+    if self.lang != nil
+      true
+    else
+      false
+    end
+  end
+  def lang
+    if self.attributes['xml:lang']
+      return self.attributes['xml:lang'].to_s
+    elsif self.parent != nil
+      return self.parent.lang
+    else
+      return nil
+    end
+  end
+  
+  def base?
+    if self.base != nil
+      true
+    else
+      false
+    end
+  end
+  
+  def base
+    if self.attributes['xml:base']
+      return self.attributes['xml:base'].to_s
+    elsif self.parent != nil
+      return self.parent.base
+    else
+      return nil
+    end
+  end
+  
+  def write(excl=[])
+    # TODO: add optional list argument of excluded namespaces
+    self.prefixes.each { |ns|
+      self.add_attribute('xmlns:' + ns, self.namespaces[ns].to_s) unless excl.include? self.namespaces[ns]
+    }
+    self.support_write_recursive(self.namespaces, self)
+    return self.to_s
+  end
+  
+  protected
+  def support_write_recursive(array, el)
+    el.each_element { |e| 
+      unless array.has_key?(e.prefix) && array.has_value?(e.namespace)
+        if e.prefix != ""
+          e.add_attribute('xmlns:' + e.prefix, e.namespace)
+        else
+          e.add_attribute('xmlns', e.namespace)
+        end
+      end
+      self.support_write_recursive(array, e)
+    }
+  end
+  
+end

data/lib/rena/triple.rb

@@ -0,0 +1,72 @@
+class Triple
+  attr_accessor :subject, :object, :predicate
+  
+  ## 
+  # Creates a new triple directly from the intended subject, predicate, and object.
+  #
+  # ==== Example
+  #   Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new) # => results in the creation of a new triple and returns it
+  #
+  # @param [URIRef, BNode] s the subject of the triple
+  # @param [URIRef] p the predicate of the triple
+  # @param [URIRef, BNode, Literal, TypedLiteral] o the object of the triple
+  #
+  # ==== Returns
+  #
+  # @return [Triple] An array of the triples (leaky abstraction? consider returning the graph instead)
+  #
+  # @raise [Error] Checks parameter types and raises if they are incorrect.
+  # @author Tom Morris
+  def initialize (subject, predicate, object)
+    self.check_subject(subject)
+    self.check_predicate(predicate)
+    self.check_object(object)
+  end
+
+  def to_ntriples
+    @subject.to_ntriples + " " + @predicate.to_ntriples + " " + @object.to_ntriples + " ."
+  end
+    
+  protected
+  def check_subject(subject)
+    if subject.class == BNode || subject.class == URIRef
+      @subject = subject
+    elsif subject.class == String
+      if subject =~ /\S+\/\/\S+/ # does it smell like a URI?
+        @subject = URIRef.new(subject)
+      else
+        @subject = BNode.new(subject)
+      end
+    else
+      raise "Subject is not of a known class"
+    end
+  end
+  
+  protected
+  def check_predicate(predicate)
+    if predicate.class == URIRef
+      @predicate = predicate
+    elsif predicate.class == BNode
+      raise "BNode is not allowed as a predicate"
+    elsif predicate.class == String
+      if predicate =~ /\S+\/\/\S+/ # URI smell check again
+        @predicate = URIRef.new(predicate)
+      else
+        raise "String literals are not acceptable as predicates"
+      end
+    else
+      raise "Predicate should be a uriref"
+    end
+  end
+  
+  protected
+  def check_object(object)
+    if [String, Integer, Fixnum, Float].include? object.class
+      @object = Literal.new(object.to_s)
+    elsif [URIRef, BNode, Literal, TypedLiteral].include? object.class
+      @object = object
+    else
+      raise "Object expects valid class"
+    end
+  end
+end

data/lib/rena/uriref.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'addressable/uri'
+require 'rena/exceptions/uri_relative_exception'
+
+class URIRef
+  attr_accessor :uri
+  def initialize (string)
+    self.test_string(string)
+    @uri = Addressable::URI.parse(string)
+    if @uri.relative?
+      raise UriRelativeException, "<" + @uri.to_s + ">"
+    end
+    if !@uri.to_s.match(/^javascript/).nil?
+      raise "Javascript pseudo-URIs are not acceptable"
+    end
+  end
+  
+  def == (other)
+    return true if @uri == other.uri
+  end
+  
+  def to_s
+    @uri.to_s
+  end
+  
+  def to_ntriples
+    "<" + @uri.to_s + ">"
+  end
+  
+  def test_string (string)
+    if string.class != String
+      string = string.to_s
+    end
+    
+    string.each_byte do |b|
+      if b >= 0 and b <= 31
+        raise "URI must not contain control characters"
+      end
+    end
+  end
+end

data/rena.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = "rena"
+  s.version = "0.0.1"
+  s.date = "2008-07-13"
+  s.summary = "Ruby RDF library."
+  s.email = "tom@tommorris.org"
+  s.homepage = "http://github.com/tommorris/rena"
+  s.description = "Rena is a Ruby library for manipulating RDF files."
+  s.has_rdoc = true
+  s.authors = ['Tom Morris', 'Pius Uzamere']
+  s.files = ["README.txt", "Rakefile", "rena.gemspec", "lib/rena.rb", "lib/rena/bnode.rb", "lib/rena/graph.rb", "lib/rena/literal.rb", "lib/rena/namespace.rb", "lib/rena/rdfxmlparser.rb", "lib/rena/rexml_hacks.rb", "lib/rena/triple.rb", "lib/rena/uriref.rb", "lib/rena/exceptions/about_each_exception.rb", "lib/rena/exceptions/uri_relative_exception.rb"]
+  s.test_files = ["test/test_uris.rb", "test/xml.rdf", "test/spec/bnode.spec.rb", "test/spec/graph.spec.rb", "test/spec/literal.spec.rb", "test/spec/namespaces.spec.rb", "test/spec/parser.spec.rb", "test/spec/rexml_hacks.spec.rb", "test/spec/triple.spec.rb", "test/spec/uriref.spec.rb"]
+  #s.rdoc_options = ["--main", "README.txt"]
+  #s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.add_dependency("addressable", ["> 0.0.1"])
+end

data/test/spec/bnode.spec.rb

@@ -0,0 +1,25 @@
+require 'lib/rena'
+describe "Blank nodes" do
+  it "should accept a custom identifier" do
+    b = BNode.new('foo')
+    b.identifier.should == "foo"
+    b.to_s.should == "foo"
+  end
+  
+  it "should reject custom identifiers if they are not acceptable" do
+    b = BNode.new("4cake")
+    b.identifier.should_not == "4cake"
+  end
+  
+  it "should be expressible in N3 and NT syntax" do
+    b = BNode.new('test')
+    b.to_n3.should == "_:test"
+    b.to_ntriples.should == b.to_n3
+  end
+  
+  it "should be able to determine equality" do
+    a = BNode.new('a')
+    a2 = BNode.new('a')
+    a.eql?(a2).should == true
+  end
+end

data/test/spec/graph.spec.rb

@@ -0,0 +1,108 @@
+require 'lib/rena'
+
+describe "Graphs" do
+  it "should allow you to add one or more triples" do
+    lambda do
+      f = Graph.new
+      f.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+  end
+  
+  it "should tell you how large the graph is" do
+    f = Graph.new
+    5.times do
+      f.add_triple BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new
+    end
+    f.size.should == 5
+  end
+
+  it "should support << as an alias for add_triple" do
+    lambda do
+      f = Graph.new
+      f << Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+  end
+  
+  it "should output NTriple" do
+    f = Graph.new
+    ex = Namespace.new("http://example.org/", "ex")
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    f << Triple.new(ex.john, foaf.knows, ex.jane)
+    f << Triple.new(ex.jane, foaf.knows, ex.rick)
+    f << Triple.new(ex.rick, foaf.knows, ex.john)
+    nt = "<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .\n<http://example.org/jane> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n<http://example.org/rick> <http://xmlns.com/foaf/0.1/knows> <http://example.org/john> .\n"
+    f.to_ntriples.should == nt
+  end
+  
+  it "should allow iteration" do
+    f = Graph.new
+    ex = Namespace.new("http://example.org/", "ex")
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    f << Triple.new(ex.john, foaf.knows, ex.jane)
+    f << Triple.new(ex.jane, foaf.knows, ex.rick)
+    f << Triple.new(ex.rick, foaf.knows, ex.john)
+    count = 0
+    f.each do |t|
+      count = count + 1
+      t.class.should == Triple
+    end
+    count.should == 3
+  end
+  
+  it "should allow iteration over a particular subject" do
+    f = Graph.new
+    ex = Namespace.new("http://example.org/", "ex")
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    f << Triple.new(ex.john, foaf.knows, ex.jane)
+    f << Triple.new(ex.jane, foaf.knows, ex.rick)
+    f << Triple.new(ex.rick, foaf.knows, ex.john)
+    count = 0
+    f.each_with_subject(ex.john) do |t|
+      count = count + 1
+      t.class.should == Triple
+    end
+    count.should == 1
+  end
+  
+  it "should be able to determine whether or not it has existing BNodes" do
+    f = Graph.new
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    f << Triple.new(BNode.new('john'), foaf.knows, BNode.new('jane'))
+    f.has_bnode_identifier?('john').should == true
+    f.has_bnode_identifier?('jane').should == true
+    f.has_bnode_identifier?('jack').should == false
+  end
+  
+  it "should be able to return BNodes on demand" do
+    f = Graph.new
+    john = BNode.new('john')
+    jane = BNode.new('jane')
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    f << Triple.new(john, foaf.knows, jane)
+    f.get_bnode_by_identifier('john').should == john
+    f.get_bnode_by_identifier('jane').should == jane
+  end
+  
+  it "should allow you to create and bind Namespace objects on-the-fly" do
+    f = Graph.new
+    f.namespace("http://xmlns.com/foaf/0.1/", "foaf")
+    f.nsbinding["foaf"].uri.should == "http://xmlns.com/foaf/0.1/"
+  end
+  
+  it "should not allow you to bind things other than namespaces" do
+    lambda do
+      f = Graph.new
+      f.bind(false)
+    end.should raise_error
+  end
+  
+  it "should have an error log for parsing errors" do
+    pending "TODO: implement an error log at the graph level"
+  end
+  
+  it "should follow the specification as to output identical triples" do
+    pending
+  end
+  
+  it "should be able to integrate another graph"
+end