reddy 0.1.0

data/lib/reddy/triple.rb

@@ -0,0 +1,95 @@
+module Reddy
+  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 Addressable::URI
+        URIRef.new(subject.to_s)
+      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 (#{subject.class}: #{subject.inspect})"
+      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 Reddy::UriRelativeException => e
+      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
+    end
+
+    def self.coerce_object(object)
+      case object
+      when Addressable::URI
+        URIRef.new(object.to_s)
+      when String, Integer, Float
+        Literal.untyped(object)
+    #  when URIRef, BNode, Literal, TypedLiteral
+    #    Literal.build_from(object)
+      when URIRef, BNode, Literal
+        object
+      else
+        raise InvalidObject, "#{object.class}: #{object.inspect} is not a valid object"
+      end
+    end
+  end
+end

data/lib/reddy/uriref.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'addressable/uri'
+require 'net/http'
+
+module Reddy
+  class UriRelativeException < StandardError
+  end
+
+  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 + (input)
+      if input.class == String
+        input_uri = Addressable::URI.parse(input)
+      else
+        input_uri = Addressable::URI.parse(input.to_s)
+      end
+      return URIRef.new((@uri + input_uri).to_s)
+    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 Reddy::RdfXmlParser.new(get[1].body, @uri.to_s).graph if get[0] == :xml
+    end
+  end
+end

data/reddy.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{reddy}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Morris"]
+  s.date = %q{2008-12-02}
+  s.description = %q{Reddy is an RDF library for Ruby.}
+  s.email = ["tom@tommorris.org"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc", "README.txt"]
+  s.files = ["HACKNOTES", "History.txt", "lib", "lib/reddy", "lib/reddy/libxml_hacks.rb", "lib/reddy/rexml_hacks.rb", "lib/reddy/n3_grammar.treetop", "lib/reddy/uriref.rb", "lib/reddy/rdfxmlparser.rb", "lib/reddy/n3parser.rb", "lib/reddy/exceptions", "lib/reddy/exceptions/about_each_exception.rb", "lib/reddy/exceptions/uri_relative_exception.rb", "lib/reddy/namespace.rb", "lib/reddy/graph.rb", "lib/reddy/bnode.rb", "lib/reddy/triple.rb", "lib/reddy/rdfaparser.rb", "lib/reddy/literal.rb", "lib/reddy.rb", "Manifest.txt", "Rakefile", "README.rdoc", "README.txt", "reddy.gemspec", "spec", "spec/uriref_spec.rb", "spec/rdfa_parser_spec.rb", "spec/n3parser_spec.rb", "spec/graph_spec.rb", "spec/literal_spec.rb", "spec/bnode_spec.rb", "spec/triple_spec.rb", "spec/parser_spec.rb", "spec/rexml_hacks_spec.rb", "spec/namespaces_spec.rb", "tasks", "test", "test/xml.rdf", "test/n3_tests", "test/n3_tests/misc", "test/n3_tests/misc/on_now-01.nt", "test/n3_tests/misc/on_now-01.n3", "test/n3_tests/n3p", "test/n3_tests/n3p/simple-07.nt", "test/n3_tests/n3p/simple-05.n3", "test/n3_tests/n3p/simple-06.n3", "test/n3_tests/n3p/simple-07.n3", "test/n3_tests/n3p/simple-06.nt", "test/n3_tests/n3p/simple-02.nt", "test/n3_tests/n3p/simple-04.nt", "test/n3_tests/n3p/simple-02.n3", "test/n3_tests/n3p/simple-03.nt", "test/n3_tests/n3p/simple-01.nt", "test/n3_tests/n3p/simple-01.n3", "test/n3_tests/n3p/simple-04.n3", "test/n3_tests/n3p/simple-03.n3", "test/n3_tests/n3p/simple-05.nt", "test/n3_tests/lcsh", "test/n3_tests/lcsh/sh85082139.nt", "test/n3_tests/lcsh/sh85118553.nt", "test/n3_tests/lcsh/sh85118553.n3", "test/n3_tests/lcsh/sh85062913.n3", "test/n3_tests/lcsh/sh85082139.n3", "test/n3_tests/lcsh/sh85062913.nt", "test/perf_test", "test/perf_test/tommorris.rdf", "test/perf_test/test.rb", "test/rdf_tests", "test/rdf_tests/xml-literal-mixed.rdf", "test/rdf_tests/xml-literal-mixed.nt", "test/rdf_tests/tm_001.nt", "test/rdf_tests/cc197bad-dc9c-440d-a5b5-d52ba2e14234.rdf", "test/rdf_tests/tm_001.rdf", "test/rdf_tests/cc197bad-dc9c-440d-a5b5-d52ba2e14234.nt", "test/test_helper.rb", "test/test_uris.rb", "test/test_reddy.rb", "test/longtests_spec.rb", "test/ruby_fundamentals.spec.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/tommorris/reddy}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{reddy}
+  s.rubygems_version = %q{1.3.0}
+  s.summary = %q{Reddy is an RDF library for Ruby.}
+  s.test_files = ["test/test_helper.rb", "test/test_uris.rb", "test/test_reddy.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<addressable>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<treetop>, [">= 1.2.4"])
+      s.add_runtime_dependency(%q<libxml-ruby>, [">= 0.8.3"])
+      s.add_runtime_dependency(%q<whatlanguage>, [">= 1.0.0"])
+      s.add_development_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<addressable>, [">= 2.0.0"])
+      s.add_dependency(%q<treetop>, [">= 1.2.4"])
+      s.add_dependency(%q<libxml-ruby>, [">= 0.8.3"])
+      s.add_dependency(%q<whatlanguage>, [">= 1.0.0"])
+      s.add_dependency(%q<newgem>, [">= 1.1.0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<addressable>, [">= 2.0.0"])
+    s.add_dependency(%q<treetop>, [">= 1.2.4"])
+    s.add_dependency(%q<libxml-ruby>, [">= 0.8.3"])
+    s.add_dependency(%q<whatlanguage>, [">= 1.0.0"])
+    s.add_dependency(%q<newgem>, [">= 1.1.0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/spec/bnode_spec.rb

@@ -0,0 +1,29 @@
+require 'lib/reddy'
+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,138 @@
+require 'lib/reddy'
+
+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 you to select one resource" 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)
+    f.get_resource(ex.john).size.should == 1
+  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
+    f.get_bnode_by_identifier('barny').should == false
+  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,142 @@
+require 'lib/reddy'
+
+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 "should support XML Literals" do
+    xml = Literal.typed("<b>foo</b>", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+    xml.encoding.should == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
+    xml.to_n3.should == "\"<b>foo</b>\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>"
+  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 = Reddy::Literal.new("foo", "en")
+  #     lang = literal.lang
+  #     lang.to_s == "en"
+  #     lang.hash.class.should == Fixnum
+  #   end    
+  # end
+  
+end