rubyrdf 0.0.1

data/lib/rdf/format/ntriples.rb

@@ -0,0 +1,493 @@
+require 'stringio'
+
+module RDF
+  module Format
+    # Import/Exports a graph to NTriples format.
+    class NTriples
+      # Raised when there is a syntax error in an input NTriples file.
+      class SyntaxError < RDF::Error; end
+      
+      # Exports a +graph+ to +file+ in NTriples format.
+      def self.export(graph, file)
+        graph.each do |t|
+          file.write(export_node(t.subject))
+          file.write(' ')
+          file.write(export_node(t.predicate))
+          file.write(' ')
+          file.write(export_node(t.object))
+          file.puts('.')
+        end
+      end
+      
+      # Returns a string NTriples representation of +node+.
+      def self.export_node(node)
+        case
+        when RDF::UriNode?(node)
+          "<#{node.uri}>"
+        when RDF::BlankNode?(node)
+          "_:#{node.name}"
+        when RDF::PlainLiteralNode?(node)
+          "\"#{node.lexical_form}\"" + (node.language_tag.to_s.empty? ? '' : "@#{node.language_tag}")
+        when RDF::TypedLiteralNode?(node)
+          "\"#{node.lexical_form}\"^^<#{node.datatype_uri}>"
+        else
+          raise SyntaxError, "Unknown node type"
+        end
+      end
+      
+      # Imports NTriples input +file+ to +graph+ or creates a new graph if +graph+ is nil.
+      def self.import(file, graph = nil)
+        NTriples.new(file, graph).import
+      end
+      
+      # Imports a string NTriples representation of a node into +graph+ or creates a new graph if +graph+ is nil.
+      def self.import_node(str, graph = nil)
+        NTriples.new(StringIO.new(str), graph).import_node
+      end
+      
+      # Creates an instance of NTriples for importing an NTriples +file+ into +graph+.
+      def initialize(file, graph = nil)
+        @lineno = 1
+        @charno = 1
+        @file = file.respond_to?(:getc) ? file : StringIO.new(file.to_s)
+        stretch_buf_to(1)
+        @graph = graph.nil? ? RDF::Graph::Memory.new : graph
+      end
+      
+      # Runs the import for this NTriples instance, and returns the graph.
+      def import
+        lines unless @file.eof?
+        @graph
+      end
+      
+      # Runs the import for a single node for this NTriples instance, and returns the node.
+      def import_node
+        if ws?
+          wses
+        end
+        
+        object
+      end
+      
+      private
+      def position
+        "line: #{@lineno}, char: #{@charno}"
+      end
+      
+      # All of the internal parsing methods follow
+      def stretch_buf_to(x)
+        @buf ||= ''
+        goal = x - @buf.length
+        while goal > 0 && !@file.eof?
+          @buf << @file.getc.chr
+          goal -= 1
+          @charno += 1
+        end
+      end
+      
+      def consume(str = nil)
+        if str.nil?
+          stretch_buf_to(2)
+          @buf.slice!(0).chr
+        elsif test(str)
+          stretch_buf_to(str.length + 1)
+          
+          if @buf.length >= str.length
+            @buf.slice!(0, str.length)
+          end
+        else
+          raise SyntaxError, "Expected #{str} at #{position}"
+        end
+      end
+      
+      def test(str)
+        stretch_buf_to(str.length)
+        @buf[0, str.length] == str
+      end
+      
+      def peek
+        @buf[0, 1]
+      end
+      
+      def unescape(str)
+        str
+      end
+      
+      ## Parsing Methods
+      def lines
+        line
+        while line?
+          line
+        end
+      end
+      
+      def line
+        @charno = 1
+        if ws?
+          wses
+        end
+        
+        case
+        when comment?
+          comment
+          eoln
+        when triple?
+          triple
+          eoln
+        when eoln? || @file.eof?
+          eoln
+        else
+          raise SyntaxError, "Expected comment, triple, or empty line at #{position}"
+        end
+        @lineno += 1
+      end
+      
+      def wses
+        str = ws
+        while ws?
+          str << ws
+        end
+        str
+      end
+      
+      def ws
+        if space? || tab?
+          consume
+        else
+          raise SyntaxError, "Expected space or tab at #{position}"
+        end
+      end
+      
+      def comment
+        str = consume('#')
+        while character_no_cr_or_lf?
+          str = consume
+        end
+        str
+      end
+      
+      def triple
+        sub = subject
+        wses
+        pred = predicate
+        wses
+        obj = object
+        if ws?
+          wses
+        end
+        consume('.')
+        if ws?
+          wses
+        end
+        @graph.add(RDF::Triple.new(sub, pred, obj))
+      end
+      
+      def subject
+        if uriRef?
+          uriRef
+        elsif nodeId?
+          nodeId
+        else
+          raise SyntaxError, "Expected uriRef or nodeId at #{position}"
+        end
+      end
+      
+      def predicate
+        uriRef
+      end
+      
+      def object
+        if uriRef?
+          uriRef
+        elsif nodeId?
+          nodeId
+        elsif lit_string?
+          literal
+        end
+      end
+      
+      def uriRef
+        consume('<')
+        node = RDF::UriNode.new(absoluteUri)
+        consume('>')
+        node
+      end
+      
+      def absoluteUri
+        str = character
+        while character? && !test('>')
+          str << character
+        end
+        unescape(str)
+      end
+      
+      def nodeId
+        consume('_:')
+        RDF::BlankNode.new(name, @graph)
+      end
+      
+      def name
+        str = ''
+        if cap_az? || az?
+          str << consume
+        else
+          raise SyntaxError, "Expected A-Z or a-z at #{position}"
+        end
+        
+        while cap_az? || az? || num?
+          str << consume
+        end
+        str
+      end
+      
+      def literal
+        str = lit_string
+        if lang?
+          lit_lang = lang
+        elsif datatype?
+          lit_dt = datatype
+        end
+        
+        if lit_dt
+          RDF::TypedLiteralNode.new(str, lit_dt)
+        else
+          RDF::PlainLiteralNode.new(str, lit_lang)
+        end
+      end
+      
+      def lit_string
+        consume('"')
+        str = string
+        consume('"')
+        unescape(str)
+      end
+      
+      def string
+        str = ''
+        backslash = false
+        while character? && (!test('"') || backslash)
+          char = character
+          if char == '\\' && !backslash
+            backslash = true
+          else
+            if backslash
+              backslash = false
+              char = convert_backslash(char)
+            end
+            
+            str << char
+          end
+        end
+        str
+      end
+      
+      def convert_backslash(char)
+        case char
+        when 'n'
+          "\n"
+        when 'r'
+          "\r"
+        when 't'
+          "\t"
+        when 'u'
+          small_unicode_value
+        when 'U'
+          long_unicode_value
+        else
+          char
+        end
+      end
+      
+      def small_unicode_value
+        value = ''
+        while peek =~ /[A-Fa-f0-9]/
+          value << consume
+        end
+        
+        if value.size <= 4
+          value.hex.utf8
+        else
+          raise SyntaxError, 'Expected no more than four hexadecimal characters'
+        end
+      end
+      
+      def long_unicode_value
+        value = ''
+        while peek =~ /[A-Fa-f0-9]/
+          value << consume
+        end
+        
+        if value.size >= 5 && value.size <= 8
+          value.hex.utf8
+        else
+          raise SyntaxError, 'Expected between five and eight hexadecimal characters'
+        end
+      end
+      
+      def lang
+        consume('@')
+        language
+      end
+      
+      def language
+        str = ''
+        if az?
+          str << consume
+        else
+          raise SyntaxError, "Expected a-z at #{position}"
+        end
+        
+        while az? && !test('-')
+          str << consume
+        end
+        
+        while test('-')
+          str << consume
+          if az? || num?
+            str << consume
+          else
+            raise SyntaxError, "Expected a-z or number at #{position}"
+          end
+          
+          while az? || num?
+            str << consume
+          end
+        end
+        str
+      end
+      
+      def datatype
+        consume('^^')
+        uriRef.uri
+      end
+      
+      def character
+        if character?
+          consume
+        else
+          raise SyntaxError, "Expected character at #{position}"
+        end
+      end
+      
+      def eoln
+        str = ''
+        if cr?
+          str = consume
+          if lf?
+            str << consume
+          end
+        elsif lf?
+          str = consume
+        elsif !@file.eof?
+          raise SyntaxError, "Expected cr, lf, or crlf at #{position}"
+        end
+        str
+      end
+      
+      ## Test Methods
+      def line?
+        ws? || comment? || uriRef? || nodeId? || eoln?
+      end
+      
+      def comment?
+        test('#')
+      end
+      
+      def triple?
+        subject?
+      end
+      
+      def subject?
+        uriRef? || nodeId?
+      end
+      
+      def predicate?
+        uriRef?
+      end
+      
+      def object?
+        uriRef? || nodeId? || lit_string?
+      end
+      
+      def uriRef?
+        test('<')
+      end
+      
+      def nodeId?
+        test("_:")
+      end
+      
+      def lit_string?
+        test('"')
+      end
+      
+      def lang?
+        test("@")
+      end
+      
+      def datatype?
+        test("^^")
+      end
+      
+      def language_tag?
+        ('a'..'z').include?(peek)
+      end
+      
+      def ws?
+        space? || tab?
+      end
+      
+      def eoln?
+        cr? || lf?
+      end
+      
+      def space?
+        peek == 0x20.chr
+      end
+      
+      def cr?
+        peek == 0xD.chr
+      end
+      
+      def lf?
+        peek == 0xA.chr
+      end
+      
+      def tab?
+        peek == 0x9.chr
+      end
+      
+      def string?
+        @file.eof? || character?
+      end
+      
+      def cap_az?
+        ('A'..'Z').include?(peek)
+      end
+      
+      def az?
+        ('a'..'z').include?(peek)
+      end
+      
+      def num?
+        ('0'..'9').include?(peek)
+      end
+      
+      def name?
+        cap_az? || az?
+      end
+      
+      def absoluteUri?
+        character?
+      end
+      
+      def character_no_cr_or_lf?
+        character? && !(cr? || lf?)
+      end
+      
+      def character?
+        (0x20.chr .. 0x7E.chr).include?(peek)
+      end
+    end
+  end
+end

data/lib/rdf/graph/base.rb

@@ -0,0 +1,118 @@
+module RDF
+  module Graph
+    # Base class for graph implementations.  This class provides basic
+    # functionality and common interface for all graphs.
+    class Base
+      # Exports the triples for this graph in +format+ to +file+.  If +file+ is
+      # nil, then the export is returned as a string.
+      # 
+      # There is one format provided by default (:ntriples), but the supported
+      # formats are depended upon the particular graph implementation, and graph
+      # implementations can override this method to use a (presumably) faster
+      # export function from the underlying triple store--as long as it
+      # preserves the interface expectations.
+      # 
+      # If a graph implementation overrides this method, and the underlying
+      # triple store does not support one of the default formats
+      # (see RDF::Format), then it is recommended that the implementation make
+      # use of the RDF::Format classes to provide exports for the default
+      # formats.
+      #
+      # *Raises*:: <tt></tt>
+      # UnsupportedFormatError:: if +format+ is not supported for export
+      def export(format = :ntriples, file = nil)
+        file ||= StringIO.new
+        
+        case format
+        when :ntriples
+          RDF::Format::NTriples.export(self, file)
+        else
+          raise UnsupportedFormatError
+        end
+        
+        file.string if file.is_a?(StringIO)
+      end
+      
+      # Imports the triples from +file+ in +format+ to this graph.
+      # 
+      # This method will not merge the graphs, meaning the blank nodes from
+      # +file+ are not renamed as they are imported.  If you want to merge two
+      # graphs, then use merge.
+      # 
+      # There is one format provided by default (:ntriples), but the supported
+      # formats are depended upon the particular graph implementation, and graph
+      # implementations can override this method to use a (presumably) faster
+      # import function from the underlying triple store--as long as it
+      # preserves the interface expectations.
+      # 
+      # If a graph implementation overrides this method, and the underlying
+      # triple store does not support one of the default formats
+      # (see RDF::Format), then it is recommended that the implementation make
+      # use of the RDF::Format classes to provide imports for the default
+      # formats.
+      # 
+      # *Raises*:: <tt></tt>
+      # ArgumentError:: if +file+ is nil
+      # UnsupportedFormatError:: if +format+ is not supported for import
+      def import(file, format = :ntriples)
+        raise ArgumentError, "file cannot be blank" if file.nil?
+        
+        case format
+        when :ntriples
+          RDF::Format::NTriples.import(file, self)
+        else
+          raise UnsupportedFormatError
+        end
+      end
+      
+      # Merges +graph+ into the current graph.  In doing so it will rename all
+      # of the blank nodes so they don't collide with any existing blank nodes.
+      def merge(graph)
+        map = {}
+        graph.each do |t|
+          s, p, o = t.subject, t.predicate, t.object
+          if RDF::BlankNode?(s)
+            map[s] = new_blank_node(s.name) unless map.key?(s)
+            s = map[s]
+          end
+          if RDF::BlankNode?(o)
+            map[o] = new_blank_node(o.name) unless map.key?(o)
+            o = map[o]
+          end
+          
+          add(s, p, o)
+        end
+      end
+      
+      # Returns true if the triple (+s+, +p+, +o+) is in this graph, false
+      # otherwise.
+      def include?(*triple)
+        triple = Triple.construct(*triple)
+        return false if variable?(triple.subject) || variable?(triple.object)
+        execute(RDF::Query.new.where(triple.subject, triple.predicate, triple.object)).success?
+      end
+      
+      def each
+        result = execute(RDF::Query.new.where(:s, :p, :o))
+        result.bindings.each do |b|
+          yield Triple.new(b[:s], b[:p], b[:o])
+        end
+      end
+      
+      # Returns true if this graph is empty, false otherwise.
+      def empty?
+        size == 0
+      end
+      
+      # Creates a new BlankNode associated with this graph.
+      def new_blank_node(name)
+        RDF::BlankNode.new(name, self)
+      end
+      
+      private
+        def variable?(x)
+          RDF::BlankNode?(x) && x.graph != self
+        end
+    end
+  end
+end