metade-rena 0.0.2

data/lib/rena/n3_grammar.treetop

@@ -0,0 +1,129 @@
+grammar N3Grammer
+	rule document
+		statements
+	end
+	
+	rule statements
+		(space / (statement / directive) space* ('.' space*)? )*
+	end
+	
+	rule statement
+		subject space+ property_list
+	end
+	
+	rule subject
+		node
+	end
+	
+	rule verb
+		">-" prop "->"      # has xxx of 
+		/ "<-" prop "<-"    # is xxx of 
+		# / # / operator     # has operator:xxx of??? NOT IMPLMENTED
+		/ prop              # has xxx of -- shorthand
+		# / "has" prop        # has xxx of
+		# / "is" prop "of"    # is xxx of
+		/ "a"               # has rdf:type of
+		# / "="               # has daml:equivaent of
+	end
+	
+	rule prop
+		node
+	end
+	
+	rule node
+		uri_ref2 / anonnode / 'this'
+	end
+	
+	rule anonnode
+		"[" space* property_list space* "]"  # something which ...
+		/ "{" statementlist "}"  # the statementlist itself as a resource
+		/ "(" nodelist ")" {
+			def anonnode; true; end
+		}
+	end
+	
+	rule property_list
+		verb space+ object_list space* ";" space+ property_list
+		/ verb space+ object_list
+		/ ":-" anonnode  #to allow two anonymous forms to be given eg [ a :Truth; :- { :sky :color :blue } ] )
+		/ ":-" anonnode ";" property_list
+		/ '.'
+	end
+
+	rule object_list
+		object "," space* object_list / object
+	end
+
+	rule directive
+		'@prefix' space+ nprefix:nprefix? ':' space+ uri_ref2:uri_ref2 {
+			def directive; true; end
+		}
+	end
+	
+	rule uri_ref2
+		qname / "<" uri:URI_Reference ">"
+	end
+	
+	rule qname
+		nprefix ":" localname / ':' localname
+	end
+	
+	rule object
+		subject / literal
+	end
+	
+	rule literal
+  	(string1 / string2) ("^^<" uri:URI_Reference ">" / "@" [a-z]+ )?
+	end
+	
+	rule localname
+		fragid
+	end
+	
+	rule URI_Reference
+		[^{}<>]*
+	end
+	
+	rule nprefix
+		((alpha / "_") alphanumeric*)
+	end
+
+	rule fragid
+		alpha alphanumeric*
+	end
+
+	rule alpha
+		[a-zA-Z]
+	end
+	
+	rule alphanumeric
+		alpha / [0-9] / "_"
+	end
+	
+	rule space
+		[ \t\n\r]+ / comment
+	end
+	
+	rule comment
+	  '#' (![\n\r] .)*
+	end
+
+  # " constant-value-with-escaping "
+	rule string1
+		'"' string1_char+ '"'
+	end
+
+	rule string1_char
+		!["] .
+	end
+
+  # """ constant value with escaping including single or double occurences of quotes and/or newlines """	
+	rule string2
+		'"""' string2_char* '"""'
+	end
+
+	rule string2_char
+		!'"""' . # something like this; need to think about it some more	
+	end
+		
+end

data/lib/rena/n3parser.rb

@@ -0,0 +1,145 @@
+require 'rena/graph'
+require 'treetop'
+
+Treetop.load(File.join(File.dirname(__FILE__), "n3_grammar"))
+
+module Rena
+  class N3Parser
+    attr_accessor :graph
+
+    ## 
+    # Creates a new parser for N3 (or Turtle).
+    #
+    # @param [String] n3_str the Notation3/Turtle string
+    # @param [String] uri the URI of the document
+    #
+    # @author Patrick Sinclair (metade)
+    def initialize(n3_str, uri=nil)
+      @uri = Addressable::URI.parse(uri) unless uri.nil?
+      parser = N3GrammerParser.new
+      document = parser.parse(n3_str)
+      if document
+        @graph = Graph.new
+        process_directives(document)
+        process_statements(document)
+      else
+        parser.terminal_failures.each do |tf|
+          puts "Expected #{tf.expected_string.inspect} (#{tf.index})- '#{n3_str[tf.index,10].inspect}'"
+        end
+      end
+    end
+
+    protected
+
+    def process_directives(document)
+      directives = document.elements.find_all { |e| e.elements.first.respond_to? :directive }
+      directives.map! { |d| d.elements.first }
+      directives.each { |d| namespace(d.uri_ref2.uri.text_value, d.nprefix.text_value) }
+    end
+
+    def namespace(uri, short)
+      short = '__local__' if short == ''
+      @graph.namespace(uri, short)
+    end
+
+    def process_statements(document)
+      subjects = document.elements.find_all { |e| e.elements.first.respond_to? :subject }
+      subjects.map! { |s| s.elements.first }
+      subjects.each do |s|
+        subject = process_node(s.subject)
+        properties = process_properties(s.property_list)
+        properties.each do |p|      
+          predicate = process_verb(p.verb)
+          objects = process_objects(p.object_list)
+          objects.each { |object| triple(subject, predicate, object) }
+        end
+      end
+    end
+
+    def triple(subject, predicate, object)
+      @graph.add_triple(subject, predicate, object)
+    end
+
+    def process_anonnode(anonnode)
+      bnode = BNode.new
+      properties = process_properties(anonnode.property_list)
+      properties.each do |p|      
+        predicate = process_node(p.verb)
+        objects = process_objects(p.object_list)
+        objects.each { |object| triple(bnode, predicate, object) }
+      end
+      bnode
+    end
+
+    def process_verb(verb)
+      return URIRef.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type') if (verb.text_value=='a')
+      return process_node(verb)
+    end
+
+    def process_node(node)
+      if (node.respond_to? :uri)
+        URIRef.new(node.uri.text_value)
+      else      
+        prefix = (node.respond_to? :nprefix) ? node.nprefix.text_value : nil
+        localname = node.localname.text_value
+        build_uri(prefix, localname)
+      end
+    end
+
+    def process_properties(properties)
+      result = []
+      result << properties if (properties.respond_to? :verb)
+      result << process_properties(properties.property_list) if (properties.respond_to? :property_list)
+      result.flatten
+    end
+
+    def process_objects(objects)
+      result = []
+      if (objects.respond_to? :object)
+        result << process_object(objects.object)
+      else
+        result << process_object(objects)
+      end
+      result << process_objects(objects.object_list) if (objects.respond_to? :object_list)
+      result.flatten
+    end
+
+    def process_object(object)
+      if (object.respond_to? :localname or object.respond_to? :uri)
+        process_node(object)
+      elsif (object.respond_to? :property_list)
+        process_anonnode(object)
+      else
+        process_literal(object)
+      end
+    end
+    
+    def process_literal(object)
+      encoding, language = nil, nil
+      string, type = object.elements
+      
+      unless type.elements.nil?
+        if (type.elements[0].text_value=='@')
+          language = type.elements[1].text_value
+        else
+          encoding = type.elements[1].text_value
+        end
+      end
+
+      if (encoding.nil?)
+        Literal.untyped(string.elements[1].text_value, language)
+      else
+        Literal.typed(string.elements[1].text_value, encoding)
+      end      
+    end
+    
+    def build_uri(prefix, localname)
+      prefix = '__local__' if prefix.nil?
+      if (prefix=='_')
+        BNode.new(localname)
+      else
+        @graph.nsbinding[prefix].send(localname)
+      end
+    end
+  end
+end

data/lib/rena/namespace.rb

@@ -0,0 +1,76 @@
+require 'rena/uriref'
+require 'rena/graph'
+
+module Rena
+  class Namespace
+    attr_accessor :short, :uri, :fragment
+ 
+    ## 
+    # Creates a new namespace given a URI and the short name.
+    #
+    # ==== Example
+    #   Namespace.new("http://xmlns.com/foaf/0.1/", "foaf") # => returns a new Foaf namespace
+    #
+    # @param [String] uri the URI of the namespace
+    # @param [String] short the short name of the namespace
+    # @param [Boolean] fragment are the identifiers on this resource fragment identifiers? (e.g. '#')  Defaults to false.
+    #
+    # ==== Returns
+    # @return [Namespace] The newly created namespace.
+    #
+    # @raise [Error] Checks validity of the desired shortname and raises if it is incorrect.
+    # @author Tom Morris, Pius Uzamere
+
+    def initialize(uri, short, fragment = false)
+      @uri = uri
+      @fragment = fragment
+      if shortname_valid?(short)
+        @short = short
+      else
+        raise
+      end
+    end
+
+    ## 
+    # Allows the construction of arbitrary URIs on the namespace.
+    #
+    # ==== Example
+    #   foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf"); foaf.knows # => returns a new URIRef with URI "http://xmlns.com/foaf/0.1/knows"
+    #   foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf", true); foaf.knows # => returns a new URIRef with URI "http://xmlns.com/foaf/0.1/#knows"
+    #
+    # @param [String] uri the URI of the namespace
+    # @param [String] short the short name of the namespace
+    # @param [Boolean] fragment are the identifiers on this resource fragment identifiers? (e.g. '#')  Defaults to false.
+    #
+    # ==== Returns
+    # @return [URIRef] The newly created URIRegerence.
+    #
+    # @raise [Error] Checks validity of the desired shortname and raises if it is incorrect.
+    # @author Tom Morris, Pius Uzamere
+
+    def method_missing(methodname, *args)
+      unless fragment
+        URIRef.new(@uri + methodname.to_s)
+      else
+        URIRef.new(@uri + '#' + methodname.to_s)
+      end
+    end
+
+    def bind(graph)
+      if graph.class == Graph
+        graph.bind(self)
+      else
+        raise
+      end
+    end
+
+    private
+    def shortname_valid?(shortname)
+      if shortname =~ /[a-zA-Z_][a-zA-Z0-9_]+/
+        return true
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/rena/rdfxmlparser.rb

@@ -0,0 +1,188 @@
+require 'rena/uriref'
+require 'rena/graph'
+require 'rena/literal'
+require 'rena/exceptions/uri_relative_exception'
+require 'rena/exceptions/about_each_exception'
+require 'rena/rexml_hacks'
+
+
+module Rena
+  class RdfXmlParser
+    SYNTAX_BASE = "http://www.w3.org/1999/02/22-rdf-syntax-ns"
+    RDF_TYPE = SYNTAX_BASE + "#type"
+    RDF_DESCRIPTION = SYNTAX_BASE + "#Description"
+
+    attr_accessor :xml, :graph
+    def initialize(xml_str, uri = nil)
+      @excl = ["http://www.w3.org/1999/02/22-rdf-syntax-ns#resource",
+               "http://www.w3.org/1999/02/22-rdf-syntax-ns#nodeID",
+               "http://www.w3.org/1999/02/22-rdf-syntax-ns#about",
+               "http://www.w3.org/1999/02/22-rdf-syntax-ns#ID"]
+      if uri != nil
+        @uri = Addressable::URI.parse(uri)
+      end
+      @xml = REXML::Document.new(xml_str)
+  #    self.iterator @xml.root.children
+      if self.is_rdf?
+        @graph = Graph.new
+
+        @xml.root.each_element { |e|
+          self.parse_element e
+        }
+  #      puts @graph.size
+      end
+    end
+
+    def is_rdf?
+      @xml.each_element do |e|
+        if e.namespaces.has_value? "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+          return true
+        end
+      end
+      return false
+    end
+
+    protected
+    def get_uri_from_atts (element, aboutmode = false)
+      if aboutmode == false
+        resourceuri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#resource"
+      else
+        resourceuri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#about"
+      end
+  
+      subject = nil
+      element.attributes.each_attribute { |att|
+        uri = att.namespace + att.name
+        value = att.to_s
+        if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEach"
+          raise AboutEachException, "Failed as per RDFMS-AboutEach-Error001.rdf test from 2004 test suite"
+        end
+        if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEachPrefix"
+          raise AboutEachException, "Failed as per RDFMS-AboutEach-Error002.rdf test from 2004 test suite"
+        end
+        if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#bagID"
+          raise
+          if name =~ /^[a-zA-Z_][a-zA-Z0-9]*$/
+            # TODO: do something intelligent with the bagID
+          else
+            raise
+          end
+        end
+        
+        if uri == resourceuri #specified resource
+          element_uri = Addressable::URI.parse(value)
+          if (element_uri.relative?)
+            # we have an element with a relative URI
+            if (element.base?)
+              # the element has a base URI, use that to build the URI
+              value = "##{value}" if (value[0..0].to_s != "#")
+              value = "#{element.base}#{value}"
+            elsif (!@uri.nil?)
+              # we can use the document URI to build the URI for the element
+              value = @uri + element_uri
+            end
+          end
+          subject = URIRef.new(value)
+        end
+        
+        if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#nodeID" #BNode with ID
+          # we have a BNode with an identifier. First, we need to do syntax checking.
+          if value =~ /^[a-zA-Z_][a-zA-Z0-9]*$/
+            # now we check to see if the graph has the value
+            if @graph.has_bnode_identifier?(value)
+              # if so, pull it in - no need to recreate objects.
+              subject = @graph.get_bnode_by_identifier(value)
+            else
+              # if not, create a new one.
+              subject = BNode.new(value)
+            end
+          end
+        end
+    
+        if uri == "http://www.w3.org/1999/02/22-rdf-syntax-ns#ID"
+          begin
+            # check for base
+            if att.element.base?
+              subject = att.element.base.to_s + value
+            elsif @uri != nil
+              compound = @uri.to_s + "#" + value
+              subject = compound.to_s
+            else
+              raise "Needs to have an ID"
+            end
+  #        rescue UriRelativeException
+          end
+        end
+
+        # add other subject detection subroutines here
+      }
+      if subject.class == NilClass
+        subject = BNode.new
+      end
+      return subject
+    end
+
+    protected
+
+    def parse_element (element, subject = nil, resource = false)
+      if subject == nil
+        # figure out subject
+        subject = self.get_uri_from_atts(element, true)
+      end
+      
+      # type parsing
+      if (resource == true or element.attributes.has_key? 'about')
+        type = URIRef.new(element.namespace + element.name)
+        unless type.to_s == RDF_TYPE
+          @graph.add_triple(subject, RDF_DESCRIPTION, type)
+        end
+      end
+      
+      # attribute parsing
+      element.attributes.each_attribute { |att|
+        uri = att.namespace + att.name
+        value = att.to_s
+    
+        unless @excl.member? uri
+          @graph.add_triple(subject, uri, Literal.untyped(value))
+        end
+      }
+
+      # element parsing
+      element.each_element { |e|
+        self.parse_resource_element e, subject
+      }
+    end
+
+    def parse_resource_element e, subject
+      uri = e.namespace + e.name
+      if e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "parseType").to_s == "Literal"
+        @graph.add_triple(subject, uri, Literal.typed(e.children.to_s.strip, "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"))
+      elsif e.has_elements?
+        # subparsing
+        e.each_element { |se| #se = 'striped element'
+          if e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "parseType").to_s == "Resource"
+            object = BNode.new
+          else
+            object = self.get_uri_from_atts(se, true)
+          end
+          @graph.add_triple(subject, uri, object)
+          self.parse_element(se, object, true)
+        }
+      elsif e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "datatype")
+        @graph.add_triple(subject, uri, Literal.typed(e.text, e.attributes.get_attribute_ns("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "datatype").to_s.strip))
+      elsif e.has_attributes?
+        # get object out
+        object = self.get_uri_from_atts(e)
+        @graph.add_triple(subject, uri, object)
+      elsif e.has_text?
+        if e.lang?
+          @graph.add_triple(subject, uri, Literal.untyped(e.text, e.lang))
+        else
+          @graph.add_triple(subject, uri, Literal.untyped(e.text))
+        end
+      end
+    end
+
+  end
+end