metade-rena 0.0.2

data/lib/rena/rexml_hacks.rb

@@ -0,0 +1,97 @@
+require 'rexml/document'
+
+# @ignore
+# 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
+  
+  ## 
+  # Tells you whether or not an element has a set xml:lang.
+  #
+  # @author Tom Morris
+  def lang?
+    self.lang.nil? ? false : true
+  end
+  
+  ## 
+  # Tells you what the set xml:lang is for an element.
+  #
+  # ==== Returns
+  # @return [String] The URI of the xml:lang.
+  # 
+  # @author Tom Morris
+  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
+
+  ## 
+  # Tells you whether or not an element has a set xml:base.
+  #
+  # @author Tom Morris  
+  def base?
+    if self.base != nil
+      true
+    else
+      false
+    end
+  end
+  
+  ## 
+  # Tells you what the set xml:lang is for an element.
+  #
+  # ==== Returns
+  # @return [String] The URI of the xml:base.
+  # 
+  # @author Tom Morris
+  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
+  
+  ## 
+  # Allows you to write out an XML representation of a particular element and it's children, fixing namespace issues.
+  #
+  # ==== Returns
+  # @return [String] The XML of the element and it's children.
+  # 
+  # @author Tom Morris
+  def write_rena(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,89 @@
+module Rena
+  class Triple
+    class InvalidPredicate < StandardError
+    end
+
+    class InvalidSubject < StandardError
+    end
+
+    class InvalidObject < StandardError
+    end
+
+    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)
+      @subject   = self.class.coerce_subject(subject)
+      @predicate = self.class.coerce_predicate(predicate)
+      @object    = self.class.coerce_object(object)
+    end
+
+    def to_ntriples
+      @subject.to_ntriples + " " + @predicate.to_ntriples + " " + @object.to_ntriples + " ."
+    end
+
+    def inspect
+      [@subject, @predicate, @object].inspect
+    end
+
+    def is_type?
+      @predicate.to_s == "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+    end
+
+    protected
+
+    def self.coerce_subject(subject)
+      case subject
+      when URIRef, BNode
+        subject
+      when String
+        if subject =~ /\S+\/\/\S+/ # does it smell like a URI?
+          URIRef.new(subject)
+        else
+          BNode.new(subject)
+        end
+      else
+        raise InvalidSubject, "Subject is not of a known class"
+      end
+    end
+
+    def self.coerce_predicate(uri_or_string)
+      case uri_or_string
+      when URIRef
+        uri_or_string
+      when String
+        URIRef.new uri_or_string
+      else
+        raise InvalidPredicate, "Predicate should be a URI"
+      end
+    rescue UriRelativeException => e
+      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
+    end
+
+    def self.coerce_object(object)
+      case object
+      when String, Integer, Float
+        Literal.build_from(object)
+      when URIRef, BNode, Literal
+        object
+      else
+        raise InvalidObject, "#{object.inspect} is not a valid object"
+      end
+    end
+  end
+end

data/lib/rena/uriref.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'addressable/uri'
+require 'rena/exceptions/uri_relative_exception'
+require 'net/http'
+
+module Rena
+  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 short_name
+      if @uri.fragment()
+        return @uri.fragment()
+      elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
+        return @uri.path.split("/").last
+      else
+        return false
+      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)
+      string.to_s.each_byte do |b|
+        if b >= 0 and b <= 31
+          raise "URI must not contain control characters"
+        end
+      end
+    end
+
+    def load_graph
+      get = Net::HTTP.start(@uri.host, @uri.port) {|http| [:xml, http.get(@uri.path)] }
+      return Rena::RdfXmlParser.new(get[1].body, @uri.to_s).graph if get[0] == :xml
+    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,17 @@
+Gem::Specification.new do |s|
+  s.name = "rena"
+  s.version = "0.0.2"
+  s.date = "2008-10-5"
+  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', 'Patrick Sinclair']
+  s.files = ["README.txt", "Rakefile", "rena.gemspec", "lib/rena.rb", "lib/rena/bnode.rb", "lib/rena/graph.rb", "lib/rena/literal.rb", "lib/rena/n3parser.rb", "lib/rena/n3_grammar.treetop", "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", "spec/bnode_spec.rb", "spec/graph_spec.rb", "spec/literal_spec.rb", "spec/namespaces_spec.rb", "spec/parser_spec.rb", "spec/rexml_hacks_spec.rb", "spec/triple_spec.rb", "spec/uriref_spec.rb"]
+  #s.rdoc_options = ["--main", "README.txt"]
+  #s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.add_dependency("addressable", [">= 1.0.4"])
+  s.add_dependency("treetop", [">= 1.2.4"])
+end

data/spec/bnode_spec.rb

@@ -0,0 +1,29 @@
+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 be_true
+    
+    a3 = URIRef.new('http://somehost.com/wherever.xml')
+    a.eql?(a3).should be_false
+  end
+  
+end

data/spec/graph_spec.rb

@@ -0,0 +1,127 @@
+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> ."
+    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 follow the specification as to output identical triples" do
+    pending
+  end
+  
+  it "should be able to integrate another graph" do
+    f = Graph.new
+    f.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    g = Graph.new
+    g.join(f)
+    g.size.should == 1
+    
+    h = Graph.new
+    lambda do
+      h.join("")
+    end.should raise_error
+  end
+  
+  it "should give you a list of resources of a particular type" do
+    f = Graph.new
+    person = URIRef.new("http://xmlns.com/foaf/0.1/Person")
+    f.add_triple(URIRef.new("http://example.org/joe"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+    f.add_triple(URIRef.new("http://example.org/jane"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+    f.size.should == 2
+    
+    f.get_by_type("http://xmlns.com/foaf/0.1/Person").size.should == 2
+    f.get_by_type("http://xmlns.com/foaf/0.1/Person")[0].to_s.should == "http://example.org/joe"
+    f.get_by_type("http://xmlns.com/foaf/0.1/Person")[1].to_s.should == "http://example.org/jane"
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,136 @@
+require 'lib/rena'
+
+describe "Literals" do
+  it "accept a language tag" do
+    f = Literal.untyped("tom", "en")
+    f.lang.should == "en"
+  end
+  
+  it "accepts an encoding" do
+    f = Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    f.encoding.to_s.should == "http://www.w3.org/2001/XMLSchema#string"
+  end
+  
+  it "should be equal if they have the same contents" do
+    f = Literal.untyped("tom")
+    g = Literal.untyped("tom")
+    f.should == g    
+  end
+  
+  it "should not be equal if they do not have the same contents" do
+    f = Literal.untyped("tom")
+    g = Literal.untyped("tim")
+    f.should_not == g
+  end
+  
+  it "should be equal if they have the same contents and language" do
+    f = Literal.untyped("tom", "en")
+    g = Literal.untyped("tom", "en")
+    f.should == g
+  end
+
+  it "should return a string using to_s" do
+    f = Literal.untyped("tom")
+    f.to_s.should == "tom"
+  end
+  
+  it "should not be equal if they do not have the same contents and language" do
+    f = Literal.untyped("tom", "en")
+    g = Literal.untyped("tim", "en")
+    f.should_not == g
+    
+    lf = Literal.untyped("tom", "en")
+    lg = Literal.untyped("tom", "fr")
+    lf.should_not == lg
+  end
+  
+  it "should be equal if they have the same contents and datatype" do
+    f = Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    g = Literal.typed("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 = Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    g = Literal.typed("tim", "http://www.w3.org/2001/XMLSchema#string")
+    f.should_not == g
+
+    dtf = Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    dtg = Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#token")
+    dtf.should_not == dtg
+  end
+  
+  it "should return valid N3/NTriples format strings" do
+    f = Literal.untyped("tom")
+    f.to_n3.should == "\"tom\""
+    f.to_ntriples.should == f.to_n3
+    
+    g = Literal.untyped("tom", "en")
+    g.to_n3.should == "\"tom\"@en"
+    f.to_ntriples.should == f.to_n3
+    
+    typed_int = Literal.typed(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 = Literal.typed("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.untyped("tom", "EN")
+    f.lang.should == "en"
+  end
+  
+  it "should support TriX encoding" do
+    e = Literal.untyped("tom")
+    e.to_trix.should == "<plainLiteral>tom</plainLiteral>"
+    
+    f = Literal.untyped("tom", "en")
+    f.to_trix.should == "<plainLiteral xml:lang=\"en\">tom</plainLiteral>"
+    
+    g = Literal.typed("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 = Literal.typed("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 "build_from should infer the type" do
+    int = Literal.build_from(15)
+    int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
+    
+    float = Literal.build_from(15.4)
+    float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
+    
+    other = Literal.build_from("foo")
+    other.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+  end
+  
+  it "build_from_language" do
+    english = Literal.build_from_language("Have a nice day")
+    english.encoding.should == "en"
+    
+    french = Literal.build_from_language("Bonjour, madame. Parlez vous francais?")
+    french.encoding.should == "fr"
+    
+    german = Literal.build_from_language("Achtung")
+    german.encoding.should == "de"
+  end
+
+  # TODO: refactor based on new interface
+  # describe "Languages" do
+  #   it "should be inspectable" do
+  #     literal = Rena::Literal.new("foo", "en")
+  #     lang = literal.lang
+  #     lang.to_s == "en"
+  #     lang.hash.class.should == Fixnum
+  #   end    
+  # end
+  
+end