rubyrdf 0.0.1

data/lib/rdf/graph/memory.rb

@@ -0,0 +1,146 @@
+require 'set'
+
+module RDF
+  module Graph
+    # An in-memory, pure Ruby implementation of an RDF graph.  This graph implementation also serves as an example of the interface that every graph implementation should have.
+    class Memory < Base
+      include RDF::Query::Executer
+      
+      # Creates a new Graph.
+      def initialize
+        super
+        @triples = Set.new
+        @idx_s = Hash.new{|h, k| h[k] = Set.new}
+        @idx_sp = Hash.new{|h, k| h[k] = Set.new}
+        @idx_blank = Hash.new(0)
+      end
+      
+      # Adds a triple to the graph.  Will accept an instance of Triple, or three parameters for the subject, predicate, and object.
+      def add(*triple)
+        triple = Triple.construct(*triple)
+        
+        # perform some syntax checks
+        raise RDF::UnassociatedBlankNodeError, "#{triple.subject} is not associated with this graph" if RDF::BlankNode?(triple.subject) && triple.subject.graph != self
+        raise RDF::UnassociatedBlankNodeError, "#{triple.object} is not associated with this graph" if RDF::BlankNode?(triple.object) && triple.object.graph != self
+        
+        index_subject(triple)
+        index_subject_and_predicate(triple)
+        index_blank(triple.subject) if RDF::BlankNode?(triple.subject)
+        index_blank(triple.object) if RDF::BlankNode?(triple.object)
+        @triples << triple
+      end
+      
+      # Deletes +triple+ from the graph.  Will accept an instance of Triple, or three parameters for the subject, predicate, and object.
+      def delete(*triple)
+        triple = Triple.construct(*triple)
+        unindex_subject(triple)
+        unindex_subject_and_predicate(triple)
+        unindex_blank(triple.subject) if RDF::BlankNode?(triple.subject)
+        unindex_blank(triple.object) if RDF::BlankNode?(triple.object)
+        @triples.delete(triple)
+      end
+      
+      # Returns true if graph contains +triple+.  Will accept an instance of Triple, or three parameters for the subject, predicate, and object.
+      def include?(*triple)
+        triple = Triple.construct(*triple)
+        @triples.include?(triple)
+      end
+      
+      # Iterates through all of the triples in this graph.
+      def each(&b)
+        @triples.each(&b)
+      end
+      
+      # Returns the number of triples in this graph.
+      def size
+        @triples.size
+      end
+      
+      private
+        def index_subject(triple)
+          @idx_s[triple.subject] ||= Set.new
+          @idx_s[triple.subject] << triple.predicate
+        end
+        
+        def index_subject_and_predicate(triple)
+          @idx_sp[[triple.subject, triple.predicate]] ||= Set.new
+          @idx_sp[[triple.subject, triple.predicate]] << triple.object
+        end
+        
+        def index_blank(node)
+          @idx_blank[node] += 1
+        end
+        
+        def unindex_subject(triple)
+          if @idx_s[triple.subject]
+            @idx_s[triple.subject].delete(triple.predicate)
+            @idx_s.delete(triple.subject) if @idx_s[triple.subject].empty?
+          end
+        end
+        
+        def unindex_subject_and_predicate(triple)
+          sp = [triple.subject, triple.predicate]
+          if @idx_sp[sp]
+            @idx_sp[sp].delete(triple.object)
+            @idx_sp.delete(sp) if @idx_sp[sp].empty?
+          end
+        end
+        
+        def unindex_blank(node)
+          if @idx_blank[node] > 0
+            @idx_blank[node] -= 1
+            @idx_blank.delete(node) if @idx_blank[node] == 0 && @idx_blank.key?(node)
+          end
+        end
+        
+        def match_binding(s, p, o, b)
+          if (s.is_a?(Symbol) || (RDF::BlankNode?(s) && !@idx_blank.key?(s))) && !b.bound?(s)
+            result = @idx_s.keys.inject(RDF::Query::Result.new) do |r, node|
+              binding = b.clone
+              binding[s] = node
+              r.bindings << binding
+              r
+            end
+            result = match(s, p, o, result)
+            result
+          else
+            bind_predicate(s, p, o, b)
+          end
+        end
+        
+        def bind_predicate(s, p, o, b)
+          if p.is_a?(Symbol) && !b.bound?(p)
+            result = @idx_s[b[s]].inject(RDF::Query::Result.new) do |r, node|
+              binding = b.clone
+              binding[p] = node
+              r.bindings << binding
+              r
+            end
+            result = match(s, p, o, result)
+            result
+          else
+            bind_object(s, p, o, b)
+          end
+        end
+        
+        def bind_object(s, p, o, b)
+          if (o.is_a?(Symbol) || (RDF::BlankNode?(o) && !@idx_blank.key?(o))) && !b.bound?(o)
+            result = @idx_sp[[b[s],b[p]]].inject(RDF::Query::Result.new) do |r, node|
+              binding = b.clone
+              binding[o] = node
+              r.bindings << binding
+              r
+            end
+            
+            match(s, p, o, result)
+          else
+            if @triples.include?(Triple.new(b[s], b[p], b[o]))
+              RDF::Query::Result.success!(b)
+            else
+              RDF::Query::Result.new
+            end
+          end
+        end
+    end
+  end
+end

data/lib/rdf/graph/tests.rb

@@ -0,0 +1,137 @@
+module RDF
+  module Graph
+    module Tests
+      ##== add ==##
+      def test_add_should_insert_triple
+        @graph.add(RDF::Triple.new(EX::a, EX::b, EX::c))
+        assert @graph.include?(RDF::Triple.new(EX::a, EX::b, EX::c)),
+          "Add should accept an RDF::Triple as a parameter"
+      end
+      
+      def test_add_should_insert_spo
+        @graph.add(EX::a, EX::b, EX::c)
+        assert @graph.include?(RDF::Triple.new(EX::a, EX::b, EX::c)),
+          "Add should accept three nodes as parameters"
+      end
+      
+      def test_add_should_raise_error_for_unassociated_blank_node_subject
+        assert_raise(RDF::UnassociatedBlankNodeError) {
+          @graph.add(RDF::Graph::Memory.new.new_blank_node('x'), EX::b, EX::c)
+        }
+      end
+      
+      def test_add_should_raise_error_for_unassociated_blank_node_object
+        assert_raise(RDF::UnassociatedBlankNodeError) {
+          @graph.add(EX::a, EX::b, RDF::Graph::Memory.new.new_blank_node('x'))
+        }
+      end
+      
+      ##== include? ==##
+      def test_include_should_accept_spo
+        @graph.add(RDF::Triple.new(EX::a, EX::b, EX::c))
+        assert @graph.include?(EX::a, EX::b, EX::c)
+      end
+      
+      ##== delete ==##
+      def test_delete_should_remove_triple
+        @graph.add(RDF::Triple.new(EX::a, EX::b, EX::c))
+        @graph.delete(RDF::Triple.new(EX::a, EX::b, EX::c))
+        assert !@graph.include?(RDF::Triple.new(EX::a, EX::b, EX::c))
+      end
+      
+      def test_delete_should_remove_spo
+        @graph.add(RDF::Triple.new(EX::a, EX::b, EX::c))
+        @graph.delete(EX::a, EX::b, EX::c)
+        assert !@graph.include?(RDF::Triple.new(EX::a, EX::b, EX::c))
+      end
+      
+      ##== empty? ==##
+      def test_empty_should_be_true_for_empty_graph
+        assert @graph.empty?
+      end
+      
+      def test_empty_should_not_be_true_for_non_empty_graph
+        @graph.add(RDF::Triple.new(EX::a, EX::b, EX::c))
+        assert !@graph.empty?
+      end
+      
+      ##== new_blank_node ==##
+      def test_new_blank_node_should_be_a_blank_node
+        assert RDF::BlankNode?(@graph.new_blank_node('test'))
+      end
+      
+      def test_new_blank_node_should_set_graph
+        assert_equal @graph, @graph.new_blank_node('test').graph
+      end
+      
+      def test_new_blank_node_should_set_name
+        assert_equal 'test', @graph.new_blank_node('test').name
+      end
+      
+      ##== each ==##
+      def test_each_should_iterate_all_nodes
+        triples = [RDF::Triple.new(EX::a, EX::b, EX::c),
+        RDF::Triple.new(EX::d, EX::e, EX::f),
+        RDF::Triple.new(EX::g, EX::h, EX::i)]
+        @graph.add(triples[0])
+        @graph.add(triples[1])
+        @graph.add(triples[2])
+        
+        @graph.each do |t|
+          assert triples.delete(t)
+        end
+        assert_equal [], triples
+      end
+      
+      ##== size ==##
+      def test_size_should_be_zero_for_empty_graph
+        assert_equal 0, @graph.size
+      end
+      
+      def test_size_should_be_number_of_triples
+        @graph.add(EX::a, EX::b, EX::c)
+        @graph.add(EX::d, EX::e, EX::f)
+        assert 2, @graph.size
+      end
+      
+      ##== merge ==##
+      def test_merge_should_copy_triples
+        new_graph = RDF::Graph::Memory.new
+        new_graph.add(EX::a, EX::b, new_graph.new_blank_node('x'))
+        @graph.merge(new_graph)
+        assert @graph.execute(RDF::Query.new.where(EX::a, EX::b, :a)).success?
+      end
+      
+      def test_merge_should_associate_blank_nodes_with_new_graph
+        new_graph = RDF::Graph::Memory.new
+        x = new_graph.new_blank_node('x')
+        new_graph.add(EX::a, EX::b, x)
+        @graph.merge(new_graph)
+        assert_equal @graph, @graph.execute(RDF::Query.new.where(EX::a, EX::b, :a)).bindings.to_a.first[:a].graph
+      end
+      
+      ##== execute ==##
+      def query_executer_test_case
+        @graph.add(EX::a, EX::b, EX::c)
+        @graph.add(EX::c, EX::e, EX::f)
+        q = RDF::Query.new
+        q.where(EX::a, EX::b, :a)
+        q.where(:a, EX::e, EX::f)
+        
+        @graph.execute(q)
+      end
+      
+      def test_execute_should_return_result
+        assert query_executer_test_case.is_a?(RDF::Query::Result)
+      end
+      
+      def test_execute_should_succeed
+        assert query_executer_test_case.success?
+      end
+      
+      def test_execute_should_assign_variable
+        assert_equal EX::c, query_executer_test_case.bindings.to_a.first[:a]
+      end
+    end
+  end
+end

data/lib/rdf/namespace.rb

@@ -0,0 +1,90 @@
+module RDF
+  # An RDF namespace that can be used to generate URI references easily.
+  #
+  # Example:
+  #
+  #   RDF::Namespace.register(:ex, 'http://example.com/')
+  #   EX::Test   #=> 'http://example.com/Test'
+  #   EX::test   #=> 'http://example.com/test'
+  module Namespace
+    @@prefixes = {}
+    @@bases = {}
+    
+    class << self
+      # Returns an array of all registered prefixes.
+      def prefixes
+        @@prefixes.keys
+      end
+      
+      # Returns true if the specified +prefix+ is registered.
+      def registered?(prefix)
+        @@prefixes.key?(prefix)
+      end
+      
+      # Registers +prefix+ as a nickname for +base+, and either finds an existing module, 
+      # or creates a new module named +prefix+ that can be used for expansions.
+      def register(prefix, base)
+        raise ArgumentError, "prefix cannot be nil" if prefix.to_s.empty?
+        
+        prefix, base = prefix.to_s.to_sym, base.to_s
+        
+        raise ArgumentError, "base is invalid it should end with '/' or '#'" unless ['/', '#'].include?(base[-1,1])
+        if @@prefixes.has_key?(prefix)
+          $stderr.puts "Warning: Namespace #{prefix} is already defined"
+          return find_or_create_module(prefix)
+        end
+        
+        @@prefixes[prefix] = base
+        @@bases[base] = prefix
+        
+        mod = find_or_create_module(prefix)
+        class << mod
+          def method_missing(sym, *a, &b)
+            raise ArgumentError, "Unexpected arguments for Namespace.expand" if a.size > 0
+            RDF::UriNode.new(Namespace.expand(self, sym))
+          end
+          
+          def const_missing(sym)
+            RDF::UriNode.new(Namespace.expand(self, sym))
+          end
+          
+          [:type, :name, :id].each{|a| private(a)}
+        end
+        mod
+      end
+      
+      # Returns the string resulting from looking up the prefix and appending the name
+      def expand(prefix, name)
+        prefix, name = prefix.to_s.downcase.to_sym, name.to_s
+        @@prefixes[prefix] + name
+      end
+      
+      # Finds the last '/' or '#' and uses it to split the uri into base and name parts.
+      def split(uri)
+        uri = uri.to_s
+        i = uri.rindex(/\/|#/) + 1
+        [uri[0...i].to_s, uri[i..-1].to_s]
+      end
+      
+      # Returns the assigned prefix name for a uri, if one exists
+      def prefix(uri)
+        @@bases[split(uri).first]
+      end
+      
+      private
+        def find_or_create_module(name)
+          name = name.to_s.upcase
+          
+          unless Object.const_defined?(name)
+            Object.const_set(name, Module.new)
+          end
+          Object.const_get(name)
+        end
+    end
+  end
+  
+  Namespace.register(:rdf, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+  Namespace.register(:rdfs, 'http://www.w3.org/2000/01/rdf-schema#')
+  Namespace.register(:owl, 'http://www.w3.org/2002/07/owl#')
+  Namespace.register(:xsd, 'http://www.w3.org/2001/XMLSchema#')
+end

data/lib/rdf/plain_literal_node.rb

@@ -0,0 +1,36 @@
+module RDF
+  # A plain literal node.
+  class PlainLiteralNode
+    # the lexical form of this LiteralNode.
+    attr_reader :lexical_form
+    # the language tag (if any) of this LiteralNode.
+    attr_reader :language_tag
+    
+    # Creates a new literal node with the specified +lexical_form+ and +language_tag+.
+    def initialize(lexical_form, language_tag = nil)
+      @lexical_form = lexical_form
+      @language_tag = language_tag
+    end
+    
+    # Returns true if +o+ is a PlainLiteralNode with the same +lexical_form+ and
+    # +language_tag+ (if any).
+    def ==(o)
+      if RDF::PlainLiteralNode?(o)
+        lexical_form == o.lexical_form &&
+        language_tag.to_s.downcase == o.language_tag.to_s.downcase
+      end
+    end
+    
+    alias :eql? :==
+    
+    # Returns a hash value for this PlainLiteralNode.
+    def hash
+      [-1025818701, lexical_form.hash, language_tag.to_s.downcase.hash].hash
+    end
+    
+    # Returns the NTriples representation of this PlainLiteralNode.
+    def to_s
+      Format::NTriples.export_node(self)
+    end
+  end
+end

data/lib/rdf/query/binding.rb

@@ -0,0 +1,68 @@
+module RDF
+  class Query
+    # A single binding of variables in an Graph.
+    class Binding
+      # Creates a new instange of Binding initializing it with +hash+, or an empty Hash if +hash+ is nil.
+      def initialize(hash = nil)
+        @hash = hash || {}
+      end
+      
+      # Copy constructor that creates a deep copy of this binding.
+      def initialize_copy(o)
+        @hash = o.instance_variable_get('@hash').clone
+      end
+      
+      # Returns true if +key+ is bound in this binding.
+      def bound?(key)
+        @hash.key?(key)
+      end
+      
+      # Returns the value bound to +key+ if +key+ is bound in this binding, or +key+ otherwise.
+      def [](key)
+        @hash.key?(key) ? @hash[key] : key
+      end
+      
+      # Binds +key+ to +value+ in this binding.
+      def []=(key, value)
+        @hash[key] = value
+      end
+      
+      # Returns true if this binding is empty, false otherwise.
+      def empty?
+        @hash.empty?
+      end
+      
+      # Returns true if +o+ is a Binding and it has the same bindings.
+      def ==(o)
+        if o.is_a?(Binding)
+          @hash.each_pair do |k,v|
+            return false unless o[k] == v
+          end
+          
+          ohash = o.instance_variable_get('@hash')
+          ohash.each_pair do |k,v|
+            return false unless @hash[k] == v
+          end
+          
+          true
+        end
+      end
+      
+      alias :eql? :==
+      
+      # Returns a hash value for this binding.
+      def hash
+        h = -901662846
+        @hash.each_pair do |k,v|
+          h ^= (h << 5) + k.hash + (h >> 2)
+          h ^= (h << 5) + v.hash + (h >> 2)
+        end
+        h
+      end
+      
+      def to_s
+        "{#{@hash.collect{|k,v| "#{k} => #{v}"}.join(", ")}}"
+      end
+    end
+  end
+end

data/lib/rdf/query/executer.rb

@@ -0,0 +1,42 @@
+module RDF
+  class Query
+    # A mix-in module for graph implementations.  If a Graph implementation
+    # cannot delegate the +execute+ method to the underlying triplestore, then
+    # this module can be mixed in to provide Query execution.  The graph must
+    # only implement the +match+ method.
+    module Executer
+      # Returns the result of executing +query+ on this graph.
+      def execute(query)
+        result = nil
+        
+        where_clause = query.where_clause
+        begin
+          s, p, o = where_clause.shift
+          result = match(s, p, o, result)
+        end while where_clause.any? && result.success?
+        
+        result
+      end
+      
+      # Performs a match of +s+, +p+, and +o+ and returns a set of bindings.
+      #
+      # If +s+, +p+, or +o+ are Ruby symbols, then they will be considered
+      # variables, and they will be bound to all possible nodes in the result.
+      # 
+      # If +s+, +p+, or +o+ are BlankNodes that are unassociated with this
+      # graph, then they will be bound to all possible nodes in the result.
+      def match(s, p, o, result = nil)
+        if result.nil?
+          result = match_binding(s, p, o, RDF::Query::Binding.new)
+          result
+        else
+          result = result.bindings.inject(RDF::Query::Result.new) do |r, b|
+            r << match_binding(s, p, o, b)
+            r
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/rdf/query/result.rb

@@ -0,0 +1,54 @@
+module RDF
+  class Query
+    # A set of bindings for a graph.
+    class Result
+      def self.success!(*a)
+        r = Result.new(*a)
+        r.success!
+        r
+      end
+      
+      attr_reader :bindings
+      
+      # Creates an instance of Result with the specified bindings.
+      def initialize(*bindings)
+        @success = false
+        @bindings = Set.new((bindings || []).flatten.reject{|b| b.empty?})
+      end
+      
+      # Returns true if the executed query failed.
+      def failure?
+        !@success
+      end
+      
+      # Returns true if the executed query succeeded.
+      def success?
+        @success
+      end
+      
+      # Sets the success indicator to true.
+      def success!
+        @success = true
+      end
+      
+      # Merges the Result +o+ into this Result.
+      def <<(o)
+        raise ArgumentError, "Must be RDF::Query::Result" unless o.is_a?(Result)
+        if o.success?
+          if failure?
+            success!
+            bindings.clear
+          end
+          
+          o.bindings.each do |b|
+            bindings << b unless b.empty?
+          end
+        end
+      end
+      
+      def to_s
+        "{#{bindings.collect{|b| b.to_s}.join(', ')}}"
+      end
+    end
+  end
+end

data/lib/rdf/query.rb

@@ -0,0 +1,54 @@
+module RDF
+  # An RDF graph query.  This represents a complex query that joins several triples.  To query for
+  # a simple triple, see the +match+ method on RDF::Graph::Memory.
+  #
+  # A Query is created then passed to the +execute+ method on a graph.  In some graph
+  # implementations the execute method may delegate to the underlying triple store, but
+  # in other cases the +execute+ method may be mixed in from RDF::Query::Executer.
+  # 
+  # At some point I'd like to steal the {query DSL}[http://projects.semwebcentral.org/cgi-bin/viewcvs.cgi/semitar/test/test_query.rb?rev=1.1.1.1&cvsroot=semitar&content-type=text/vnd.viewcvs-markup] from Semitar[http://semitar.projects.semwebcentral.org/].
+  # 
+  # Example:
+  #  q = RDF::Query.new.select(:a, :c).
+  #                     where(:a, RDF::type, :b).
+  #                     and(:b, RDFS::subClassOf, RDF::Property).
+  #                     and(:b, RDFS::comment, :c)
+  #  result = some_graph.execute(q)
+  class Query
+    class << self
+      alias :select :new
+    end
+    
+    # Creates a new Query.
+    def initialize
+      @select_clause = []
+      @where_clause = []
+    end
+    
+    # Adds items to the select clause of this query.  When this query is executed, the results will include
+    # bindings for these variables.
+    def select(*a)
+      @select_clause = a
+      self
+    end
+    
+    # Returns the select clause for this query.
+    def select_clause
+      @select_clause.clone
+    end
+    
+    # Adds the triple +s p o+ to the where clause of this query.  When the query is executed, the where clause
+    # will constrain the results.
+    def where(s, p, o)
+      @where_clause << [s, p, o]
+      self
+    end
+    
+    # Returns the where clause for this query.
+    def where_clause
+      @where_clause.clone
+    end
+    
+    alias :and :where
+  end
+end

data/lib/rdf/triple.rb

@@ -0,0 +1,61 @@
+module RDF
+  # A triple.
+  class Triple
+    def self.construct(*a)
+      if a.size == 1
+        a[0] if a[0].is_a?(Triple)
+      elsif a.size == 3
+        Triple.new(*a)
+      else
+        raise ArgumentError, 'Expected triple or subject, predicate, and object'
+      end
+    end
+    
+    # the subject of this triple
+    attr_reader :subject
+    # the predicate of this triple
+    attr_reader :predicate
+    # the object of this triple
+    attr_reader :object
+    
+    # Creates a new triple with the specified +subject+, +predicate+, and +object+.
+    # 
+    # Raises:
+    # ArgumentError:: if any of the parameters is nil.
+    # LiteralNodeSubjectError:: if +subject+ is a LiteralNode.
+    # LiteralNodePredicateError:: if +predicate+ is a LiteralNode.
+    # BlankNodePredicateError:: if +predicate+ is a BlankNode.
+    def initialize(subject, predicate, object)
+      @subject = subject
+      @predicate = predicate
+      @object = object
+      
+      raise ArgumentError, 'subject must be a node' unless RDF::Node?(@subject)
+      raise ArgumentError, 'predicate must be a node' unless RDF::Node?(@predicate)
+      raise ArgumentError, 'object must be a node' unless RDF::Node?(@object)
+      
+      raise RDF::InvalidSubjectError, "#{@subject} must be a blank or uri node" unless RDF::BlankNode?(@subject) || RDF::UriNode?(@subject)
+      raise RDF::InvalidPredicateError, "#{@predicate} must be a uri node" unless RDF::UriNode?(@predicate)
+    end
+    
+    # Returns true if +o+ is a Triple with the same +subject+, +object+, and +predicate+.
+    def ==(o)
+      if RDF::Triple?(o)
+        subject == o.subject &&
+        predicate == o.predicate &&
+        object == o.object
+      end
+    end
+    
+    alias :eql? :==
+    
+    # Returns a hash value for this Triple.
+    def hash
+      [-78640401, subject.hash, predicate.hash, object.hash].hash
+    end
+    
+    def to_s
+      "#{subject} #{predicate} #{object}."
+    end
+  end
+end