rdf_context 0.5.0 → 0.5.1

data/lib/rdf_context/serializer/xml_serializer.rb

@@ -0,0 +1,236 @@
+require File.join(File.dirname(__FILE__), 'abstract_serializer')
+
+module RdfContext
+  # Serialize RDF graphs in NTriples format
+  class XmlSerializer < RecursiveSerializer
+    VALID_ATTRIBUTES = [:none, :untyped, :typed]
+    
+    def initialize(graph)
+      super
+      @force_RDF_about = {}
+    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
+    # <em>options[:max_depth]</em>:: Maximum depth for recursively defining resources, defaults to 3
+    # <em>options[:lang]</em>:: Output as root xml:lang attribute, and avoid generation xml:lang where possible
+    # <em>options[:attributes]</em>:: How to use XML attributes when serializing, one of :none, :untyped, :typed. The default is none.
+    #
+    # -- Serialization Examples
+    # attributes == :none
+    #
+    #   serialize(io, :attributes => none)
+    def serialize(stream, options = {})
+      @max_depth = options[:max_depth] || 3
+      @base = options[:base]
+      @lang = options[:lang]
+      @attributes = options[:attributes] || :none
+      raise "Invalid attribute option '#{@attributes}', should be one of #{VALID_ATTRIBUTES.to_sentence}" unless VALID_ATTRIBUTES.include?(@attributes.to_sym)
+      
+      doc = Nokogiri::XML::Document.new
+
+      preprocess
+
+      predicates = @graph.predicates.uniq
+      possible = predicates | @graph.objects.uniq
+      namespaces = {}
+      required_namespaces = {}
+      possible.each do |res|
+        next unless res.is_a?(URIRef)
+        if !get_qname(res)  # Creates Namespace mappings
+          [RDF_NS, DC_NS, OWL_NS, LOG_NS, RDF_NS, RDFS_NS, XHV_NS, XML_NS, XSD_NS, XSI_NS].each do |ns|
+            # Bind a standard namespace to the graph and try the lookup again
+            @graph.bind(ns) if ns.uri == res.base
+            required_namespaces[res.base] = true if !get_qname(res) && predicates.include?(res)
+          end
+        end
+      end
+      add_namespace(RDF_NS)
+      add_namespace(XML_NS) if @base || @lang
+      
+      # See if there's a default namespace, and favor it when generating element names.
+      # Lookup an equivalent prefixed namespace for use in generating attributes
+      @default_ns = @graph.namespace("")
+      if @default_ns
+        add_namespace(@default_ns)
+        prefix = @graph.prefix(@default_ns.uri)
+        @prefixed_default_ns = @graph.namespace(prefix)
+        add_namespace(@prefixed_default_ns) if @prefixed_default_ns
+      end
+      
+      # Add bindings for predicates not already having bindings
+      tmp_ns = "ns0"
+      required_namespaces.keys.each do |uri|
+        puts "serialize: create temporary namespace for <#{uri}>" if $DEBUG
+        add_namespace(Namespace.new(uri, tmp_ns))
+        tmp_ns = tmp_ns.succ
+      end
+
+      doc.root = Nokogiri::XML::Element.new("rdf:RDF", doc)
+      @namespaces.each_pair do |p, ns|
+        if p.to_s.empty?
+          doc.root.default_namespace = ns.uri.to_s
+        else
+          doc.root.add_namespace(p, ns.uri.to_s)
+        end
+      end
+      doc.root["xml:lang"] = @lang if @lang
+      doc.root["xml:base"] = @base if @base
+      
+      # Add statements for each subject
+      order_subjects.each do |subject|
+        #puts "subj: #{subject.inspect}"
+        subject(subject, doc.root)
+      end
+
+      doc.write_xml_to(stream, :encoding => "UTF-8", :indent => 2)
+    end
+    
+    protected
+    def subject(subject, parent_node)
+      node = nil
+      
+      if !is_done?(subject)
+        subject_done(subject)
+        properties = @graph.properties(subject)
+        prop_list = sort_properties(properties)
+        puts "subject: #{subject.to_n3}, props: #{properties.inspect}" if $DEBUG
+
+        rdf_type, *rest = properties.fetch(RDF_TYPE.to_s, [])
+        properties[RDF_TYPE.to_s] = rest
+        if rdf_type.is_a?(URIRef)
+          element = get_qname(rdf_type)
+          if rdf_type.namespace && @default_ns && rdf_type.namespace.uri == @default_ns.uri
+            element = rdf_type.short_name
+          end
+        end
+        element ||= "rdf:Description"
+
+        node = Nokogiri::XML::Element.new(element, parent_node.document)
+      
+        if subject.is_a?(BNode)
+          # Only need nodeID if it's referenced elsewhere
+          node["rdf:nodeID"] = subject.to_s if ref_count(subject) > (@depth == 0 ? 0 : 1)
+        else
+          node["rdf:about"] = relativize(subject)
+        end
+
+        prop_list.each do |prop|
+          prop_ref = URIRef.new(prop)
+          
+          properties[prop].each do |object|
+            @depth += 1
+            predicate(prop_ref, object, node, properties[prop].length == 1)
+            @depth -= 1
+          end
+        end
+      elsif @force_RDF_about.include?(subject)
+        puts "subject: #{subject.to_n3}, force about" if $DEBUG
+        node = Nokogiri::XML::Element.new("rdf:Description", parent_node.document)
+        node["rdf:about"] = relativize(subject)
+        @force_RDF_about.delete(subject)
+      end
+
+      parent_node.add_child(node) if node
+    end
+    
+    # Output a predicate into the specified node.
+    #
+    # If _is_unique_ is true, this predicate may be able to be serialized as an attribute
+    def predicate(prop, object, node, is_unique)
+      qname = prop.to_qname(uri_binding)
+
+      # See if we can serialize as attribute.
+      # * untyped attributes that aren't duplicated where xml:lang == @lang
+      # * typed attributes that aren't duplicated if @dt_as_attr is true
+      # * rdf:type
+      as_attr = false
+      as_attr ||= true if [:untyped, :typed].include?(@attributes) && prop == RDF_TYPE
+
+      # Untyped attribute with no lang, or whos lang is the same as the default and RDF_TYPE
+      as_attr ||= true if [:untyped, :typed].include?(@attributes) &&
+        (object.is_a?(Literal) && object.untyped? && (object.lang.nil? || object.lang == @lang))
+      
+      as_attr ||= true if [:typed].include?(@attributes) && object.is_a?(Literal) && object.typed?
+
+      as_attr = false unless is_unique
+      
+      # Can't do as an attr if the qname has no prefix and there is no prefixed version
+      if @default_ns && prop.namespace.uri == @default_ns.uri
+        if as_attr
+          if @prefixed_default_ns
+            qname = "#{@prefixed_default_ns.prefix}:#{prop.short_name}"
+          else
+            as_attr = false
+          end
+        else
+          qname = prop.short_name
+        end
+      end
+
+      puts "predicate: #{qname}, as_attr: #{as_attr}, object: #{object.inspect}, done: #{is_done?(object)}, sub: #{@subjects.include?(object)}" if $DEBUG
+      qname = "rdf:li" if qname.match(/rdf:_\d+/)
+      pred_node = Nokogiri::XML::Element.new(qname, node.document)
+      
+      if object.is_a?(Literal) || is_done?(object) || !@subjects.include?(object)
+        # Literals or references to objects that aren't subjects, or that have already been serialized
+        
+        args = object.xml_args
+        puts "predicate: args=#{args.inspect}" if $DEBUG
+        attrs = args.pop
+        
+        if as_attr
+          # Serialize as attribute
+          pred_node.unlink
+          pred_node = nil
+          node[qname] = object.is_a?(URIRef) ? relativize(object) : object.to_s
+        else
+          # Serialize as element
+          attrs.each_pair do |a, av|
+            next if a == "xml:lang" && av == @lang # Lang already specified, don't repeat
+            av = relativize(object) if a == "#{RDF_NS.prefix}:resource"
+            puts "  elt attr #{a}=#{av}" if $DEBUG
+            pred_node[a] = av.to_s
+          end
+          puts "  elt #{'xmllit ' if object.is_a?(Literal) && object.xmlliteral?}content=#{args.first}" if $DEBUG && !args.empty?
+          if object.is_a?(Literal) && object.xmlliteral?
+            pred_node.add_child(Nokogiri::XML::CharacterData.new(args.first, node.document))
+          elsif args.first
+            pred_node.content = args.first unless args.empty?
+          end
+        end
+      else
+        # Check to see if it can be serialized as a collection
+        col = @graph.seq(object)
+        conformant_list = col.all? {|item| !item.is_a?(Literal)}
+        o_props = @graph.properties(object)
+        if conformant_list && o_props[RDF_NS.first.to_s]
+          # Serialize list as parseType="Collection"
+          pred_node["rdf:parseType"] = "Collection"
+          col.each do |item|
+            # Mark the BNode subject of each item as being complete, so that it is not serialized
+            @graph.triples(Triple.new(nil, RDF_NS.first, item)) do |triple, ctx|
+              subject_done(triple.subject)
+            end
+            @force_RDF_about[item] = true
+            subject(item, pred_node)
+          end
+        else
+          if @depth < @max_depth
+            @depth += 1
+            subject(object, pred_node)
+            @depth -= 1
+          elsif object.is_a?(BNode)
+            pred_node["rdf:nodeID"] = object.identifier
+          else
+            pred_node["rdf:resource"] = relativize(object)
+          end
+        end
+      end
+      node.add_child(pred_node) if pred_node
+    end
+  end
+end

data/lib/rdf_context/store/abstract_store.rb

@@ -29,6 +29,7 @@ module RdfContext
     
     def destroy(configuration = {}); end
     def open(configuration = {}); end
+    def close(commit_pending_transactions = false); end
     def commit; end
     def rollback; end
 

data/lib/rdf_context/store/memory_store.rb

@@ -252,7 +252,7 @@ module RdfContext
     end
 
     def size(context = nil)
-      context = nil if context == @identifier || (context.respond_to?(:identifier) && context.identifier == @identifier)
+      context = nil if (context.respond_to?(:identifier) ? context.identifier : context) == @identifier
 
       triples(Triple.new(nil, nil, nil), context).length
     end

data/lib/rdf_context/string_hacks.rb

@@ -102,7 +102,7 @@ class String
       (?:\\[\\bfnrt"/])   # Escaped control characters, " and /
       |(?:\\U00\h{6})     # 6 byte escaped Unicode
       |(?:\\u\h{4})       # 4 byte escaped Unicode
-    )xn
+    )x
   else
     UNESCAPE_RE = %r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n
   end

data/lib/rdf_context/uriref.rb

@@ -72,6 +72,10 @@ module RdfContext
       self.to_s == other.to_s
     end
     alias_method :==, :eql?
+    
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
   
     # Needed for uniq
     def hash; to_s.hash; end
@@ -88,8 +92,7 @@ module RdfContext
     # Output URI as QName using URI binding
     def to_qname(uri_binding = {})
       ns = namespace(uri_binding)
-      sn = self.to_s.sub(ns.uri.to_s, "")
-      "#{ns.prefix}:#{sn}"
+      "#{ns.prefix}:#{short_name}"
     end
     
     def namespace(uri_binding = {})

data/spec/bnode_spec.rb

@@ -47,7 +47,7 @@ describe "Blank nodes" do
   describe "which has a blank identifier" do
     subject { BNode.new("", @context) }
     it "should not be the same as an anonymous identifier" do should_not == BNode.new end
-    it "should be the same as another blank identifier" do should == BNode.new("", @context) end
+    it "should not be the same as another blank identifier" do should_not == BNode.new("", @context) end
   end
 
   describe "which are anonymous" do

data/spec/graph_spec.rb

@@ -299,6 +299,62 @@ HERE
       subject.size.should == 0
     end
 
+    describe "properties" do
+      subject { Graph.new }
+      
+      it "should get asserted properties" do
+        subject.add_triple(@ex.a, @ex.b, @ex.c)
+        subject.properties(@ex.a).should be_a(Hash)
+        subject.properties(@ex.a).size.should == 1
+        subject.properties(@ex.a).has_key?(@ex.b.to_s).should be_true
+        subject.properties(@ex.a)[@ex.b.to_s].should == [@ex.c]
+      end
+      
+      it "should get asserted properties with 2 properties" do
+        subject.add_triple(@ex.a, @ex.b, @ex.c)
+        subject.add_triple(@ex.a, @ex.b, @ex.d)
+        subject.properties(@ex.a).should be_a(Hash)
+        subject.properties(@ex.a).size.should == 1
+        subject.properties(@ex.a).has_key?(@ex.b.to_s).should be_true
+        subject.properties(@ex.a)[@ex.b.to_s].should include(@ex.c, @ex.d)
+      end
+
+      it "should get asserted properties with 3 properties" do
+        subject.add_triple(@ex.a, @ex.b, @ex.c)
+        subject.add_triple(@ex.a, @ex.b, @ex.d)
+        subject.add_triple(@ex.a, @ex.b, @ex.e)
+        subject.properties(@ex.a).should be_a(Hash)
+        subject.properties(@ex.a).size.should == 1
+        subject.properties(@ex.a).has_key?(@ex.b.to_s).should be_true
+        subject.properties(@ex.a)[@ex.b.to_s].should include(@ex.c, @ex.d, @ex.e)
+      end
+
+      it "should get asserted type with single type" do
+        subject.add_triple(@ex.a, RDF_TYPE, @ex.Audio)
+        subject.properties(@ex.a)[RDF_TYPE.to_s].should == [@ex.Audio]
+        subject.type_of(@ex.a).should == [@ex.Audio]
+      end
+    
+      it "should get nil with no type" do
+        subject.add_triple(@ex.a, @ex.b, @ex.c)
+        subject.properties(@ex.a)[RDF_TYPE.to_s].should == nil
+        subject.type_of(@ex.a).should == []
+      end
+      
+      it "should sync properties to graph" do
+        props = subject.properties(@ex.a)
+        props.should be_a(Hash)
+        props[RDF_TYPE.to_s] = @ex.Audio
+        props[DC_NS.title.to_s] = "title"
+        props[@ex.b.to_s] = [@ex.c, @ex.d]
+        subject.sync_properties(@ex.a)
+        subject.contains?(Triple.new(@ex.a, RDF_TYPE, @ex.Audio)).should be_true
+        subject.contains?(Triple.new(@ex.a, DC_NS.title, "title")).should be_true
+        subject.contains?(Triple.new(@ex.a, @ex.b, @ex.c)).should be_true
+        subject.contains?(Triple.new(@ex.a, @ex.b, @ex.d)).should be_true
+      end
+    end
+    
     describe "find triples" do
       it "should find subjects" do
         subject.triples(Triple.new(@ex.john, nil, nil)).size.should == 2
@@ -331,12 +387,13 @@ HERE
       it "should output RDF/XML" do
         rdfxml = <<-HERE
 <?xml version="1.0" encoding="UTF-8"?>
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+<rdf:RDF xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:ex="http://example.org/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
   <rdf:Description rdf:about="http://example.org/john">
-    <foaf:knows rdf:resource="http://example.org/jane"/>
-    <foaf:knows rdf:resource="http://example.org/rick"/>
-  </rdf:Description>
-  <rdf:Description rdf:about="http://example.org/jane">
+    <foaf:knows>
+      <rdf:Description rdf:about="http://example.org/jane">
+        <foaf:knows rdf:resource="http://example.org/rick"/>
+      </rdf:Description>
+    </foaf:knows>
     <foaf:knows rdf:resource="http://example.org/rick"/>
   </rdf:Description>
 </rdf:RDF>
@@ -362,7 +419,7 @@ HERE
     end
     
     describe "rdf:first/rdf:rest sequences" do
-      subject {
+      it "should return object list" do
         a, b = BNode.new("a"), BNode.new("b"), BNode.new("c")
         g = Graph.new(:store => ListStore.new)
         g.add_triple(@ex.List, RDF_NS.first, @ex.john)
@@ -372,11 +429,21 @@ HERE
         g.add_triple(b, RDF_NS.first,  @ex.rick)
         g.add_triple(b, RDF_NS.rest, RDF_NS.nil)
         g.bind(@ex)
-        g
-      }
+
+        #puts g.seq(@ex.List).inspect
+        g.seq(@ex.List).should == [@ex.john, @ex.jane, @ex.rick]
+      end
       
-      it "should return object list" do
-        subject.seq(@ex.List).should == [@ex.john, @ex.jane, @ex.rick]
+      it "should generate a list of resources" do
+        g = Graph.new(:store => ListStore.new)
+        g.add_seq(@ex.List, RDF_NS.first, [@ex.john, @ex.jane, @ex.rick])
+        g.seq(@ex.List).should == [@ex.john, @ex.jane, @ex.rick]
+      end
+      
+      it "should generate an empty list" do
+        g = Graph.new(:store => ListStore.new)
+        g.add_seq(@ex.List, RDF_NS.first, [])
+        g.seq(@ex.List).should == []
       end
     end
   end

data/spec/rdf_helper.rb

@@ -105,7 +105,10 @@ module RdfHelper
 
       return unless output
 
-      if self.compare == :array
+      case self.compare
+      when :none
+        # Don't check output, just parse to graph
+      when :array
         @parser.graph.should be_equivalent_graph(self.output, self)
       else
         output_parser = Parser.new

data/spec/turtle_serializer_spec.rb

@@ -0,0 +1,227 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+include RdfContext
+
+describe "Turtle Serializer" do
+  describe "simple tests" do
+    it "should use full URIs without base" do
+      input = %(<http://a/b> <http://a/c> <http://a/d> .)
+      serialize(input, nil, %r(^<http://a/b> <http://a/c> <http://a/d> \.$))
+    end
+
+    it "should use relative URIs with base" do
+      input = %(<http://a/b> <http://a/c> <http://a/d> .)
+      serialize(input, "http://a/",
+        %r(^@base <http://a/> \.$),
+        %r(^<b> <c> <d> \.$)
+      )
+    end
+
+    it "should use qname URIs with prefix" do
+      input = %(@prefix a: <http://a/> . <http://a/b> <http://a/c> <http://a/d> .)
+      serialize(input, nil,
+        %r(^@prefix a: <http://a/> \.$),
+        %r(^a:b a:c a:d \.$)
+      )
+    end
+
+    it "should use qname URIs with empty prefix" do
+      input = %(@prefix : <http://a/> . <http://a/b> <http://a/c> <http://a/d> .)
+      serialize(input, nil,
+        %r(^@prefix : <http://a/> \.$),
+        %r(^:b :c :d \.$)
+      )
+    end
+    
+    it "should order properties" do
+      input = %(
+        @prefix : <http://a/> .
+        @prefix dc: <http://purl.org/dc/elements/1.1/> .
+        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+        :b :c :d .
+        :b dc:title "title" .
+        :b a :class .
+        :b rdfs:label "label" .
+      )
+      serialize(input, nil,
+        %r(^:b a :class;$),
+        %r(^\s+rdfs:label "label";$),
+        %r(^\s+dc:title \"title\";$),
+        %r(^\s+:c :d \.$),
+        %r(a :class.*label.*title.*:c :d)m
+      )
+    end
+    
+    it "should generate object list" do
+      input = %(@prefix : <http://a/> . :b :c :d, :e .)
+      serialize(input, nil,
+        %r(^@prefix : <http://a/> \.$),
+        %r(^:b :c :d,$),
+        %r(^\s+:e \.$)
+      )
+    end
+    
+    it "should generate property list" do
+      input = %(@prefix : <http://a/> . :b :c :d; :e :f .)
+      serialize(input, nil,
+        %r(^@prefix : <http://a/> \.$),
+        %r(^:b :c :d;$),
+        %r(^\s+:e :f \.$)
+      )
+    end
+  end
+  
+  describe "anons" do
+    it "should generate bare anon" do
+      input = %(@prefix : <http://a/> . [:a :b] .)
+      serialize(input, nil,
+        %r(^\s*\[ :a :b\] \.$)
+      )
+    end
+    
+    it "should generate anon as subject" do
+      input = %(@prefix : <http://a/> . [:a :b] :c :d .)
+      serialize(input, nil,
+        %r(^\s*\[ :a :b;$),
+        %r(^\s+:c :d\] \.$)
+      )
+    end
+    
+    it "should generate anon as object" do
+      input = %(@prefix : <http://a/> . :a :b [:c :d] .)
+      serialize(input, nil,
+        %r(^\s*\:a :b \[ :c :d\] \.$)
+      )
+    end
+  end
+  
+  describe "lists" do
+    it "should generate bare list" do
+      input = %(@prefix : <http://a/> . (:a :b) .)
+      serialize(input, nil,
+        %r(^\(:a :b\) \.$)
+      )
+    end
+
+    it "should generate literal list" do
+      input = %(@prefix : <http://a/> . :a :b ( "apple" "banana" ) .)
+      serialize(input, nil,
+        %r(^:a :b \("apple" "banana"\) \.$)
+      )
+    end
+    
+    it "should generate empty list" do
+      input = %(@prefix : <http://a/> . :a :b () .)
+      serialize(input, nil,
+        %r(^:a :b \(\) \.$)
+      )
+    end
+    
+    it "should generate empty list(2)" do
+      input = %(@prefix : <http://a/> . :emptyList = () .)
+      serialize(input, nil,
+        %r(^:emptyList <.*sameAs> \(\) \.$)
+      )
+    end
+    
+    it "should generate empty list as subject" do
+      input = %(@prefix : <http://a/> . () :a :b .)
+      serialize(input, nil,
+        %r(^\(\) :a :b \.$)
+      )
+    end
+    
+    it "should generate list as subject" do
+      input = %(@prefix : <http://a/> . (:a) :b :c .)
+      serialize(input, nil,
+        %r(^\(:a\) :b :c \.$)
+      )
+    end
+
+    it "should generate list of empties" do
+      input = %(@prefix : <http://a/> . :listOf2Empties = (() ()) .)
+      serialize(input, nil,
+        %r(^:listOf2Empties <.*sameAs> \(\(\) \(\)\) \.$)
+      )
+    end
+    
+    it "should generate list anon" do
+      input = %(@prefix : <http://a/> . :twoAnons = ([a :mother] [a :father]) .)
+      serialize(input, nil,
+        %r(^:twoAnons <.*sameAs> \(\[\s*a :mother\] \[\s*a :father\]\) \.$)
+      )
+    end
+    
+    it "should generate owl:unionOf list" do
+      input = %(
+        @prefix : <http://a/> .
+        @prefix owl: <http://www.w3.org/2002/07/owl#> .
+        @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+        :a rdfs:domain [
+          a owl:Class;
+          owl:unionOf [
+            a owl:Class;
+            rdf:first :b;
+            rdf:rest [
+              a owl:Class;
+              rdf:first :c;
+              rdf:rest rdf:nil
+            ]
+          ]
+        ] .
+      )
+      serialize(input, nil,
+        %r(:a rdfs:domain \[\s*a owl:Class;\s+owl:unionOf\s+\(:b\s+:c\)\]\s*\.$)m
+      )
+    end
+  end
+  
+  # W3C Turtle Test suite from http://www.w3.org/2000/10/swap/test/regression.n3
+  describe "w3c turtle tests" do
+    require 'rdf_helper'
+
+    def self.positive_tests
+      RdfHelper::TestCase.test_cases(TURTLE_TEST, TURTLE_DIR) rescue []
+    end
+
+    positive_tests.each do |t|
+      #puts t.inspect
+      #next unless t.name == "test-04"
+      
+      specify "#{t.name}: " + (t.description || "#{t.inputDocument}") do
+        # Skip tests for very long files, too long
+        if %w(test-14 test-15 test-16 rdfq-results).include?(t.name)
+          pending("Skip very long input file")
+        elsif !defined?(::Encoding) && %w(test-18).include?(t.name)
+          pending("Not supported in Ruby 1.8")
+        elsif %w(test-29).include?(t.name)
+          pending("Silly test")
+        else
+          begin
+            t.run_test do |rdf_string, parser|
+              parser.parse(rdf_string, t.about.uri.to_s, :strict => true, :debug => [])
+              parser.graph.serialize(:format => :ttl, :base => t.about.uri.to_s)
+              t.compare = :none
+            end
+          #rescue #Spec::Expectations::ExpectationNotMetError => e
+          #  pending() {  raise }
+          end
+        end
+      end
+    end
+  end
+  
+  # Serialize ntstr to a string and compare against regexps
+  def serialize(ntstr, base = nil, *regexps)
+    g = Graph.new
+    g.parse(ntstr, base)
+    result = g.serialize(:format => :ttl, :base => base)
+    puts result if $verbose
+    
+    regexps.each do |re|
+      result.should =~ re
+    end
+    
+    result
+  end
+end