tommorris-rena 0.0.1 → 0.0.2

data/lib/rena/literal.rb

@@ -1,89 +1,207 @@
-class Literal
-  attr_accessor :contents, :lang
-  def initialize(contents, lang = nil)
-    @contents = contents
-    if lang != nil && lang != false
-      @lang = lang.downcase
+module Rena
+  class Literal
+    class Encoding
+      def self.integer
+        @integer ||= coerce "http://www.w3.org/2001/XMLSchema#int"
+      end
+
+      def self.float
+        @float ||= coerce "http://www.w3.org/2001/XMLSchema#float"
+      end
+
+      def self.string
+        @string ||= coerce "http://www.w3.org/2001/XMLSchema#string"
+      end
+
+      def self.coerce(string_or_nil)
+        if string_or_nil.nil? || string_or_nil == ''
+          the_null_encoding
+        else
+          new string_or_nil
+        end
+      end
+
+      class Null
+        def to_s
+          ''
+        end
+
+        def format_as_n3(content)
+          "\"#{content}\""
+        end
+
+        def format_as_trix(content)
+          "<plainLiteral>#{content}</plainLiteral>"
+        end
+
+        def inspect
+          "<theRena::TypeLiteral::Encoding::Null>"
+        end
+
+        def xmlliteral?
+          false
+        end
+      end
+
+      def self.the_null_encoding
+        @the_null_encoding ||= Null.new
+      end
+
+      attr_reader :value
+      def initialize(value)
+        @value = value
+      end
+
+      def should_quote?
+        @value != self.class.integer.to_s
+      end
+
+      def ==(other)
+        case other
+        when String
+          other == @value
+        when self.class
+          other.value == @value
+        else
+          false
+        end
+      end
+
+      def hash
+        @value.hash
+      end
+
+      def to_s
+        @value
+      end
+
+      def format_as_n3(content)
+        quoted_content = should_quote? ? "\"#{content}\"" : content
+        "#{quoted_content}^^<#{value}>"
+      end
+
+      def format_as_trix(value)
+        "<typedLiteral datatype=\"#{@value}\">#{value}</typedLiteral>"
+      end
+
+      def xmlliteral?
+        @value == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
+      end
     end
-  end
-  
-  def == (obj)
-    if obj.class == Literal && obj.contents == @contents && (obj.lang == @lang || (obj.lang == nil && @lang == nil))
-      true
-    else
-      false
+
+    class Language < Encoding
+      def initialize(string)
+        @value = string.downcase
+      end
+
+      def clean(string)
+        case string
+        when "eng"; "en"
+        else string
+        end
+      end
+
+      def format_as_n3(contents)
+        "\"#{contents}\"@#{@value}"
+      end
+
+      def format_as_trix(contents)
+        "<plainLiteral xml:lang=\"#{@value}\">#{contents}</plainLiteral>"
+      end
+      
+      def == (other)
+        case other
+        when String
+          other == @value
+        when self.class
+          other.value == @value
+        end
+      end
     end
-  end
-  
-  def to_n3
-    out = "\"" + @contents + "\""
-    out += "@" + @lang if @lang != nil
-    out += "^^" + @encoding if @encoding != nil
-    return out
-  end
-  
-  def to_ntriples
-    return self.to_n3
-  end
 
-  def to_trix
-    if @lang != nil && @lang != false
-      out = "<plainLiteral xml:lang=\"" + @lang + "\">"
-    else
-      out = "<plainLiteral>"
+    attr_accessor :contents, :encoding
+    def initialize(contents, encoding)
+      @contents = contents.to_s
+      unless encoding.is_a?(Encoding) || encoding.is_a?(Encoding::Null)
+        raise TypeError, "#{encoding.inspect} should be an instance of Encoding"
+      end
+      @encoding = encoding
     end
-    out += @contents
-    out += "</plainLiteral>"
-    return out
-  end
-  
-end
 
-class TypedLiteral < Literal
-  attr_accessor :contents, :encoding
-  def initialize(contents, encoding)
-    @contents = contents
-    @encoding = encoding
-    if @encoding == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
-      @xmlliteral = true
-    else
-      @xmlliteral = false
+    def self.untyped(contents, language = nil)
+      new(contents, Language.coerce(language))
     end
-  end
-  
-  def == (obj)
-    if obj.class == TypedLiteral && obj.contents == @contents && obj.encoding == @encoding
-      return true
-    else
-      return false
+
+    def self.typed(contents, encoding)
+      new(contents, Encoding.coerce(encoding))
     end
-  end
-  
-  def to_n3
-    if @encoding == "http://www.w3.org/2001/XMLSchema#int"
-      out = @contents.to_s
-    else
-      out = "\"" + @contents.to_s + "\""
-    end
-    out += "^^<" + @encoding + ">" if @encoding != nil
-    return out
-  end
-  
-  def to_trix
-    "<typedLiteral datatype=\"" + @encoding + "\">" + @contents + "</typedLiteral>"
-  end
-  
-  def xmlliteral?
-    @xmlliteral
-  end
-  
-  def infer!
-    if @contents.class == Fixnum
-      @encoding = "http://www.w3.org/2001/XMLSchema#int"
-    elsif @contents.class == Float 
-      @encoding = "http://www.w3.org/2001/XMLSchema#float"
-    else
-      @encoding = "http://www.w3.org/2001/XMLSchema#string"
+
+    def self.build_from(object)
+      new(object.to_s, infer_encoding_for(object))
+    end
+
+    def self.infer_encoding_for(object)
+      case object
+      when Integer; Encoding.integer
+      when Float;   Encoding.float
+      else          Encoding.string
+      end
+    end
+
+    require 'whatlanguage'
+    unless WhatLanguage.nil?
+      def self.infer_language_for(object)
+        inferred_lang = object.language
+        case inferred_lang
+        when :dutch; Language.new("nl")
+        when :english; Language.new("en")
+        when :farsi; Langauge.new("fa")
+        when :french; Language.new("fr")
+        when :german; Language.new("de")
+        when :pinyin; Language.new("zh-CN")
+        when :portugese; Language.new("pt")
+        when :russian; Language.new("ru")
+        when :spanish; Language.new("es")
+        when :swedish; Language.new("sv")
+        end
+      end
+      
+      def self.build_from_language(object)
+        new(object.to_s, infer_language_for(object))
+      end
+    end
+
+    class << self
+      protected :new
+    end
+
+    def == (obj)
+      obj.is_a?(self.class) && obj.contents == @contents && obj.encoding == @encoding
+    end
+
+    def to_n3
+      encoding.format_as_n3(@contents)
+    end
+
+    ## alias_method breaks subclasses! Beware! Here be dragons!
+    def to_ntriples
+      to_n3
+    end
+
+    def to_trix
+      encoding.format_as_trix(@contents)
+    end
+
+    def xmlliteral?
+      encoding.xmlliteral?
+    end
+    
+    def to_s
+      @contents.to_s
+    end
+    
+    def lang
+      encoding.is_a?(Language) ? encoding : nil
     end
   end
-end
+end

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