rdf_context 0.5.0 → 0.5.1

data/lib/rdf_context/literal.rb

@@ -379,6 +379,10 @@ module RdfContext
       end
     end
     
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+  
     def hash
       [@contents, @encoding, @lang].hash
     end
@@ -425,10 +429,11 @@ module RdfContext
       encoding.xml_args(@contents, @lang)
     end
 
+    def untyped?; encoding == Encoding.the_null_encoding; end
+    def typed?; encoding != Encoding.the_null_encoding; end
+    
     # Is this an XMLLiteral?
-    def xmlliteral?
-      encoding.is_a?(XMLLiteral)
-    end
+    def xmlliteral?; encoding == Encoding.xmlliteral; end
     
     # Output literal contents as a string
     def to_s

data/lib/rdf_context/parser.rb

@@ -28,7 +28,7 @@ module RdfContext
     # @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[:type]</em>:: One of _rdfxml_, _html_, or _n3_ (among others)
     # <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_
@@ -62,9 +62,9 @@ module RdfContext
         
         # 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)
+        when "n3", "ntriples", "turtle", "ttl", "n3", "notation3" 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")

data/lib/rdf_context/serializer/abstract_serializer.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'uriref')
+
+module RdfContext
+  # Abstract serializer
+  class AbstractSerializer
+    attr_accessor :graph, :base
+    
+    def initialize(graph)
+      @graph = graph
+      @base = nil
+    end
+    
+    # Serialize the graph
+    #
+    # @param [IO, StreamIO] stream:: Stream in which to place serialized graph
+    # @param [Hash] options:: Options for parser
+    # <em>options[:base]</em>:: Base URI of graph, used to shorting URI references
+    def serialize(stream, options = {})
+    end
+    
+    def relativize(uri)
+      uri = uri.to_s
+      self.base ? uri.sub(/^#{self.base}/, "") : uri
+    end
+  end
+end

data/lib/rdf_context/serializer/nt_serializer.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'abstract_serializer')
+
+module RdfContext
+  # Serialize RDF graphs in NTriples format
+  class NTSerializer < AbstractSerializer
+    def serialize(stream, base = nil)
+      @graph.triples.collect do |t|
+        stream.write(t.to_ntriples + "\n")
+      end
+    end
+  end
+end

data/lib/rdf_context/serializer/recursive_serializer.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), 'abstract_serializer')
+require File.join(File.dirname(__FILE__), '..', 'bnode')
+require File.join(File.dirname(__FILE__), '..', 'literal')
+
+module RdfContext
+  # Recursive serializer
+  class RecursiveSerializer < AbstractSerializer
+    MAX_DEPTH = 10
+    INDENT_STRING = " "
+    
+    def initialize(graph)
+      super(graph)
+      @stream = nil
+      self.reset
+    end
+
+    def top_classes; [RDFS_NS.Class]; end
+    def predicate_order; [RDF_TYPE, RDFS_NS.label, DC_NS.title]; end
+    
+    def is_done?(subject)
+      @serialized.include?(subject)
+    end
+    
+    # Mark a subject as done.
+    def subject_done(subject)
+      @serialized[subject] = true
+    end
+    
+    def order_subjects
+      seen = {}
+      subjects = []
+      
+      top_classes.each do |class_uri|
+        graph.triples(Triple.new(nil, RDF_TYPE, class_uri)).map {|t| t.subject}.sort.uniq.each do |subject|
+          #puts "order_subjects: #{subject.inspect}"
+          subjects << subject
+          seen[subject] = @top_levels[subject] = true
+        end
+      end
+      
+      # Sort subjects by resources over bnodes, ref_counts and the subject URI itself
+      recursable = @subjects.keys.
+        select {|s| !seen.include?(s)}.
+        map {|r| [r.is_a?(BNode) ? 1 : 0, ref_count(r), r]}.
+        sort
+      
+      subjects += recursable.map{|r| r.last}
+    end
+    
+    def preprocess
+      @graph.triples.each {|t| preprocess_triple(t)}
+    end
+    
+    def preprocess_triple(triple)
+      #puts "preprocess: #{triple.inspect}"
+      references = ref_count(triple.object) + 1
+      @references[triple.object] = references
+      @subjects[triple.subject] = true
+    end
+    
+    # Return the number of times this node has been referenced in the object position
+    def ref_count(node)
+      @references.fetch(node, 0)
+    end
+
+    # Return a QName for the URI, or nil. Adds namespace of QName to defined namespaces
+    def get_qname(uri)
+      if uri.is_a?(URIRef)
+        begin
+          qn = @graph.qname(uri)
+        rescue RdfException
+          return false  # no namespace
+        end
+        # Local parts with . will mess up serialization
+        return false if qn.index('.')
+        
+        add_namespace(uri.namespace)
+        return qn
+      end
+    end
+    
+    def add_namespace(ns)
+      @namespaces[ns.prefix.to_s] = ns
+    end
+
+    # URI -> Namespace bindings (similar to graph) for looking up qnames
+    def uri_binding
+      @uri_binding ||= @namespaces.values.inject({}) {|hash, ns| hash[ns.uri.to_s] = ns; hash}
+    end
+
+    def reset
+      @depth = 0
+      @lists = {}
+      @namespaces = {}
+      @references = {}
+      @serialized = {}
+      @subjects = {}
+      @top_levels = {}
+    end
+
+    # Take a hash from predicate uris to lists of values.
+    # Sort the lists of values.  Return a sorted list of properties.
+    def sort_properties(properties)
+      properties.keys.each do |k|
+        properties[k] = properties[k].sort do |a, b|
+          a_li = a.is_a?(URIRef) && a.short_name =~ /^_\d+$/ ? a.to_i : a.to_s
+          b_li = b.is_a?(URIRef) && b.short_name =~ /^_\d+$/ ? b.to_i : b.to_s
+          
+          a_li <=> b_li
+        end
+      end
+      
+      # Make sorted list of properties
+      prop_list = []
+      
+      predicate_order.each do |prop|
+        next unless properties[prop]
+        prop_list << prop.to_s
+      end
+      
+      properties.keys.sort.each do |prop|
+        next if prop_list.include?(prop.to_s)
+        prop_list << prop.to_s
+      end
+      
+      puts "sort_properties: #{prop_list.to_sentence}" if $DEBUG
+      prop_list
+    end
+
+    # Returns indent string multiplied by the depth
+    def indent(modifier = 0)
+      INDENT_STRING * (@depth + modifier)
+    end
+    
+    # Write text
+    def write(text)
+      @stream.write(text)
+    end
+  end
+end

data/lib/rdf_context/serializer/turtle_serializer.rb

@@ -0,0 +1,219 @@
+require File.join(File.dirname(__FILE__), 'recursive_serializer')
+
+module RdfContext
+  # Abstract serializer
+  class TurtleSerializer < RecursiveSerializer
+    SUBJECT = 0
+    VERB = 1
+    OBJECT = 2
+    
+    def reset
+      super
+      @shortNames = {}
+      @started = false
+    end
+    
+    def get_qname(uri)
+      if uri.is_a?(URIRef)
+        md = uri.to_s.match(/^#{@base}(.*)$/) if @base
+        return "<#{md[1]}>" if md
+        
+        super(uri)
+      end
+    end
+    
+    def preprocess_triple(triple)
+      super
+      
+      # Pre-fetch qnames, to fill namespaces
+      get_qname(triple.subject)
+      get_qname(triple.predicate)
+      get_qname(triple.object)
+
+      @references[triple.predicate] = ref_count(triple.predicate) + 1
+    end
+    
+    def label(node)
+      get_qname(node) || node.to_n3
+    end
+    
+    def start_document
+      @started = true
+      
+      write("#{indent}@base <#{@base}> .\n") if @base
+      
+      ns_list = @namespaces.values.sort_by {|ns| ns.prefix}
+      unless ns_list.empty?
+        ns_str = ns_list.map do |ns|
+          "#{indent}@prefix #{ns.prefix}: <#{ns.uri}> ."
+        end.join("\n") + "\n"
+        write(ns_str)
+      end
+    end
+    
+    def end_document; end
+    
+    # Checks if l is a valid RDF list, i.e. no nodes have other properties.
+    def is_valid_list(l)
+      props = @graph.properties(l)
+      #puts "is_valid_list: #{props.inspect}" if $DEBUG
+      return false unless props.has_key?(RDF_NS.first.to_s) || l == RDF_NS.nil
+      while l && l != RDF_NS.nil do
+        #puts "is_valid_list(length): #{props.length}" if $DEBUG
+        return false unless props.has_key?(RDF_NS.first.to_s) && props.has_key?(RDF_NS.rest.to_s)
+        n = props[RDF_NS.rest.to_s]
+        #puts "is_valid_list(n): #{n.inspect}" if $DEBUG
+        return false unless n.is_a?(Array) && n.length == 1
+        l = n.first
+        props = @graph.properties(l)
+      end
+      #puts "is_valid_list: valid" if $DEBUG
+      true
+    end
+    
+    def do_list(l)
+      puts "do_list: #{l.inspect}" if $DEBUG
+      position = SUBJECT
+      while l do
+        p = @graph.properties(l)
+        item = p.fetch(RDF_NS.first.to_s, []).first
+        if item
+          path(item, position)
+          subject_done(l)
+          position = OBJECT
+        end
+        l = p.fetch(RDF_NS.rest.to_s, []).first
+      end
+    end
+    
+    def p_list(node, position)
+      return false if !is_valid_list(node)
+      #puts "p_list: #{node.inspect}, #{position}" if $DEBUG
+
+      write(position == SUBJECT ? "(" : " (")
+      @depth += 2
+      do_list(node)
+      @depth -= 2
+      write(')')
+    end
+    
+    def p_squared?(node, position)
+      node.is_a?(BNode) &&
+        !@serialized.has_key?(node) &&
+        ref_count(node) <= 1
+    end
+    
+    def p_squared(node, position)
+      return false unless p_squared?(node, position)
+
+      #puts "p_squared: #{node.inspect}, #{position}" if $DEBUG
+      subject_done(node)
+      write(position == SUBJECT ? '[' : ' [')
+      @depth += 2
+      predicate_list(node)
+      @depth -= 2
+      write(']')
+      
+      true
+    end
+    
+    def p_default(node, position)
+      #puts "p_default: #{node.inspect}, #{position}" if $DEBUG
+      l = (position == SUBJECT ? "" : " ") + label(node)
+      write(l)
+    end
+    
+    def path(node, position)
+      puts "path: #{node.inspect}, pos: #{position}, []: #{is_valid_list(node)}, p2?: #{p_squared?(node, position)}, rc: #{ref_count(node)}" if $DEBUG
+      raise RdfException, "Cannot serialize node '#{node}'" unless p_list(node, position) || p_squared(node, position) || p_default(node, position)
+    end
+    
+    def verb(node)
+      puts "verb: #{node.inspect}" if $DEBUG
+      if node == RDF_TYPE
+        write(" a")
+      else
+        path(node, VERB)
+      end
+    end
+    
+    def object_list(objects)
+      puts "object_list: #{objects.inspect}" if $DEBUG
+      return if objects.empty?
+
+      objects.each_with_index do |obj, i|
+        write(",\n#{indent(2)}") if i > 0
+        path(obj, OBJECT)
+      end
+    end
+    
+    def predicate_list(subject)
+      properties = @graph.properties(subject)
+      prop_list = sort_properties(properties) - [RDF_NS.first.to_s, RDF_NS.rest.to_s]
+      puts "predicate_list: #{prop_list.inspect}" if $DEBUG
+      return if prop_list.empty?
+
+      prop_list.each_with_index do |prop, i|
+        write(";\n#{indent(2)}") if i > 0
+        verb(URIRef.new(prop))
+        object_list(properties[prop])
+      end
+    end
+    
+    def s_squared?(subject)
+      ref_count(subject) == 0 && subject.is_a?(BNode) && !is_valid_list(subject)
+    end
+    
+    def s_squared(subject)
+      return false unless s_squared?(subject)
+      
+      write("\n#{indent} [")
+      @depth += 1
+      predicate_list(subject)
+      @depth -= 1
+      write("] .")
+      true
+    end
+    
+    def s_default(subject)
+      write("\n#{indent}")
+      path(subject, SUBJECT)
+      predicate_list(subject)
+      write(" .")
+      true
+    end
+    
+    def statement(subject)
+      puts "statement: #{subject.inspect}, s2?: #{s_squared(subject)}" if $DEBUG
+      subject_done(subject)
+      s_squared(subject) || s_default(subject)
+    end
+    
+    # Serialize the graph
+    #
+    # @param [IO, StreamIO] stream:: Stream in which to place serialized graph
+    # @param [Hash] options:: Options for parser
+    # <em>options[:base]</em>:: Base URI of graph, used to shorting URI references
+    def serialize(stream, options = {})
+      puts "\nserialize: #{@graph.inspect}" if $DEBUG
+      reset
+      @stream = stream
+      @base = options[:base]
+      
+      @graph.bind(RDF_NS)
+      @graph.bind(RDFS_NS)
+      
+      preprocess
+      start_document
+
+      order_subjects.each do |subject|
+        #puts "subj: #{subject.inspect}"
+        unless is_done?(subject)
+          statement(subject)
+        end
+      end
+      
+      end_document
+    end
+  end
+end