rdf-rdfxml 0.2.1 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (23) hide show
  1. data/History.txt +13 -0
  2. data/Rakefile +2 -2
  3. data/VERSION +1 -1
  4. data/etc/doap.nt +47 -0
  5. data/etc/doap.xml +73 -0
  6. data/lib/rdf/rdfxml.rb +0 -1
  7. data/lib/rdf/rdfxml/patches/literal_hacks.rb +19 -8
  8. data/lib/rdf/rdfxml/patches/seq.rb +1 -1
  9. data/lib/rdf/rdfxml/patches/uri_hacks.rb +6 -0
  10. data/lib/rdf/rdfxml/reader.rb +14 -8
  11. data/lib/rdf/rdfxml/version.rb +1 -1
  12. data/lib/rdf/rdfxml/writer.rb +13 -18
  13. data/rdf-rdfxml.gemspec +14 -13
  14. data/script/console +2 -2
  15. data/script/parse +49 -0
  16. data/spec/literal_spec.rb +176 -3
  17. data/spec/rdf-iso-falure.rb +35 -0
  18. data/spec/reader_spec.rb +16 -9
  19. data/spec/uri_spec.rb +47 -34
  20. data/spec/writer_spec.rb +5 -2
  21. metadata +30 -11
  22. data/lib/rdf/rdfxml/patches/rdf_escape.rb +0 -131
  23. data/spec/rdf_escape_spec.rb +0 -36
data/script/console CHANGED
@@ -3,8 +3,8 @@
3
3
  irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
4
4
 
5
5
  libs = " -r irb/completion"
6
- # Perhaps use a console_lib to store any extra methods I may want available in the cosole
7
- # libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
6
+ RDF = File.dirname(__FILE__) + "/../../rdf/lib"
7
+ libs << " -I #{RDF}" if File.directory?(RDF)
8
8
  libs << " -r #{File.dirname(__FILE__) + '/../lib/rdf/rdfxml.rb'}"
9
9
  puts "Loading rdf-rdfxml gem"
10
10
  exec "#{irb} #{libs} --simple-prompt"
data/script/parse ADDED
@@ -0,0 +1,49 @@
1
+ #!/usr/bin/env ruby -s
2
+ require 'rubygems'
3
+ $:.unshift(File.join(File.dirname(__FILE__), "..", 'lib'))
4
+ require 'rdf/rdfxml'
5
+ require 'getoptlong'
6
+
7
+ def parse(input, base)
8
+ puts RDF::Writer.for($format.to_sym).buffer { |writer|
9
+ RDF::RDFXML::Reader.new(input, :base_uri => base, :strict => true).each do |statement|
10
+ writer << statement
11
+ end
12
+ }
13
+ end
14
+
15
+ mode = ARGV.shift
16
+ raise "Mode must be one of 'parse'" unless mode == "parse"
17
+
18
+ $verbose = false
19
+ $format = :ntriples
20
+ base_uri = "http://example.com"
21
+ input = nil
22
+
23
+ opts = GetoptLong.new(
24
+ ["--debug", GetoptLong::NO_ARGUMENT],
25
+ ["--verbose", GetoptLong::NO_ARGUMENT],
26
+ ["--quiet", GetoptLong::NO_ARGUMENT],
27
+ ["--format", GetoptLong::REQUIRED_ARGUMENT],
28
+ ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
29
+ ["--uri", GetoptLong::REQUIRED_ARGUMENT]
30
+ )
31
+ opts.each do |opt, arg|
32
+ case opt
33
+ when '--verbose' then $verbose = true
34
+ when '--quiet' then $quiet = true
35
+ when '--debug' then $DEBUG = true
36
+ when '--execute' then input = arg
37
+ when '--format' then $format = arg
38
+ when '--uri' then base_uri = arg
39
+ end
40
+ end
41
+
42
+ if ARGV.empty?
43
+ s = input ? input : $stdin.read
44
+ parse(StringIO.new(s), base_uri)
45
+ else
46
+ ARGV.each do |test_file|
47
+ parse(File.open(test_file), base_uri)
48
+ end
49
+ end
data/spec/literal_spec.rb CHANGED
@@ -22,26 +22,64 @@ describe RDF::Literal do
22
22
  describe "with a namespace" do
23
23
  subject {
24
24
  @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
25
- :namespaces => {"dc" => RDF::DC.to_s})
25
+ :namespaces => {:dc => RDF::DC.to_s})
26
26
  }
27
27
 
28
28
  it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
29
29
 
30
+ describe "as string prefix" do
31
+ subject {
32
+ @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
33
+ :namespaces => {"dc" => RDF::DC.to_s})
34
+ }
35
+
36
+ it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
37
+ end
38
+
30
39
  describe "and language" do
31
40
  subject {
32
41
  @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
33
- :namespaces => {"dc" => RDF::DC.to_s},
42
+ :namespaces => {:dc => RDF::DC.to_s},
34
43
  :language => :fr)
35
44
  }
36
45
 
37
46
  it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup> baz!" end
38
47
  end
39
48
 
49
+ describe "and node set" do
50
+ subject {
51
+ root = Nokogiri::XML.parse(%(<?xml version="1.0" encoding="UTF-8"?>
52
+ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
53
+ <html xmlns="http://www.w3.org/1999/xhtml"
54
+ xmlns:dc="http://purl.org/dc/terms/"
55
+ xmlns:ex="http://example.org/rdf/"
56
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
57
+ xmlns:svg="http://www.w3.org/2000/svg">
58
+ <head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
59
+ <title>Test 0100</title>
60
+ </head>
61
+ <body>
62
+ <div about="http://www.example.org">
63
+ <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
64
+ </div>
65
+ </body>
66
+ </html>
67
+ ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
68
+ content = root.css("h2").children
69
+ @new.call(content, :datatype => RDF.XMLLiteral,
70
+ :namespaces => {
71
+ :svg => "http://www.w3.org/2000/svg",
72
+ :dc => "http://purl.org/dc/terms/",
73
+ })
74
+ }
75
+ it "should add namespace" do subject.to_s.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>" end
76
+ end
77
+
40
78
  describe "and language with an existing language embedded" do
41
79
  subject {
42
80
  @new.call("foo <dc:sup>bar</dc:sup><dc:sub xml:lang=\"en\">baz</dc:sub>",
43
81
  :datatype => RDF.XMLLiteral,
44
- :namespaces => {"dc" => RDF::DC.to_s},
82
+ :namespaces => {:dc => RDF::DC.to_s},
45
83
  :language => :fr)
46
84
  }
47
85
 
@@ -50,6 +88,15 @@ describe RDF::Literal do
50
88
  end
51
89
 
52
90
  describe "with a default namespace" do
91
+ subject {
92
+ @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
93
+ :namespaces => {:__default__ => RDF::DC.to_s})
94
+ }
95
+
96
+ it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
97
+ end
98
+
99
+ describe "with a default namespace (as empty string)" do
53
100
  subject {
54
101
  @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
55
102
  :namespaces => {"" => RDF::DC.to_s})
@@ -57,5 +104,131 @@ describe RDF::Literal do
57
104
 
58
105
  it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
59
106
  end
107
+
108
+ context "rdfcore tests" do
109
+ context "rdfms-xml-literal-namespaces" do
110
+ it "should reproduce test001" do
111
+ l = @new.call("
112
+ <html:h1>
113
+ <b>John</b>
114
+ </html:h1>
115
+ ",
116
+ :datatype => RDF.XMLLiteral,
117
+ :namespaces => {
118
+ "" => "http://www.w3.org/1999/xhtml",
119
+ "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
120
+ "html" => "http://NoHTML.example.org",
121
+ "my" => "http://my.example.org/",
122
+ })
123
+
124
+ l.to_s.should == "\n <html:h1 xmlns:html=\"http://NoHTML.example.org\">\n <b xmlns=\"http://www.w3.org/1999/xhtml\">John</b>\n </html:h1>\n "
125
+ end
126
+
127
+ it "should reproduce test002" do
128
+ l = @new.call("
129
+ Ramifications of
130
+ <apply>
131
+ <power/>
132
+ <apply>
133
+ <plus/>
134
+ <ci>a</ci>
135
+ <ci>b</ci>
136
+ </apply>
137
+ <cn>2</cn>
138
+ </apply>
139
+ to World Peace
140
+ ",
141
+ :datatype => RDF.XMLLiteral,
142
+ :namespaces => {
143
+ "" => "http://www.w3.org/TR/REC-mathml",
144
+ })
145
+
146
+ l.to_s.should == "\n Ramifications of\n <apply xmlns=\"http://www.w3.org/TR/REC-mathml\">\n <power></power>\n <apply>\n\t<plus></plus>\n\t<ci>a</ci>\n\t<ci>b</ci>\n </apply>\n <cn>2</cn>\n </apply>\n to World Peace\n "
147
+ end
148
+ end
149
+
150
+ context "rdfms-xmllang" do
151
+ it "should reproduce test001" do
152
+ l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => nil)
153
+
154
+ l.to_s.should == "chat"
155
+ end
156
+ it "should reproduce test002" do
157
+ l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => :fr)
158
+
159
+ l.to_s.should == "chat"
160
+ end
161
+ end
162
+
163
+ context "xml-canon" do
164
+ it "should reproduce test001" do
165
+ l = @new.call("<br />", :datatype => RDF.XMLLiteral)
166
+
167
+ l.to_s.should == "<br></br>"
168
+ end
169
+ end
170
+ end
171
+
172
+ context "rdfa tests" do
173
+ it "should reproduce test 0011: XMLLiteral" do
174
+ l = @new.call("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time",
175
+ :datatype => RDF.XMLLiteral,
176
+ :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
177
+
178
+ l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
179
+ end
180
+
181
+ it "should reproduce test 0092: Tests XMLLiteral content with explicit @datatype" do
182
+ l = @new.call(%(E = mc<sup>2</sup>: The Most Urgent Problem of Our Time<),
183
+ :datatype => RDF.XMLLiteral,
184
+ :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
185
+
186
+ l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
187
+ end
188
+
189
+ it "should reproduce test 0100: XMLLiteral with explicit namespace" do
190
+ l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
191
+ :datatype => RDF.XMLLiteral,
192
+ :namespaces => {
193
+ "" => "http://www.w3.org/1999/xhtml",
194
+ "svg" => "http://www.w3.org/2000/svg",
195
+ })
196
+
197
+ l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
198
+ end
199
+
200
+ it "should reproduce 0101: XMLLiteral with explicit namespace and xml:lang" do
201
+ l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
202
+ :datatype => RDF.XMLLiteral, :language => :fr,
203
+ :namespaces => {
204
+ "" => "http://www.w3.org/1999/xhtml",
205
+ "svg" => "http://www.w3.org/2000/svg",
206
+ })
207
+
208
+ l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"fr\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
209
+ end
210
+
211
+ it "should reproduce test 0102: XMLLiteral with explicit namespace and xml:lang; not overwriting existing langs" do
212
+ l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg xml:lang="hu"><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
213
+ :datatype => RDF.XMLLiteral, :language => :fr,
214
+ :namespaces => {
215
+ "" => "http://www.w3.org/1999/xhtml",
216
+ "svg" => "http://www.w3.org/2000/svg",
217
+ })
218
+
219
+ l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"hu\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
220
+ end
221
+
222
+ it "should reproduce test 0103: XMLLiteral with explicit namespace; not overwriting local namespaces" do
223
+ l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg xmlns="http://www.w3.org/2000/svg"><rect width="200" height="100"/></svg>),
224
+ :datatype => RDF.XMLLiteral,
225
+ :namespaces => {
226
+ "" => "http://www.w3.org/1999/xhtml",
227
+ "svg" => "http://www.w3.org/2000/svg",
228
+ })
229
+
230
+ l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg xmlns=\"http://www.w3.org/2000/svg\"><rect height=\"100\" width=\"200\"></rect></svg>"
231
+ end
232
+ end
60
233
  end if defined?(::Nokogiri)
61
234
  end
data/spec/rdf-iso-falure.rb ADDED
@@ -0,0 +1,35 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require 'rdf'
4
+ require 'rdf/rdfxml'
5
+ require 'rdf/ntriples'
6
+ require 'rdf/isomorphic'
7
+
8
+ s1 = %(<?xml version="1.0"?>
9
+ <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
10
+ xmlns:eg="http://example.org/">
11
+ <rdf:Description rdf:about="http://example.org/foo">
12
+ <eg:bar rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">10</eg:bar>
13
+ <eg:baz rdf:datatype="http://www.w3.org/2001/XMLSchema#integer" xml:lang="fr">10</eg:baz>
14
+ </rdf:Description>
15
+ </rdf:RDF>)
16
+
17
+ s2 = %(<http://example.org/foo> <http://example.org/bar> "10"^^<http://www.w3.org/2001/XMLSchema#integer> .
18
+ <http://example.org/foo> <http://example.org/baz> "10"^^<http://www.w3.org/2001/XMLSchema#integer> .
19
+ )
20
+
21
+ g1 = RDF::Graph.new
22
+ RDF::RDFXML::Reader.new(s1).each {|s| g1 << s}
23
+
24
+ g1.each do |s|
25
+ puts s.object.datatype.inspect
26
+ end
27
+
28
+ res1 = g1.map(&:to_ntriples).join("")
29
+
30
+ g2 = RDF::Graph.new
31
+ RDF::NTriples::Reader.new(s2).each {|s| g2 << s}
32
+
33
+ puts g1.isomorphic_with?(g2) ? "graphs isomorphic" : "graphs non-isomorphic"
34
+
35
+ puts res1 == s2 ? "strings equivalent" : "strings differ"
data/spec/reader_spec.rb CHANGED
@@ -1,9 +1,16 @@
1
1
  # coding: utf-8
2
2
  require File.join(File.dirname(__FILE__), 'spec_helper')
3
+ require 'rdf/spec/reader'
3
4
 
4
5
  # w3c test suite: http://www.w3.org/TR/rdf-testcases/
5
6
 
6
7
  describe "RDF::RDFXML::Reader" do
8
+ before :each do
9
+ @reader = RDF::RDFXML::Reader
10
+ end
11
+
12
+ it_should_behave_like RDF_Reader
13
+
7
14
  context "discovery" do
8
15
  {
9
16
  "rdf" => RDF::Reader.for(:rdf),
@@ -18,7 +25,7 @@ describe "RDF::RDFXML::Reader" do
18
25
  "application/rdf+xml" => RDF::Reader.for(:content_type => "application/rdf+xml"),
19
26
  }.each_pair do |label, format|
20
27
  it "should discover '#{label}'" do
21
- format.should == RDF::RDFXML::Reader
28
+ format.should == @reader
22
29
  end
23
30
  end
24
31
  end
@@ -45,20 +52,20 @@ EOF
45
52
 
46
53
  it "should yield reader" do
47
54
  inner = mock("inner")
48
- inner.should_receive(:called).with(RDF::RDFXML::Reader)
49
- RDF::RDFXML::Reader.new(@sampledoc) do |reader|
55
+ inner.should_receive(:called).with(@reader)
56
+ @reader.new(@sampledoc) do |reader|
50
57
  inner.called(reader.class)
51
58
  end
52
59
  end
53
60
 
54
61
  it "should return reader" do
55
- RDF::RDFXML::Reader.new(@sampledoc).should be_a(RDF::RDFXML::Reader)
62
+ @reader.new(@sampledoc).should be_a(@reader)
56
63
  end
57
64
 
58
65
  it "should yield statements" do
59
66
  inner = mock("inner")
60
67
  inner.should_receive(:called).with(RDF::Statement).twice
61
- RDF::RDFXML::Reader.new(@sampledoc).each_statement do |statement|
68
+ @reader.new(@sampledoc).each_statement do |statement|
62
69
  inner.called(statement.class)
63
70
  end
64
71
  end
@@ -66,7 +73,7 @@ EOF
66
73
  it "should yield triples" do
67
74
  inner = mock("inner")
68
75
  inner.should_receive(:called).with(RDF::URI, RDF::URI, RDF::Literal).twice
69
- RDF::RDFXML::Reader.new(@sampledoc).each_triple do |subject, predicate, object|
76
+ @reader.new(@sampledoc).each_triple do |subject, predicate, object|
70
77
  inner.called(subject.class, predicate.class, object.class)
71
78
  end
72
79
  end
@@ -387,7 +394,7 @@ EOF
387
394
  t.run_test do |rdf_string|
388
395
  t.debug = []
389
396
  g = RDF::Graph.new
390
- RDF::RDFXML::Reader.new(rdf_string,
397
+ @reader.new(rdf_string,
391
398
  :base_uri => t.about,
392
399
  :strict => true,
393
400
  :debug => t.debug).each do |statement|
@@ -408,7 +415,7 @@ EOF
408
415
  t.run_test do |rdf_string, parser|
409
416
  lambda do
410
417
  g = RDF::Graph.new
411
- RDF::RDFXML::Reader.new(rdf_string,
418
+ @reader.new(rdf_string,
412
419
  :base_uri => t.about,
413
420
  :strict => true).each do |statement|
414
421
  g << statement
@@ -424,7 +431,7 @@ EOF
424
431
  def parse(input, options)
425
432
  @debug = []
426
433
  graph = RDF::Graph.new
427
- RDF::RDFXML::Reader.new(input, options.merge(:debug => @debug)).each do |statement|
434
+ @reader.new(input, options.merge(:debug => @debug)).each do |statement|
428
435
  graph << statement
429
436
  end
430
437
  graph
data/spec/uri_spec.rb CHANGED
@@ -17,43 +17,56 @@ describe RDF::URI do
17
17
  subject.join(RDF::URI.new("foo#bar")).to_s.should == "http://example.org/foo#bar"
18
18
  end
19
19
 
20
- describe "normalization" do
20
+ describe "utf-8 escaped" do
21
21
  {
22
- %w(http://foo ) => "http://foo/",
23
- %w(http://foo a) => "http://foo/a",
24
- %w(http://foo /a) => "http://foo/a",
25
- %w(http://foo #a) => "http://foo/#a",
26
-
27
- %w(http://foo/ ) => "http://foo/",
28
- %w(http://foo/ a) => "http://foo/a",
29
- %w(http://foo/ /a) => "http://foo/a",
30
- %w(http://foo/ #a) => "http://foo/#a",
31
-
32
- %w(http://foo# ) => "http://foo/", # Special case for Addressable
33
- %w(http://foo# a) => "http://foo/a",
34
- %w(http://foo# /a) => "http://foo/a",
35
- %w(http://foo# #a) => "http://foo/#a",
36
-
37
- %w(http://foo/bar ) => "http://foo/bar",
38
- %w(http://foo/bar a) => "http://foo/a",
39
- %w(http://foo/bar /a) => "http://foo/a",
40
- %w(http://foo/bar #a) => "http://foo/bar#a",
41
-
42
- %w(http://foo/bar/ ) => "http://foo/bar/",
43
- %w(http://foo/bar/ a) => "http://foo/bar/a",
44
- %w(http://foo/bar/ /a) => "http://foo/a",
45
- %w(http://foo/bar/ #a) => "http://foo/bar/#a",
46
-
47
- %w(http://foo/bar# ) => "http://foo/bar",
48
- %w(http://foo/bar# a) => "http://foo/a",
49
- %w(http://foo/bar# /a) => "http://foo/a",
50
- %w(http://foo/bar# #a) => "http://foo/bar#a",
51
-
52
- %w(http://foo/bar# #D%C3%BCrst) => "http://foo/bar#D%C3%BCrst",
53
- %w(http://foo/bar# #Dürst) => "http://foo/bar#D%C3%BCrst",
22
+ %(http://a/D%C3%BCrst) => %(<http://a/D%C3%BCrst>),
23
+ %(http://a/D\u00FCrst) => %(<http://a/D\\u00FCrst>),
24
+ %(http://b/Dürst) => %(<http://b/D\\u00FCrst>),
25
+ %(http://a/\u{15678}another) => %(<http://a/\\U00015678another>),
26
+ }.each_pair do |uri, dump|
27
+ it "should dump #{uri} as #{dump}" do
28
+ RDF::URI.new(uri).to_ntriples.should == dump
29
+ end
30
+ end
31
+ end if defined?(::Encoding) # Only works properly in Ruby 1.9
32
+
33
+ describe "join" do
34
+ {
35
+ %w(http://foo ) => "<http://foo>",
36
+ %w(http://foo a) => "<http://foo/a>",
37
+ %w(http://foo /a) => "<http://foo/a>",
38
+ %w(http://foo #a) => "<http://foo#a>",
39
+
40
+ %w(http://foo/ ) => "<http://foo/>",
41
+ %w(http://foo/ a) => "<http://foo/a>",
42
+ %w(http://foo/ /a) => "<http://foo/a>",
43
+ %w(http://foo/ #a) => "<http://foo/#a>",
44
+
45
+ %w(http://foo# ) => "<http://foo#>",
46
+ %w(http://foo# a) => "<http://foo/a>",
47
+ %w(http://foo# /a) => "<http://foo/a>",
48
+ %w(http://foo# #a) => "<http://foo#a>",
49
+
50
+ %w(http://foo/bar ) => "<http://foo/bar>",
51
+ %w(http://foo/bar a) => "<http://foo/a>",
52
+ %w(http://foo/bar /a) => "<http://foo/a>",
53
+ %w(http://foo/bar #a) => "<http://foo/bar#a>",
54
+
55
+ %w(http://foo/bar/ ) => "<http://foo/bar/>",
56
+ %w(http://foo/bar/ a) => "<http://foo/bar/a>",
57
+ %w(http://foo/bar/ /a) => "<http://foo/a>",
58
+ %w(http://foo/bar/ #a) => "<http://foo/bar/#a>",
59
+
60
+ %w(http://foo/bar# ) => "<http://foo/bar#>",
61
+ %w(http://foo/bar# a) => "<http://foo/a>",
62
+ %w(http://foo/bar# /a) => "<http://foo/a>",
63
+ %w(http://foo/bar# #a) => "<http://foo/bar#a>",
64
+
65
+ %w(http://foo/bar# #D%C3%BCrst) => "<http://foo/bar#D%C3%BCrst>",
66
+ %w(http://foo/bar# #Dürst) => "<http://foo/bar#D\\u00FCrst>",
54
67
  }.each_pair do |input, result|
55
68
  it "should create <#{result}> from <#{input[0]}> and '#{input[1]}'" do
56
- RDF::URI.new(input[0]).join(input[1].to_s).normalize.to_s.should == result
69
+ RDF::URI.new(input[0]).join(input[1].to_s).to_ntriples.should == result
57
70
  end
58
71
  end
59
72
  end