tommorris-rena 0.0.1

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/lib/rena.rb

@@ -0,0 +1,5 @@
+$:.unshift File.dirname(__FILE__)
+Dir.glob(File.join(File.dirname(__FILE__), 'rena/**.rb')).each { |f| require f }
+
+module Rena
+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

data/test/spec/literal.spec.rb

@@ -0,0 +1,112 @@
+require 'lib/rena'
+
+describe "Literals" do
+  it "accept a language tag" do
+    f = Literal.new("tom", "en")
+    f.lang.should == "en"
+  end
+  
+  it "accepts an encoding" do
+    f = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    f.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+  end
+  
+  it "should be equal if they have the same contents" do
+    f = Literal.new("tom")
+    g = Literal.new("tom")
+    f.should == g    
+  end
+  
+  it "should not be equal if they do not have the same contents" do
+    f = Literal.new("tom")
+    g = Literal.new("tim")
+    f.should_not == g
+  end
+  
+  it "should be equal if they have the same contents and language" do
+    f = Literal.new("tom", "en")
+    g = Literal.new("tom", "en")
+    f.should == g
+  end
+  
+  it "should not be equal if they do not have the same contents and language" do
+    f = Literal.new("tom", "en")
+    g = Literal.new("tim", "en")
+    f.should_not == g
+    
+    lf = Literal.new("tom", "en")
+    lg = Literal.new("tom", "fr")
+    lf.should_not == lg
+  end
+  
+  it "should be equal if they have the same contents and datatype" do
+    f = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    g = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    f.should == g
+  end
+
+  it "should not be equal if they do not have the same contents and datatype" do
+    f = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    g = TypedLiteral.new("tim", "http://www.w3.org/2001/XMLSchema#string")
+    f.should_not == g
+
+    dtf = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    dtg = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#token")
+    dtf.should_not == dtg
+  end
+  
+  it "should return valid N3/NTriples format strings" do
+    f = Literal.new("tom")
+    f.to_n3.should == "\"tom\""
+    f.to_ntriples.should == f.to_n3
+    
+    g = Literal.new("tom", "en")
+    g.to_n3.should == "\"tom\"@en"
+    f.to_ntriples.should == f.to_n3
+    
+    typed_int = TypedLiteral.new(5, "http://www.w3.org/2001/XMLSchema#int")
+    typed_int.to_n3.should == "5^^<http://www.w3.org/2001/XMLSchema#int>"
+    typed_int.to_ntriples.should == typed_int.to_n3
+    
+    typed_string = TypedLiteral.new("foo", "http://www.w3.org/2001/XMLSchema#string")
+    typed_string.to_n3.should == "\"foo\"^^<http://www.w3.org/2001/XMLSchema#string>"
+    typed_string.to_ntriples.should == typed_string.to_n3
+  end
+  
+  it "should normalize language tags to lower case" do
+    f = Literal.new("tom", "EN")
+    f.lang.should == "en"
+  end
+  
+  it "should support TriX encoding" do
+    e = Literal.new("tom")
+    e.to_trix.should == "<plainLiteral>tom</plainLiteral>"
+    
+    f = Literal.new("tom", "en")
+    f.to_trix.should == "<plainLiteral xml:lang=\"en\">tom</plainLiteral>"
+    
+    g = TypedLiteral.new("tom", "http://www.w3.org/2001/XMLSchema#string")
+    g.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#string\">tom</typedLiteral>"
+  end
+  
+  it "should handle XML litearls" do
+    # first we should detect XML literals and mark them as such in the class
+    f = TypedLiteral.new("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+    f.xmlliteral?.should == true
+#    pending "TODO: the thought of XML literals makes me want to wretch"
+  end
+  
+  it "should be able to infer!" do
+    int = TypedLiteral.new(15, nil)
+    int.infer!
+    int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
+    
+    float = TypedLiteral.new(15.4, nil)
+    float.infer!
+    float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
+    
+    other = TypedLiteral.new("foo", nil)
+    other.infer!
+    other.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+  end
+end

data/test/spec/namespaces.spec.rb

@@ -0,0 +1,44 @@
+require 'lib/rena'
+
+describe "Namespaces" do
+  it "should use method_missing to create URIRefs on the fly" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    foaf.knows.to_s.should == "http://xmlns.com/foaf/0.1/knows"
+    
+    foaf_frag = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf", true)
+    foaf_frag.knows.to_s.should == "http://xmlns.com/foaf/0.1/#knows"
+  end
+  
+  it "should have a URI" do
+    lambda do
+      test = Namespace.new(short='foaf')
+    end.should raise_error
+  end
+  
+  it "should have equality with URIRefs" do
+      foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+      foaf_name = URIRef.new("http://xmlns.com/foaf/0.1/name")
+      foaf.name.should == foaf_name
+  end
+  
+  it "should have an XML and N3-friendly prefix" do
+    lambda do
+      test = Namespace.new('http://xmlns.com/foaf/0.1/', '*~{')
+    end.should raise_error
+  end
+  
+  it "should be able to attach to the graph for substitution" do
+    # rdflib does this using graph.bind('prefix', namespace)
+    g = Graph.new
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    foaf.bind(g)
+    g.nsbinding["foaf"].should == foaf
+  end
+  
+  it "should not allow you to attach to non-graphs" do
+    lambda do
+      foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+      foaf.bind("cheese")
+    end.should raise_error
+  end
+end