tommorris-rena 0.0.1 → 0.0.2

data/lib/rena/rexml_hacks.rb

@@ -1,5 +1,6 @@
 require 'rexml/document'
 
+# @ignore
 # def subdocument_writer(el)
 #   el.prefixes.each { |ns|
 #     el.add_attribute('xmlns:' + ns, el.namespaces[ns].to_s)
@@ -9,13 +10,22 @@ require 'rexml/document'
 
 class REXML::Element
   public
+  
+  ## 
+  # Tells you whether or not an element has a set xml:lang.
+  #
+  # @author Tom Morris
   def lang?
-    if self.lang != nil
-      true
-    else
-      false
-    end
+    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
@@ -25,7 +35,11 @@ class REXML::Element
       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
@@ -34,6 +48,13 @@ class REXML::Element
     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
@@ -44,7 +65,14 @@ class REXML::Element
     end
   end
   
-  def write(excl=[])
+  ## 
+  # 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]
@@ -66,5 +94,4 @@ class REXML::Element
       self.support_write_recursive(array, e)
     }
   end
-  
-end
+end

data/lib/rena/triple.rb

@@ -1,72 +1,89 @@
-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
+module Rena
+  class Triple
+    class InvalidPredicate < StandardError
+    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)
+    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
-        @subject = BNode.new(subject)
+        raise InvalidSubject, "Subject is not of a known class"
       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)
+
+    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 "String literals are not acceptable as predicates"
+        raise InvalidPredicate, "Predicate should be a URI"
       end
-    else
-      raise "Predicate should be a uriref"
+    rescue UriRelativeException => e
+      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
     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"
+
+    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
+end

data/lib/rena/uriref.rb

@@ -1,41 +1,55 @@
 require 'rubygems'
 require 'addressable/uri'
 require 'rena/exceptions/uri_relative_exception'
+require 'net/http'
 
-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"
+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
-  end
   
-  def == (other)
-    return true if @uri == other.uri
-  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 to_s
-    @uri.to_s
-  end
+    def == (other)
+      return true if @uri == other.uri
+    end
   
-  def to_ntriples
-    "<" + @uri.to_s + ">"
-  end
+    def to_s
+      @uri.to_s
+    end
   
-  def test_string (string)
-    if string.class != String
-      string = string.to_s
+    def to_ntriples
+      "<" + @uri.to_s + ">"
     end
-    
-    string.each_byte do |b|
-      if b >= 0 and b <= 31
-        raise "URI must not contain control characters"
+  
+    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/rena.gemspec

@@ -1,16 +1,17 @@
 Gem::Specification.new do |s|
   s.name = "rena"
-  s.version = "0.0.1"
-  s.date = "2008-07-13"
+  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']
-  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.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", ["> 0.0.1"])
-end
+  s.add_dependency("addressable", [">= 1.0.4"])
+  s.add_dependency("treetop", [">= 1.2.4"])
+end

data/{test/spec/bnode.spec.rb → spec/bnode_spec.rb}

@@ -20,6 +20,10 @@ describe "Blank nodes" do
   it "should be able to determine equality" do
     a = BNode.new('a')
     a2 = BNode.new('a')
-    a.eql?(a2).should == true
+    a.eql?(a2).should be_true
+    
+    a3 = URIRef.new('http://somehost.com/wherever.xml')
+    a.eql?(a3).should be_false
   end
+  
 end

data/{test/spec/graph.spec.rb → spec/graph_spec.rb}

@@ -30,7 +30,7 @@ describe "Graphs" do
     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"
+    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
   
@@ -95,14 +95,33 @@ describe "Graphs" do
       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"
+  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