gkellogg-reddy 0.2.1

data/lib/reddy/n3_grammar.treetop

@@ -0,0 +1,143 @@
+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_ref / 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_ref:uri_ref {
+			def directive; true; end
+		}
+	end
+	
+	rule uri_ref
+		qname / "<" uri:URI_Reference ">"
+	end
+	
+	rule qname
+		nprefix ":" localname / ':' localname
+	end
+	
+	rule object
+		subject / literal
+	end
+	
+	rule literal
+  	(string_single / string_multi) ("^^<" uri:URI_Reference ">" / "@" language )?
+	end
+	
+	rule language
+		[a-z]+ ( "-" [a-z0-9]+ )*
+	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 string_single
+		'""' !["] / '"' string_single_char+ '"'
+	end
+
+	rule string_single_char
+    !["\n\r] (
+      ("\\"
+        [\\\"nrt]
+      / ( "u" hexdigit hexdigit hexdigit hexdigit )
+      / ( "U" "00" hexdigit hexdigit hexdigit hexdigit hexdigit hexdigit)
+      )
+    / .)
+	end
+
+  rule hexdigit
+    [0-9a-fA-F]
+  end
+  
+  # """ constant value with escaping including single or double occurrences of quotes and/or newlines """	
+	rule string_multi
+		'"""' string_multi_char* '"""'
+	end
+
+	rule string_multi_char
+		!'"""' . # something like this; need to think about it some more	
+	end
+		
+end

data/lib/reddy/n3parser.rb

@@ -0,0 +1,151 @@
+require 'treetop'
+
+Treetop.load(File.join(File.dirname(__FILE__), "n3_grammar"))
+
+module Reddy
+  class Parser; end
+  class N3Parser < Parser
+
+    # Parse N3 document from a string or input stream to closure or graph.
+    #
+    # Optionally, the stream may be a Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # With a block, yeilds each statement with URIRef, BNode or Literal elements
+    # 
+    # @param [String] n3_str:: the Notation3/Turtle string
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options:: Options include the following
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:strict]</em>:: Abort or proceed on error
+    # @return [Graph]
+    # @raise Reddy::RdfException or subclass
+    #
+    # @author Patrick Sinclair (metade)
+    def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      super
+
+      @callback = block
+      parser = N3GrammerParser.new
+
+      @doc = stream.respond_to?(:read) ? stream.read : stream
+      
+      document = parser.parse(@doc)
+      unless document
+        reason = parser.failure_reason
+        raise ParserException.new(reason)
+      end
+      
+      process_directives(document)
+      process_statements(document)
+      @graph
+    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_ref.uri.text_value, d.nprefix.text_value) }
+    end
+
+    def namespace(uri, prefix)
+      uri = @uri if uri == '#'
+      prefix = '__local__' if prefix == ''
+      @graph.bind(Namespace.new(uri, prefix))
+    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| add_triple("statement", subject, predicate, object) }
+        end
+      end
+    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| add_triple("anonnode", 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?
+        #puts type.elements.inspect
+        if (type.elements[0].text_value=='@')
+          language = type.elements[1].text_value
+        else
+          encoding = type.elements[1].text_value
+        end
+      end
+
+      # Evaluate text_value to remove redundant escapes
+      #puts string.elements[1].text_value.dump
+      Literal.n3_encoded(string.elements[1].text_value, language, encoding)
+    end
+    
+    def build_uri(prefix, localname)
+      prefix = '__local__' if prefix.nil?
+      if (prefix=='_')
+        BNode.new(localname, @named_bnodes)
+      else
+        @graph.nsbinding[prefix].send(localname)
+      end
+    end
+  end
+end

data/lib/reddy/namespace.rb

@@ -0,0 +1,82 @@
+module Reddy
+  # From Reddy
+  class Namespace
+    attr_accessor :prefix, :uri, :fragment
+ 
+    ## 
+    # Creates a new namespace given a URI and the prefix.
+    #
+    #  nil is a valid prefix to specify the default namespace
+    # ==== 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] prefix:: the prefix of the namespace
+    # @param [Boolean] fragment:: are the identifiers on this resource fragment identifiers? (e.g. '#')  Defaults to false.
+    # @return [Namespace]:: The newly created namespace.
+    # @raise [Error]:: Checks validity of the desired prefix and raises if it is incorrect.
+    #
+    # @author Tom Morris, Pius Uzamere
+    def initialize(uri, prefix, fragment = nil)
+      @uri = URIRef.new(uri) unless uri.is_a?(URIRef)
+      @fragment = fragment
+      @fragment = uri.to_s.match(/\#$/) ? true : false if fragment.nil?
+      prefix = nil if prefix.to_s.empty?
+      if prefix_valid?(prefix)
+        @prefix = prefix
+      else
+        raise ParserException, "Invalid prefix '#{prefix}'"
+      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"
+    #
+    # @return [URIRef]:: The newly created URIRegerence.
+    # @raise [Error]:: Checks validity of the desired prefix and raises if it is incorrect.
+    # @author Tom Morris, Pius Uzamere
+    def method_missing(methodname, *args)
+      self + methodname
+    end
+
+    # Construct a URIRef from a namespace as in method_missing, but without method collision issues
+    def +(suffix)
+      URIRef.new((fragment ? "##{suffix}" : suffix.to_s), @uri)
+    end
+
+    # Bind this namespace to a Graph
+    def bind(graph)
+      graph.bind(self)
+    end
+
+    # Compare namespaces
+    def eql?(other)
+      @prefix == other.prefix && @uri == other.uri && @fragment == other.fragment
+    end
+    alias_method :==, :eql?
+
+    # Output xmlns attribute name
+    def xmlns_attr
+      prefix.nil? ? "xmlns" : "xmlns:#{prefix}"
+    end
+    
+    # Output namespace definition as a hash
+    def xmlns_hash
+      {xmlns_attr => @uri.to_s}
+    end
+    
+    def inspect
+      "Namespace[abbr='#{prefix}',uri='#{uri}']"
+    end
+    
+    private
+    # The Namespace prefix must be an NCName
+    def prefix_valid?(prefix)
+      NC_REGEXP.match(prefix) || prefix.to_s.empty?
+    end
+  end
+end

data/lib/reddy/nokogiri_hacks.rb

@@ -0,0 +1,8 @@
+require 'nokogiri'
+class Nokogiri::XML::Node
+  # URI of namespace + node_name
+  def uri
+    ns = self.namespace ? self.namespace.href : XML_NS.uri.to_s
+    Reddy::URIRef.new(ns + self.node_name)
+  end
+end

data/lib/reddy/parser.rb

@@ -0,0 +1,127 @@
+module Reddy
+  # Generic Reddy Parser class
+  class Parser
+    attr_reader :debug
+    attr_accessor :doc, :graph
+
+    ## 
+    # Creates a new parser for N3 (or Turtle).
+    #
+    # @param [Hash] options:: Options from
+    # <em>options[:graph]</em>:: Graph to parse into, otherwise a new Reddy::Graph instance is created
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    #
+    # @author Gregg Kellogg
+    def initialize(options = {})
+      # initialize the triplestore
+      @graph = options[:graph]
+      @debug = options[:debug]
+      @strict = options[:strict]
+      @named_bnodes = {}
+    end
+    
+    # Instantiate Parser and parse document
+    #
+    # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options::  Options from
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    # @raise [Error]:: Raises RdfError if _strict_
+    #
+    # @author Gregg Kellogg
+    def self.parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      parser = self.new(options)
+      parser.parse(stream, uri, options, &block)
+    end
+    
+    # Parse RDF document from a string or input stream to closure or graph.
+    #
+    # Virtual Class, prototype for Parser subclass.
+    #
+    # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options::  Options from
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    # @raise [Error]:: Raises RdfError if _strict_
+    #
+    # @author Gregg Kellogg
+    def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      if self.class == Parser
+        # Create a delegate of a specific parser class
+        @delegate ||= case options[:type].to_s
+        when "n3", "ntriples", "turtle" then N3Parser.new(options)
+        when "rdfa", "html", "xhtml"    then RdfaParser.new(options)
+        when "xml", "rdf", "rdfxml"     then RdfXmlParser.new(options)
+        else
+          RdfXmlParser.new(options)
+          # raise ParserException.new("type option must be one of :rdfxml, :html, or :n3")
+        end
+        @delegate.parse(stream, uri, options, &block)
+      else
+        # Common parser operations
+        @uri = Addressable::URI.parse(uri.to_s).to_s unless uri.nil?
+        @strict = options[:strict] if options.has_key?(:strict)
+        @debug = options[:debug] if options.has_key?(:debug)
+        
+        @graph ||= Graph.new(:identifier => @uri)
+      end
+    end
+    
+    # Return N3 Parser instance
+    def self.n3_parser(options = {}); N3Parser.new(options); end
+    # Return RDF/XML Parser instance
+    def self.rdfxml_parser(options = {}); RdfXmlParser.new(options); end
+    # Return Rdfa Parser instance
+    def self.rdfa_parser(options = {}); RdfaParser.new(options); end
+
+    protected
+    # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
+    def node_path(node)
+      case node
+      when Nokogiri::XML::Element, Nokogiri::XML::Attr then "#{node_path(node.parent)}/#{node.name}"
+      when String then node
+      else ""
+      end
+    end
+    
+    # Add debug event to debug array, if specified
+    #
+    # @param [XML Node, any] node:: XML Node or string for showing context
+    # @param [String] message::
+    def add_debug(node, message)
+      puts "#{node_path(node)}: #{message}" if $DEBUG
+      @debug << "#{node_path(node)}: #{message}" if @debug
+    end
+
+    # add a triple, object can be literal or URI or bnode
+    #
+    # @param [Nokogiri::XML::Node, any] node:: XML Node or string for showing context
+    # @param [URIRef, BNode] subject:: the subject of the triple
+    # @param [URIRef] predicate:: the predicate of the triple
+    # @param [URIRef, BNode, Literal] object:: the object of the triple
+    # @return [Array]:: An array of the triples (leaky abstraction? consider returning the graph instead)
+    # @raise [Error]:: Checks parameter types and raises if they are incorrect if parsing mode is _strict_.
+    #
+    # @author Gregg Kellogg
+    def add_triple(node, subject, predicate, object)
+      triple = Triple.new(subject, predicate, object)
+      add_debug(node, "triple: #{triple}")
+      if @callback
+        @callback.call(triple)  # Perform yield to saved block
+      else
+        @graph << triple
+      end
+      triple
+    rescue RdfException => e
+      add_debug(node, "add_triple raised #{e.class}: #{e.message}")
+      raise if @strict
+    end
+  end
+end