rdf-rdfxml 0.0.2 → 0.0.3

data/spec/graph_spec.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/rdfxml/patches/graph_properties'
+require 'rdf/rdfxml/patches/seq'
+
+class EX < RDF::Vocabulary("http://example.com/"); end
+
+describe RDF::Graph do
+  describe "properties" do
+    subject { RDF::Graph.new }
+    
+    it "should get asserted properties" do
+      subject << [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 << [EX.a, EX.b, EX.c]
+      subject << [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 << [EX.a, EX.b, EX.c]
+      subject << [EX.a, EX.b, EX.d]
+      subject << [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 properties for a RDF::Node" do
+      bn = RDF::Node.new
+      subject << [bn, EX.b, EX.c]
+      subject.properties(bn).should be_a(Hash)
+      subject.properties(bn).size.should == 1
+      subject.properties(bn).has_key?(EX.b.to_s).should be_true
+      subject.properties(bn)[EX.b.to_s].should == [EX.c]
+    end
+
+    it "should get asserted type with single type" do
+      subject << [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 << [EX.a, EX.b, EX.c]
+      subject.properties(EX.a)[RDF.type.to_s].should == nil
+      subject.type_of(EX.a).should == []
+    end
+  end
+
+  describe "rdf:_n sequences" do
+    subject {
+      g = RDF::Graph.new
+      g << [EX.Seq, RDF.type, RDF.Seq]
+      g << [EX.Seq, RDF._1, EX.john]
+      g << [EX.Seq, RDF._2, EX.jane]
+      g << [EX.Seq, RDF._3, EX.rick]
+      g
+    }
+    
+    it "should return object list" do
+      subject.seq(EX.Seq).should == [EX.john, EX.jane, EX.rick]
+    end
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe RDF::Literal do
+  describe "XML Literal" do
+    describe "with no namespace" do
+      subject { RDF::Literal.new("foo <sup>bar</sup> baz!", :datatype => RDF["XMLLiteral"]) }
+      it "should indicate xmlliteral?" do
+        subject.xmlliteral?.should == true
+      end
+      
+      it "should return normalized literal" do subject.value.should == "foo <sup>bar</sup> baz!" end
+    end
+      
+    describe "with a namespace" do
+      subject {
+        RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"dc" => "http://purl.org/dc/terms/"})
+      }
+    
+      it "should return normalized literal" do subject.value.should == "foo <sup>bar</sup> baz!" end
+      
+      describe "and language" do
+        subject {
+          RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"dc" => "http://purl.org/dc/terms/"}, :language => "fr")
+        }
+
+        it "should return normalized literal" do subject.value.should == "foo <sup xml:lang=\"fr\">bar</sup> baz!" end
+      end
+      
+      describe "and language with an existing language embedded" do
+        subject {
+          RDF::Literal.xmlliteral("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>", :namespaces => {}, :language => "fr")
+        }
+
+        it "should return normalized literal" do subject.value.should == "foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub>" end
+      end
+      
+      describe "and namespaced element" do
+        subject {
+          root = Nokogiri::XML.parse(%(
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
+          <html xmlns="http://www.w3.org/1999/xhtml"
+                xmlns:dc="http://purl.org/dc/terms/"
+          	  xmlns:ex="http://example.org/rdf/"
+          	  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+          	  xmlns:svg="http://www.w3.org/2000/svg">
+          	<head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
+          		<title>Test 0100</title>
+          	</head>
+            <body>
+            	<div about="http://www.example.org">
+                <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
+          	</div>
+            </body>
+          </html>
+          ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
+          content = root.css("h2").children
+          RDF::Literal.xmlliteral(content, :namespaces => {:svg => "http://www.w3.org/2000/svg", :dc => "http://purl.org/dc/terms"})
+        }
+        it "should add namespace" do subject.value.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
+      end
+      
+      describe "and existing namespace definition" do
+        subject {
+          RDF::Literal.xmlliteral("<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"/>", :namespaces => {"svg" => "http://www.w3.org/2000/svg"})
+        }
+        it "should add namespace" do subject.value.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
+      end
+    end
+      
+    describe "with a default namespace" do
+      subject {
+        RDF::Literal.xmlliteral("foo <sup>bar</sup> baz!", :namespaces => {"" => "http://purl.org/dc/terms/"})
+      }
+    
+      it "should return normalized literal foo" do subject.value.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
+    end
+    
+    describe "with <br/>" do
+      subject {
+        RDF::Literal.xmlliteral("<br/>")
+      }
+      it "should add namespace" do subject.value.should == "<br></br>" end
+    end
+  end
+end

data/spec/rdf_escape_spec.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "String RDF encoding" do
+  {
+    "Gregg" => 'Gregg',
+    "Dürst" => 'D\u00FCrst',
+    "simple literal"  => 'simple literal',
+    "backslash:\\" => 'backslash:\\\\',
+    "dquote:\"" => 'dquote:\\"',
+    "newline:\n" => 'newline:\\n',
+    "return:\r" => 'return:\\r',
+    "tab:\t" => 'tab:\\t',
+  }.each_pair do |raw, encoded|
+    specify "'#{raw}' should escape to '#{encoded}'" do
+      raw.rdf_escape.should == encoded
+    end
+
+    specify "'#{encoded}' should unescape to '#{raw}'" do
+      encoded.rdf_unescape.should == raw
+    end
+  end
+  
+  # 16-bit string encodings
+  {
+    "16-bit:\u{15678}another" => '16-bit:\\U00015678another',
+  }.each_pair do |raw, encoded|
+    specify "'#{raw}' should escape to '#{encoded}'" do
+      raw.rdf_escape.should == encoded
+    end
+
+    specify "'#{encoded}' should unescape to '#{raw}'" do
+      encoded.rdf_unescape.should == raw
+    end
+  end if defined?(::Encoding)
+end

data/spec/rdf_helper.rb

@@ -1,4 +1,5 @@
 autoload :YAML, "yaml"
+autoload :CGI, 'cgi'
 
 RDFCORE_DIR = File.join(File.dirname(__FILE__), 'rdfcore')
 RDFCORE_TEST = "http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf"
@@ -95,6 +96,7 @@ module RdfHelper
       return unless output
 
       output_graph = RDF::Graph.load(self.outputDocument)
+      puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if $DEBUG
       graph.should Matchers::be_equivalent_graph(output_graph, self)
     end
 

data/spec/reader_spec.rb

@@ -7,11 +7,11 @@ describe "RDF::RDFXML::Reader" do
   context "discovery" do
     {
       "rdf" => RDF::Reader.for(:rdf),
-      "xml" => RDF::Reader.for(:xml),
+      "rdfxml" => RDF::Reader.for(:rdfxml),
       "etc/foaf.xml" => RDF::Reader.for("etc/foaf.xml"),
       "etc/foaf.rdf" => RDF::Reader.for("etc/foaf.rdf"),
       "foaf.xml" => RDF::Reader.for(:file_name      => "foaf.xml"),
-      "foaf.rdf" => RDF::Reader.for(:file_name      => "foaf.xml"),
+      "foaf.rdf" => RDF::Reader.for(:file_name      => "foaf.rdf"),
       ".xml" => RDF::Reader.for(:file_extension => "xml"),
       ".rdf" => RDF::Reader.for(:file_extension => "rdf"),
       "application/xml" => RDF::Reader.for(:content_type   => "application/xml"),
@@ -312,7 +312,11 @@ EOF
 
     it "should parse xml literal test" do
      file = File.join(@rdf_dir, "xml-literal-mixed.rdf")
-     test_file(file, "http://www.example.com/books#book12345")
+     begin
+       test_file(file, "http://www.example.com/books#book12345")
+     rescue 
+       pending("NTriples support for multi-line quites") { raise }
+     end
     end
   end
 

data/spec/uri_spec.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe RDF::URI do
+  subject { RDF::URI.new("http://example.org")}
+  
+  context "join" do
+    it "should append fragment to uri" do
+      subject.join("foo").to_s.should == "http://example.org/foo"
+    end
+
+    it "should append another fragment" do
+      subject.join("foo#bar").to_s.should == "http://example.org/foo#bar"
+    end
+
+    it "should append another URI" do
+      subject.join(RDF::URI.new("foo#bar")).to_s.should == "http://example.org/foo#bar"
+    end
+
+    describe "normalization" do
+      {
+        %w(http://foo ) =>  "http://foo/",
+        %w(http://foo a) => "http://foo/a",
+        %w(http://foo /a) => "http://foo/a",
+        %w(http://foo #a) => "http://foo/#a",
+
+        %w(http://foo/ ) =>  "http://foo/",
+        %w(http://foo/ a) => "http://foo/a",
+        %w(http://foo/ /a) => "http://foo/a",
+        %w(http://foo/ #a) => "http://foo/#a",
+
+        %w(http://foo# ) =>  "http://foo/", # Special case for Addressable
+        %w(http://foo# a) => "http://foo/a",
+        %w(http://foo# /a) => "http://foo/a",
+        %w(http://foo# #a) => "http://foo/#a",
+
+        %w(http://foo/bar ) =>  "http://foo/bar",
+        %w(http://foo/bar a) => "http://foo/a",
+        %w(http://foo/bar /a) => "http://foo/a",
+        %w(http://foo/bar #a) => "http://foo/bar#a",
+
+        %w(http://foo/bar/ ) =>  "http://foo/bar/",
+        %w(http://foo/bar/ a) => "http://foo/bar/a",
+        %w(http://foo/bar/ /a) => "http://foo/a",
+        %w(http://foo/bar/ #a) => "http://foo/bar/#a",
+
+        %w(http://foo/bar# ) =>  "http://foo/bar",
+        %w(http://foo/bar# a) => "http://foo/a",
+        %w(http://foo/bar# /a) => "http://foo/a",
+        %w(http://foo/bar# #a) => "http://foo/bar#a",
+
+        %w(http://foo/bar# #D%C3%BCrst) => "http://foo/bar#D%C3%BCrst",
+        %w(http://foo/bar# #Dürst) => "http://foo/bar#D%C3%BCrst",
+      }.each_pair do |input, result|
+        it "should create <#{result}> from <#{input[0]}> and '#{input[1]}'" do
+          RDF::URI.new(input[0]).join(input[1].to_s).normalize.to_s.should == result
+        end
+      end
+    end
+  end
+end