pjstadig-rubyrdf 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-07-11
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Paul Stadig
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+TODO.txt
+lib/rdf.rb
+lib/rdf/blank_node.rb
+lib/rdf/error.rb
+lib/rdf/node.rb
+lib/rdf/plain_literal_node.rb
+lib/rdf/sesame/base.rb
+lib/rdf/sparql_result.rb
+lib/rdf/statement.rb
+lib/rdf/typed_literal_node.rb
+lib/rdf/uri_node.rb
+lib/rdf/version.rb
+lib/rubyrdf.rb
+test/rdf/blank_node_test.rb
+test/rdf/plain_literal_node_test.rb
+test/rdf/sesame/base_test.rb
+test/rdf/sparql_result_test.rb
+test/rdf/statement_test.rb
+test/rdf/typed_literal_node_test.rb
+test/rdf/uri_node_test.rb
+test/rdf_test.rb
+test/test_helper.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on rubyrdf, see http://rubyrdf.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.txt

@@ -0,0 +1,48 @@
+= rubyrdf
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Paul Stadig
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/TODO.txt

@@ -0,0 +1,13 @@
+blank node validation
+uri node validation
+plain literal node validation
+typed literal node validation
+transactions
+to_node
+to_f
+to_i
+to_int
+to_s
+to_str
+to_date
+to_time

data/lib/rdf/blank_node.rb

@@ -0,0 +1,26 @@
+module RDF
+  class BlankNode < Node
+    attr_reader :name
+    
+    def initialize(name = nil)
+      super()
+      @name = name || genname
+    end
+    
+    def to_ntriples
+      "_:#{@name}"
+    end
+    alias_method :to_s, :to_ntriples
+    
+    def blank_node?
+      true
+    end
+    
+    private
+      def genname
+        @@id ||= 0
+        @@id += 1
+        "bn#{@@id}"
+      end
+  end
+end

data/lib/rdf/error.rb

@@ -0,0 +1,4 @@
+module RDF
+  class Error < StandardError
+  end
+end

data/lib/rdf/node.rb

@@ -0,0 +1,34 @@
+module RDF
+  class Node
+    def escape_ntriples(str)
+      str.unpack('U*').map! do |c|
+        if 0x9 == c
+          '\t'
+        elsif 0xa == c
+          '\n'
+        elsif 0xd == c
+          '\r'
+        elsif 0x22 == c
+          '\"'
+        elsif 0x5c == c
+          '\\\\'
+        elsif (0x0..0x8).include?(c) ||
+              (0xb..0xc).include?(c) ||
+              (0xe..0x1f).include?(c) ||
+              (0x7F..0xffff).include?(c)
+          "\\u#{fixed_digit_hex(c, 4)}"
+        elsif (0x20..0x21).include?(c) ||
+              (0x23..0x5b).include?(c) ||
+              (0x5d..0x7e).include?(c)
+          c.chr
+        elsif (0x10000..0x10ffff).include?(c)
+          "\\U#{fixed_digit_hex(c, 8)}"
+        end
+      end.join
+    end
+    
+    def fixed_digit_hex(num, digits)
+      "%0#{digits}d" % num.to_s(16).to_i
+    end
+  end
+end

data/lib/rdf/plain_literal_node.rb

@@ -0,0 +1,32 @@
+module RDF
+  class PlainLiteralNode < Node
+    attr_reader :lexical_form, :language_tag
+    
+    def initialize(lexical_form, language_tag = nil)
+      super()
+      @lexical_form = lexical_form.chars.normalize(:c).to_s
+      @language_tag = language_tag
+    end
+    
+    def hash
+      [-1025818701, @lexical_form, @language_tag].hash
+    end
+    
+    def ==(o)
+      self.lexical_form == o.lexical_form &&
+        self.language_tag == o.language_tag
+    rescue NoMethodError
+      false
+    end
+    alias_method :eql?, :==
+    
+    def to_ntriples
+      %Q("#{escape_ntriples(@lexical_form)}"#{@language_tag ? "@#{@language_tag}" : ''})
+    end
+    alias_method :to_s, :to_ntriples
+    
+    def plain_literal_node?
+      true
+    end
+  end
+end

data/lib/rdf/sesame/base.rb

@@ -0,0 +1,109 @@
+require 'uri'
+require 'net/http'
+require 'rexml/document'
+
+module RDF
+  module Sesame
+    class Base
+      attr_reader :address, :port, :path, :repository
+      
+      def initialize(uri, repository)
+        uri = URI.parse(uri)
+        @address = uri.host
+        @port = uri.port
+        @path = uri.path
+        @repository = repository
+      end
+      
+      def size
+        get_request(repo_path('size')).to_i
+      end
+      
+      def empty?
+        size == 0
+      end
+      
+      def add(*statement)
+        post_request(repo_path('statements'), statement.to_statement.to_ntriples, {}, 'Content-Type' => 'text/plain')
+      end
+      
+      def import(data, format = :ntriples)
+        headers = case format
+        when :ntriples
+          {'Content-Type' => 'text/plain; charset=utf-8'}
+        when :rdfxml
+          {'Content-Type' => 'application/rdf+xml; charset=utf-8'}
+        end
+        
+        result = post_request(repo_path("statements"), data, {}, headers)
+        result
+      end
+      
+      def delete(*statement)
+        delete_request(repo_path('statements'), to_param_hash(statement.to_statement))
+      end
+      
+      def delete_all
+        delete_request(repo_path("statements"))
+      end
+      
+      def select(query)
+        SparqlResult.new(get_request(repo_path, {"query" => query}, "Accept" => "application/sparql-results+xml"))
+      end
+      
+      def ask(query)
+        get_request(repo_path, {"query" => query}, "Accept" => "text/boolean") == "true"
+      end
+      
+      def include?(*statement)
+        ask("ASK { #{statement.to_statement.to_ntriples} }")
+      end
+      
+      private
+      def repo_path(path = nil)
+        parts = [@path, "repositories", @repository]
+        if path.to_s.strip != ""
+          parts << path
+        end
+        
+        File.join(*parts)
+      end
+      
+      def to_param_hash(statement)
+        {:subj => statement.subject.to_ntriples,
+         :pred => statement.predicate.to_ntriples,
+         :obj => statement.object.to_ntriples}
+      end
+      
+      def get_request(path, params = {}, headers = {})
+        Net::HTTP.start(@address, @port) do |http|
+          http.get(
+            format_uri(path, params),
+            headers).body
+        end
+      end
+      
+      def post_request(path, data, params = {}, headers = {})
+        Net::HTTP.start(@address, @port) do |http|
+          http.open_timeout = 6000
+          http.read_timeout = 6000
+          http.post(format_uri(path, params), data, headers).body
+        end
+      end
+      
+      def delete_request(path, params = {}, headers = {})
+        Net::HTTP.start(@address, @port) do |http|
+          http.delete(format_uri(path, params), headers).body
+        end
+      end
+      
+      def format_uri(path, params = {})
+        if params.empty?
+          path
+        else
+          path + "?" + params.map{|k, v| "#{k}=#{URI.escape(v)}"}.join("&")
+        end
+      end
+    end
+  end
+end

data/lib/rdf/sparql_result.rb

@@ -0,0 +1,42 @@
+module RDF
+  class SparqlResult < Array
+    class InvalidDocument < Error
+      attr_reader :document
+      
+      def initialize(document)
+        super("Invalid SPARQL Result Document")
+        @document = document
+      end
+    end
+    
+    def initialize(result)
+      super()
+      bnodes = {}
+      doc = REXML::Document.new(result)
+      doc.elements.each('/sparql/results/result') do |r|
+        binding = {}
+        r.elements.each do |b|
+          binding[b.attributes['name']] = parse_node(b.elements[1], bnodes)
+        end
+        self << binding
+      end
+    rescue REXML::ParseException
+      raise InvalidDocument.new(result)
+    end
+    
+    def parse_node(node, bnodes)
+      case node.name
+      when 'uri'
+        RDF::URINode.new(node.text)
+      when 'bnode'
+        bnodes[node.text] ||= RDF::BlankNode.new
+      when 'literal'
+        if node.attributes.include?('datatype')
+          RDF::TypedLiteralNode.new(node.text, node.attributes['datatype'])
+        else
+          RDF::PlainLiteralNode.new(node.text, node.attributes['lang'])
+        end
+      end
+    end
+  end
+end

data/lib/rdf/statement.rb

@@ -0,0 +1,62 @@
+module RDF
+  class Statement
+    class InvalidSubjectError < Error
+      def initialize(subject)
+        super("Invalid Subject: #{subject}")
+      end
+    end
+    
+    class InvalidPredicateError < Error
+      def initialize(predicate)
+        super("Invalid Predicate: #{predicate}")
+      end
+    end
+    
+    class InvalidObjectError < Error
+      def initialize(object)
+        super("Invalid Object: #{object}")
+      end
+    end
+    
+    attr_reader :subject, :predicate, :object
+    
+    def initialize(subject, predicate, object)
+      @subject, @predicate, @object = subject, predicate, object
+      raise InvalidSubjectError.new(@subject) unless @subject.resource?
+      raise InvalidPredicateError.new(@predicate) unless @predicate.uri_node?
+      raise InvalidObjectError.new(@object) unless @object.node?
+    end
+    
+    def hash
+      [-614958737, @subject, @predicate, @object].hash
+    end
+    
+    def ==(o)
+      self.subject == o.subject &&
+        self.predicate == o.predicate &&
+        self.object == o.object
+    rescue NoMethodError
+      false
+    end
+    alias_method :eql?, :==
+    
+    def to_ntriples
+      [@subject, @predicate, @object].map!{|n| n.to_ntriples}.join(' ') + " ."
+    end
+    alias_method :to_s, :to_ntriples
+    
+    def to_statement
+      self
+    end
+  end
+end
+
+class Array
+  def to_statement
+    if self.size == 1
+      self[0].to_statement
+    else
+      RDF::Statement.new(*self)
+    end
+  end
+end

data/lib/rdf/typed_literal_node.rb

@@ -0,0 +1,38 @@
+module RDF
+  class TypedLiteralNode < Node
+    attr_reader :lexical_form, :datatype_uri
+    
+    def initialize(lexical_form, datatype_uri)
+      super()
+      @lexical_form = lexical_form.chars.normalize(:c).to_s
+      if datatype_uri.uri_node?
+        @datatype_uri = datatype_uri.uri
+      else
+        @datatype_uri = datatype_uri
+      end
+      
+      @datatype_uri = @datatype_uri.chars.normalize(:c).to_s
+    end
+    
+    def hash
+      [-1025818701, @lexical_form, @datatype_uri].hash
+    end
+    
+    def ==(o)
+      self.lexical_form == o.lexical_form &&
+        self.datatype_uri == o.datatype_uri
+    rescue NoMethodError
+      false
+    end
+    alias_method :eql?, :==
+    
+    def to_ntriples
+      %Q("#{escape_ntriples(@lexical_form)}"^^<#{escape_ntriples(@datatype_uri)}>)
+    end
+    alias_method :to_s, :to_ntriples
+    
+    def typed_literal_node?
+      true
+    end
+  end
+end

data/lib/rdf/uri_node.rb

@@ -0,0 +1,30 @@
+module RDF
+  class URINode < Node
+    attr_reader :uri
+    
+    def initialize(uri)
+      super()
+      @uri = uri.chars.normalize(:c).to_s
+    end
+    
+    def hash
+      [763084702, @uri].hash
+    end
+    
+    def ==(o)
+      self.uri == o.uri
+    rescue NoMethodError
+      false
+    end
+    alias_method :eql?, :==
+    
+    def to_ntriples
+      "<#{escape_ntriples(@uri)}>"
+    end
+    alias_method :to_s, :to_ntriples
+    
+    def uri_node?
+      true
+    end
+  end
+end

data/lib/rdf/version.rb

@@ -0,0 +1,9 @@
+module RDF
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/rdf.rb

@@ -0,0 +1,111 @@
+module RDF
+  class << self
+    def unregister(*names)
+      names.each do |n|
+        @names.delete(@prefixes[n])
+        @prefixes.delete(n)
+        @namespaces.delete(n)
+      end
+    end
+    
+    def unregister_all!
+      defaults = [:rdf, :rdfs, :xsd, :owl]
+      @namespaces.keys.each do |name|
+        unregister(name) unless defaults.include?(name)
+      end
+    end
+    
+    def register(namespaces)
+      @namespaces ||= {}
+      @names ||= {}
+      @prefixes ||= {}
+      
+      namespaces.each do |name, prefix|
+        @prefixes[name.to_sym] = prefix.to_s
+        @names[prefix.to_s] = name
+        
+        mod = Module.new
+        meta = class << mod
+          self
+        end
+        
+        code_block = <<-ENDL
+          def method_missing(sym, *a, &b)
+            raise ::ArgumentError, "Unexpected arguments for RDF::NS.expand" if a.size > 0
+            ::RDF.expand_node(:#{name}, sym.to_s)
+          end
+          
+          def const_missing(sym)
+            ::RDF.expand_node(:#{name}, sym.to_s)
+          end
+          
+          def [](name)
+            ::RDF.expand_node(:#{name}, name.to_s)
+          end
+          
+          [:type, :name, :id].each{|a| private(a)}
+        ENDL
+        
+        meta.class_eval code_block
+        
+        @namespaces[name.to_sym] = mod
+      end
+    end
+    
+    def registered?(name)
+      @namespaces.key?(name.to_sym)
+    end
+    
+    def prefix(name)
+      @prefixes[name.to_sym]
+    end
+    
+    def expand_uri(name, local)
+      "#{prefix(name)}#{local.to_s}"
+    end
+    
+    def expand_node(name, local)
+      RDF::URINode.new(expand_uri(name, local))
+    end
+    
+    def [](name)
+      @namespaces[name.to_sym]
+    end
+  end
+  
+  register(
+    :rdf => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    :xsd => 'http://www.w3.org/2001/XMLSchema#',
+    :rdfs => 'http://www.w3.org/2000/01/rdf-schema#',
+    :owl => 'http://www.w3.org/2002/07/owl#')
+end
+
+class Object
+  def blank_node?
+    false
+  end
+  
+  def uri_node?
+    false
+  end
+  
+  def typed_literal_node?
+    false
+  end
+  
+  def plain_literal_node?
+    false
+  end
+  
+  def resource?
+    uri_node? || blank_node?
+  end
+  
+  def literal_node?
+    plain_literal_node? || typed_literal_node?
+  end
+  
+  def node?
+    resource? || literal_node?
+  end
+end

data/lib/rubyrdf.rb

@@ -0,0 +1,17 @@
+$KCODE = 'utf8'
+$:.unshift(File.expand_path(File.dirname(__FILE__))) unless
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+gem 'activesupport','>=1.4.0'
+require 'activesupport'
+
+require 'rdf'
+require 'rdf/error'
+require 'rdf/node'
+require 'rdf/blank_node'
+require 'rdf/uri_node'
+require 'rdf/plain_literal_node'
+require 'rdf/typed_literal_node'
+require 'rdf/statement'
+require 'rdf/sparql_result'
+require 'rdf/sesame/base'

data/test/rdf/blank_node_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::BlankNodeTest < Test::Unit::TestCase
+  def test_should_initialize_name
+    assert_equal 'test', RDF::BlankNode.new('test').name
+  end
+  
+  def test_should_generate_name
+    assert_not_nil RDF::BlankNode.new.name
+  end
+  
+  def test_should_export_to_ntriples_format
+    assert_equal '_:test', RDF::BlankNode.new('test').to_ntriples
+    assert_equal '_:test', RDF::BlankNode.new('test').to_s
+  end
+  
+  def test_should_be_node
+    node = RDF::BlankNode.new
+    
+    assert node.blank_node?
+    assert node.resource?
+    assert node.node?
+  end
+end

data/test/rdf/plain_literal_node_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::PlainLiteralNodeTest < Test::Unit::TestCase
+  def test_should_initialize_lexical_form
+    assert_equal 'test', RDF::PlainLiteralNode.new('test').lexical_form
+  end
+  
+  def test_should_normalize_lexical_form
+    assert_equal [0x03a9].pack('U'), RDF::PlainLiteralNode.new([0x2126].pack('U')).lexical_form
+  end
+  
+  def test_should_initialize_language_tag
+    assert_nil RDF::PlainLiteralNode.new('test').language_tag
+    assert_equal 'en', RDF::PlainLiteralNode.new('test', 'en').language_tag
+  end
+  
+  def test_should_be_eq
+    assert RDF::PlainLiteralNode.new('test', 'en') ==
+           RDF::PlainLiteralNode.new('test', 'en')
+    assert RDF::PlainLiteralNode.new('test') ==
+           RDF::PlainLiteralNode.new('test')
+  end
+  
+  def test_should_not_be_eq
+    node = RDF::PlainLiteralNode.new('test', 'en')
+    assert node != nil
+    assert node != RDF::PlainLiteralNode.new('test')
+    assert node != RDF::PlainLiteralNode.new('test2', 'en')
+    assert node != RDF::PlainLiteralNode.new('test', 'fr')
+  end
+  
+  def test_should_be_eql
+    node = RDF::PlainLiteralNode.new('test', 'en')
+    assert node.eql?(RDF::PlainLiteralNode.new('test', 'en'))
+  end
+  
+  def test_should_not_be_eql
+    node = RDF::PlainLiteralNode.new('test', 'en')
+    assert !node.eql?(nil)
+    assert !node.eql?(RDF::PlainLiteralNode.new('test'))
+    assert !node.eql?(RDF::PlainLiteralNode.new('test2', 'en'))
+    assert !node.eql?(RDF::PlainLiteralNode.new('test', 'fr'))
+  end
+  
+  def test_should_have_same_hash
+    assert_equal RDF::PlainLiteralNode.new('test').hash,
+                 RDF::PlainLiteralNode.new('test').hash
+    assert_equal RDF::PlainLiteralNode.new('test', 'en').hash,
+                 RDF::PlainLiteralNode.new('test', 'en').hash
+  end
+  
+  def test_should_export_to_ntriples_format
+    assert_equal '"test"', RDF::PlainLiteralNode.new('test').to_ntriples
+    assert_equal '"test"@en', RDF::PlainLiteralNode.new('test', 'en').to_ntriples
+    assert_equal '"test"', RDF::PlainLiteralNode.new('test').to_s
+    assert_equal '"\u0008\U00010000\t\n\r\"\\\\"@en',
+                 RDF::PlainLiteralNode.new([0x8, 0x10000, 0x9, 0xa, 0xd, 0x22, 0x5c].pack('U*'), 'en').to_ntriples
+  end
+  
+  def test_should_be_node
+    node = RDF::PlainLiteralNode.new('test')
+    
+    assert node.plain_literal_node?
+    assert node.literal_node?
+    assert node.node?
+  end
+end

data/test/rdf/sesame/base_test.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/../../test_helper.rb'
+
+class RDF::Sesame::BaseTest < Test::Unit::TestCase
+  def setup
+    @graph = RDF::Sesame::Base.new('http://localhost:8180/openrdf-sesame', 'test')
+    @graph.delete_all
+    RDF::unregister_all!
+    RDF::register(:ex => 'http://example.org/')
+  end
+  
+  def test_should_initialize_address_port_path_and_repository
+    assert_equal 'localhost', @graph.address
+    assert_equal 8180, @graph.port
+    assert_equal '/openrdf-sesame', @graph.path
+    assert_equal 'test', @graph.repository
+  end
+  
+  def test_should_be_empty
+    assert @graph.empty?
+  end
+  
+  def test_should_add_statement
+    @graph.add(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    assert_equal 1, @graph.size
+  end
+  
+  def test_should_import_data
+    @graph.import(<<-ENDL, :ntriples)
+      #{[RDF[:ex]::a, RDF[:ex]::b, RDF[:ex]::c].to_statement.to_ntriples}
+      #{[RDF[:ex]::d, RDF[:ex]::b, RDF[:ex]::e].to_statement.to_ntriples}
+    ENDL
+    assert_equal 2, @graph.size
+    assert @graph.include?([RDF[:ex]::a, RDF[:ex]::b, RDF[:ex]::c])
+    assert @graph.include?([RDF[:ex]::d, RDF[:ex]::b, RDF[:ex]::e])
+  end
+  
+  def test_should_delete_statement
+    @graph.add(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    @graph.delete(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    assert @graph.empty?
+  end
+  
+  def test_should_execute_select_query
+    assert @graph.select("SELECT ?x WHERE {?x #{RDF[:ex]::nothing} _:bn2 . }").empty?
+    
+    @graph.add(RDF[:ex]::a, RDF[:ex]::b, RDF::PlainLiteralNode.new('test'))
+    @graph.add(RDF[:ex]::d, RDF[:ex]::b, RDF::PlainLiteralNode.new('test', 'en'))
+    @graph.add(RDF[:ex]::d, RDF[:ex]::b, RDF::TypedLiteralNode.new('test', RDF[:ex]::a.uri))
+    @graph.add(RDF[:ex]::d, RDF[:ex]::b, RDF[:ex]::e)
+    @graph.add(RDF[:ex]::d, RDF[:ex]::b, RDF::BlankNode.new)
+    result = @graph.select("SELECT ?y WHERE {?x #{RDF[:ex]::b} ?y . }")
+    assert_equal 5, result.size
+    assert result.any?{|r| r['y'] == RDF::PlainLiteralNode.new('test')}
+    assert result.any?{|r| r['y'] == RDF::PlainLiteralNode.new('test', 'en')}
+    assert result.any?{|r| r['y'] == RDF::TypedLiteralNode.new('test', RDF[:ex]::a.uri)}
+    assert result.any?{|r| r['y'] == RDF[:ex]::e}
+    assert result.any?{|r| r['y'].blank_node?}
+  end
+  
+  def test_should_execute_ask_query
+    @graph.add(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    assert @graph.ask("ask { #{[RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj].to_statement.to_ntriples} }")
+  end
+  
+  def test_should_include_statement
+    @graph.add(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    assert @graph.include?(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+  end
+  
+  def test_should_clear_graph
+    @graph.add(RDF[:ex]::sub, RDF[:ex]::pred, RDF[:ex]::obj)
+    @graph.delete_all
+    
+    assert @graph.empty?
+  end
+end

data/test/rdf/sparql_result_test.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::SparqlResultTest < Test::Unit::TestCase
+  def setup
+    RDF.unregister_all!
+    RDF.register(:ex => 'http://example.com/')
+  end
+  
+  def test_should_preserve_blank_node_identity
+    result = RDF::SparqlResult.new(<<-ENDL)
+      <?xml version='1.0' encoding='UTF-8'?>
+      <sparql xmlns='http://www.w3.org/2005/sparql-results#'>
+        <head>
+          <variable name='x'/>
+        </head>
+        <results>
+          <result>
+            <binding name='x'>
+              <bnode>bn1</bnode>
+            </binding>
+          </result>
+          <result>
+            <binding name='x'>
+              <bnode>bn1</bnode>
+            </binding>
+          </result>
+        </results>
+      </sparql>
+    ENDL
+    
+    assert_same result[0]['x'], result[1]['x']
+  end
+  
+  def test_should_parse_uri_node
+    result = RDF::SparqlResult.new(<<-ENDL)
+      <?xml version='1.0' encoding='UTF-8'?>
+      <sparql xmlns='http://www.w3.org/2005/sparql-results#'>
+        <head>
+          <variable name='x'/>
+        </head>
+        <results>
+          <result>
+            <binding name='x'>
+              <uri>http://example.com/a</uri>
+            </binding>
+          </result>
+        </results>
+      </sparql>
+    ENDL
+    
+    assert_equal RDF[:ex]::a, result[0]['x']
+  end
+  
+  def test_should_parse_plain_literal_node
+    result = RDF::SparqlResult.new(<<-ENDL)
+      <?xml version='1.0' encoding='UTF-8'?>
+      <sparql xmlns='http://www.w3.org/2005/sparql-results#'>
+        <head>
+          <variable name='x'/>
+        </head>
+        <results>
+          <result>
+            <binding name='x'>
+              <literal>test</literal>
+            </binding>
+          </result>
+        </results>
+      </sparql>
+    ENDL
+    
+    assert_equal RDF::PlainLiteralNode.new('test'), result[0]['x']
+    
+    result = RDF::SparqlResult.new(<<-ENDL)
+      <?xml version='1.0' encoding='UTF-8'?>
+      <sparql xmlns='http://www.w3.org/2005/sparql-results#'>
+        <head>
+          <variable name='x'/>
+        </head>
+        <results>
+          <result>
+            <binding name='x'>
+              <literal xml:lang='en'>test</literal>
+            </binding>
+          </result>
+        </results>
+      </sparql>
+    ENDL
+    
+    assert_equal RDF::PlainLiteralNode.new('test', 'en'), result[0]['x']
+  end
+  
+  def test_should_parse_typed_literal_node
+    result = RDF::SparqlResult.new(<<-ENDL)
+      <?xml version='1.0' encoding='UTF-8'?>
+      <sparql xmlns='http://www.w3.org/2005/sparql-results#'>
+        <head>
+          <variable name='x'/>
+        </head>
+        <results>
+          <result>
+            <binding name='x'>
+              <literal datatype='http://example.com/a'>test</literal>
+            </binding>
+          </result>
+        </results>
+      </sparql>
+    ENDL
+    
+    assert_equal RDF::TypedLiteralNode.new('test', 'http://example.com/a'), result[0]['x']
+  end
+  
+  def test_should_validate_data
+    assert_raises(RDF::SparqlResult::InvalidDocument) {
+      RDF::SparqlResult.new('<test>')
+    }
+  end
+end

data/test/rdf/statement_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::StatementTest < Test::Unit::TestCase
+  def setup
+    RDF.unregister_all!
+    RDF.register(:ex => 'http://example.org/')
+    @ex = RDF[:ex]
+  end
+  
+  def test_should_initialize_subject_predicate_and_object
+    stmt = RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj)
+    assert_equal @ex::sub, stmt.subject
+    assert_equal @ex::pred, stmt.predicate
+    assert_equal @ex::obj, stmt.object
+  end
+  
+  def test_should_validate_subject
+    assert_raise(RDF::Statement::InvalidSubjectError) {
+      RDF::Statement.new(RDF::PlainLiteralNode.new('test'), @ex::pred, @ex::obj)
+    }
+  end
+  
+  def test_should_validate_predicate
+    assert_raise(RDF::Statement::InvalidPredicateError) {
+      RDF::Statement.new(@ex::sub, RDF::PlainLiteralNode.new('test'), @ex::obj)
+    }
+  end
+  
+  def test_should_validate_object
+    assert_raise(RDF::Statement::InvalidObjectError) {
+      RDF::Statement.new(@ex::sub, @ex::pred, 'test')
+    }
+  end
+  
+  def test_should_be_eq
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj) ==
+           RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj)
+  end
+  
+  def test_should_not_be_eq
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj) != nil
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj) !=
+           RDF::Statement.new(@ex::sub2, @ex::pred, @ex::obj)
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj) !=
+           RDF::Statement.new(@ex::sub, @ex::pred2, @ex::obj)
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj) !=
+           RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj2)
+  end
+  
+  def test_should_be_eql
+    assert RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).eql?(
+      RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj))
+  end
+  
+  def test_should_not_be_eql
+    assert !RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).eql?(nil)
+    assert !RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).eql?(
+      RDF::Statement.new(@ex::sub2, @ex::pred, @ex::obj))
+    assert !RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).eql?(
+      RDF::Statement.new(@ex::sub, @ex::pred2, @ex::obj))
+    assert !RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).eql?(
+      RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj2))
+  end
+  
+  def test_should_have_same_hash
+    assert_equal RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).hash,
+                 RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).hash
+  end
+  
+  def test_should_export_to_ntriples_format
+    assert_equal '<http://example.org/sub> <http://example.org/pred> <http://example.org/obj> .',
+                 RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).to_ntriples
+    assert_equal '<http://example.org/sub> <http://example.org/pred> <http://example.org/obj> .',
+                 RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj).to_s
+  end
+  
+  def test_should_be_statement
+    stmt = RDF::Statement.new(@ex::sub, @ex::pred, @ex::obj)
+    assert_same stmt, stmt.to_statement
+    assert_same stmt, [stmt].to_statement
+    assert_equal stmt, [@ex::sub, @ex::pred, @ex::obj].to_statement
+  end
+end

data/test/rdf/typed_literal_node_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::TypedLiteralNodeTest < Test::Unit::TestCase
+  def test_should_initialize_lexical_form_and_datatype_uri
+    node = RDF::TypedLiteralNode.new('test', 'http://stadig.name/')
+    assert_equal 'test', node.lexical_form
+    assert_equal 'http://stadig.name/', node.datatype_uri
+  end
+  
+  def test_should_initialize_datatype_uri
+    assert_equal 'http://stadig.name/',
+                  RDF::TypedLiteralNode.new('test', RDF::URINode.new('http://stadig.name/')).datatype_uri
+  end
+  
+  def test_should_normalize_lexical_form_and_datatype_uri
+    node = RDF::TypedLiteralNode.new([0x2126].pack('U'), [0x2126].pack('U'))
+    assert_equal [0x03a9].pack('U'), node.lexical_form
+    assert_equal [0x03a9].pack('U'), node.datatype_uri
+  end
+  
+  def test_should_be_eq
+    assert RDF::TypedLiteralNode.new('test', 'http://stadig.name/') ==
+           RDF::TypedLiteralNode.new('test', 'http://stadig.name/')
+  end
+  
+  def test_should_not_be_eq
+    assert RDF::TypedLiteralNode.new('test', 'http://stadig.name/') != 
+           nil
+    assert RDF::TypedLiteralNode.new('test', 'http://stadig.name/') !=
+           RDF::TypedLiteralNode.new('test2', 'http://stadig.name/')
+    assert RDF::TypedLiteralNode.new('test', 'http://stadig.name/') !=
+           RDF::TypedLiteralNode.new('test', 'http://example.com/')
+  end
+  
+  def test_should_be_eql
+    assert RDF::TypedLiteralNode.new('test', 'http://stadig.name/').eql?(
+      RDF::TypedLiteralNode.new('test', 'http://stadig.name/'))
+  end
+  
+  def test_should_not_be_eql
+    assert !RDF::TypedLiteralNode.new('test', 'http://stadig.name/').eql?(nil)
+    assert !RDF::TypedLiteralNode.new('test', 'http://stadig.name/').eql?(
+      RDF::TypedLiteralNode.new('test2', 'http://stadig.name/'))
+    assert !RDF::TypedLiteralNode.new('test', 'http://stadig.name/').eql?(
+      RDF::TypedLiteralNode.new('test', 'http://example.com/'))
+  end
+  
+  def test_should_have_same_hash
+    assert_equal RDF::TypedLiteralNode.new('test', 'http://stadig.name/').hash,
+                 RDF::TypedLiteralNode.new('test', 'http://stadig.name/').hash
+  end
+  
+  def test_should_export_to_ntriples_format
+    assert_equal '"test"^^<http://stadig.name/>', RDF::TypedLiteralNode.new('test', 'http://stadig.name/').to_ntriples
+    assert_equal '"\u0008\U00010000\t\n\r\"\\\\"^^<\u0008\U00010000\t\n\r\"\\\\>',
+                 RDF::TypedLiteralNode.new([0x8, 0x10000, 0x9, 0xa, 0xd, 0x22, 0x5c].pack('U*'), 
+                                           [0x8, 0x10000, 0x9, 0xa, 0xd, 0x22, 0x5c].pack('U*')).to_ntriples
+  end
+  
+  def test_should_be_node
+    node = RDF::TypedLiteralNode.new('test', 'http://stadig.name/')
+    
+    assert node.typed_literal_node?
+    assert node.literal_node?
+    assert node.node?
+  end
+end

data/test/rdf/uri_node_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class RDF::URINodeTest < Test::Unit::TestCase
+  def test_should_initialize_uri
+    assert_equal 'http://stadig.name/', RDF::URINode.new('http://stadig.name/').uri
+  end
+  
+  def test_should_normalize_uri
+    assert_equal [0x03a9].pack('U'), RDF::URINode.new([0x2126].pack('U')).uri
+  end
+  
+  def test_should_export_to_ntriples_format
+    assert_equal '<http://stadig.name/>', RDF::URINode.new('http://stadig.name/').to_ntriples
+    assert_equal '<http://stadig.name/>', RDF::URINode.new('http://stadig.name/').to_s
+    assert_equal '<http://stadig.name/\u0008\U00010000\t\n\r\"\\\\>',
+                 RDF::URINode.new('http://stadig.name/' + [0x8, 0x10000, 0x9, 0xa, 0xd, 0x22, 0x5c].pack('U*')).to_ntriples
+  end
+  
+  def test_should_be_eq
+    node = RDF::URINode.new('http://stadig.name/')
+    assert node == RDF::URINode.new(node.uri)
+  end
+  
+  def test_should_not_be_eq
+    node = RDF::URINode.new('http://stadig.name/')
+    assert node != nil
+    assert node != RDF::URINode.new(node.uri + 'test')
+  end
+  
+  def test_should_be_eql
+    node = RDF::URINode.new('http://stadig.name/')
+    assert node.eql?(RDF::URINode.new(node.uri))
+  end
+  
+  def test_should_not_be_eql
+    node = RDF::URINode.new('http://stadig.name/')
+    assert !node.eql?(nil)
+    assert !node.eql?(RDF::URINode.new(node.uri + 'test'))
+  end
+  
+  def test_should_have_same_hash
+    node = RDF::URINode.new('http://stadig.name/')
+    assert node.hash == RDF::URINode.new(node.uri).hash
+  end
+  
+  def test_should_be_node
+    node = RDF::URINode.new('http://stadig.name/')
+    
+    assert node.uri_node?
+    assert node.resource?
+    assert node.node?
+  end
+end

data/test/rdf_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class RDFTest < Test::Unit::TestCase
+  def setup
+    RDF.unregister_all!
+  end
+  
+  def test_should_register_defaults
+    assert_equal 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', RDF.prefix(:rdf)
+    assert_equal 'http://www.w3.org/2001/XMLSchema#', RDF.prefix(:xsd)
+    assert_equal 'http://www.w3.org/2000/01/rdf-schema#', RDF.prefix(:rdfs)
+    assert_equal 'http://www.w3.org/2002/07/owl#', RDF.prefix(:owl)
+  end
+  
+  def test_should_not_unregister_defaults
+    RDF.unregister_all!
+    assert_equal 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', RDF.prefix(:rdf)
+    assert_equal 'http://www.w3.org/2001/XMLSchema#', RDF.prefix(:xsd)
+    assert_equal 'http://www.w3.org/2000/01/rdf-schema#', RDF.prefix(:rdfs)
+    assert_equal 'http://www.w3.org/2002/07/owl#', RDF.prefix(:owl)
+  end
+  
+  def test_should_unregister
+    RDF.register(:ps => 'http://paul.stadig.name/',
+                 :ex => 'http://example.com/')
+    RDF.unregister(:ps, :ex)
+    assert !RDF.registered?(:ps)
+    assert !RDF.registered?(:ex)
+  end
+  
+  def test_should_unregister_all
+    RDF.register(:ps => 'http://paul.stadig.name/',
+                 :ex => 'http://example.com/')
+    RDF.unregister_all!
+    assert !RDF.registered?(:ps)
+    assert !RDF.registered?(:ex)
+  end
+  
+  def test_should_register
+    RDF.register(:ps => 'http://paul.stadig.name/',
+                 'ex' => 'http://example.com/')
+    assert RDF.registered?(:ps)
+    assert RDF.registered?(:ex)
+  end
+  
+  def test_should_expand_uri
+    RDF.register(:ex => 'http://example.com/')
+    assert_equal 'http://example.com/test', RDF.expand_uri(:ex, 'test')
+  end
+  
+  def test_should_expand_node
+    RDF.register(:ex => 'http://example.com/')
+    node = RDF::URINode.new('http://example.com/test')
+    assert_equal node, RDF.expand_node(:ex, 'test')
+    assert_equal node, RDF[:ex]::test
+    assert_equal node, RDF[:ex].test
+    assert_equal node, RDF[:ex]['test']
+    assert_equal node, RDF[:ex][:test]
+    assert_equal node, RDF['ex'][:test]
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/rubyrdf'

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: pjstadig-rubyrdf
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Stadig
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Resource Description Framework (RDF) library for Ruby.
+email: 
+- paul@stadig.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- PostInstall.txt
+- README.txt
+- TODO.txt
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- PostInstall.txt
+- README.txt
+- Rakefile
+- TODO.txt
+- lib/rdf.rb
+- lib/rdf/blank_node.rb
+- lib/rdf/error.rb
+- lib/rdf/node.rb
+- lib/rdf/plain_literal_node.rb
+- lib/rdf/sesame/base.rb
+- lib/rdf/sparql_result.rb
+- lib/rdf/statement.rb
+- lib/rdf/typed_literal_node.rb
+- lib/rdf/uri_node.rb
+- lib/rdf/version.rb
+- lib/rubyrdf.rb
+- test/rdf/blank_node_test.rb
+- test/rdf/plain_literal_node_test.rb
+- test/rdf/sesame/base_test.rb
+- test/rdf/sparql_result_test.rb
+- test/rdf/statement_test.rb
+- test/rdf/typed_literal_node_test.rb
+- test/rdf/uri_node_test.rb
+- test/rdf_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/pjstadig/rubyrdf/wikis
+post_install_message: |+
+  
+  For more information on rubyrdf, see http://rubyrdf.rubyforge.org
+  
+  NOTE: Change this information in PostInstall.txt 
+  You can also delete it if you don't want it.
+  
+  
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubyrdf
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Resource Description Framework (RDF) library for Ruby.
+test_files: 
+- test/rdf/blank_node_test.rb
+- test/rdf/statement_test.rb
+- test/rdf/plain_literal_node_test.rb
+- test/rdf/sparql_result_test.rb
+- test/rdf/typed_literal_node_test.rb
+- test/rdf/uri_node_test.rb
+- test/rdf/sesame/base_test.rb
+- test/rdf_test.rb