rdf-spec 0.2.3 → 0.3.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (36) hide show
  1. data/AUTHORS +1 -0
  2. data/CREDITS +1 -0
  3. data/README +12 -11
  4. data/VERSION +1 -1
  5. data/etc/doap.nt +28 -10
  6. data/lib/rdf/spec.rb +5 -4
  7. data/lib/rdf/spec/countable.rb +0 -1
  8. data/lib/rdf/spec/durable.rb +0 -1
  9. data/lib/rdf/spec/enumerable.rb +2 -3
  10. data/lib/rdf/spec/format.rb +0 -1
  11. data/lib/rdf/spec/graph.rb +0 -1
  12. data/lib/rdf/spec/indexable.rb +7 -0
  13. data/lib/rdf/spec/inferable.rb +7 -0
  14. data/lib/rdf/spec/list.rb +0 -1
  15. data/lib/rdf/spec/literal.rb +449 -291
  16. data/lib/rdf/spec/matchers.rb +4 -4
  17. data/lib/rdf/spec/mutable.rb +0 -1
  18. data/lib/rdf/spec/node.rb +0 -1
  19. data/lib/rdf/spec/query.rb +0 -1
  20. data/lib/rdf/spec/queryable.rb +3 -4
  21. data/lib/rdf/spec/readable.rb +0 -1
  22. data/lib/rdf/spec/reader.rb +0 -1
  23. data/lib/rdf/spec/repository.rb +0 -1
  24. data/lib/rdf/spec/resource.rb +0 -1
  25. data/lib/rdf/spec/statement.rb +0 -1
  26. data/lib/rdf/spec/term.rb +7 -0
  27. data/lib/rdf/spec/transaction.rb +7 -0
  28. data/lib/rdf/spec/uri.rb +125 -1
  29. data/lib/rdf/spec/value.rb +0 -1
  30. data/lib/rdf/spec/version.rb +2 -2
  31. data/lib/rdf/spec/vocab.rb +0 -1
  32. data/lib/rdf/spec/writable.rb +0 -1
  33. data/lib/rdf/spec/writer.rb +0 -1
  34. data/spec/spec_helper.rb +3 -0
  35. metadata +27 -23
  36. data/CONTRIBUTORS +0 -2
data/AUTHORS CHANGED
@@ -1,2 +1,3 @@
1
1
  * Arto Bendiken <arto.bendiken@gmail.com>
2
2
  * Ben Lavender <blavender@gmail.com>
3
+ * Gregg Kellogg <gregg@kellogg-assoc.com>
data/CREDITS ADDED
@@ -0,0 +1 @@
1
+ * John Fieber <jrf@ursamaris.org>
data/README CHANGED
@@ -15,14 +15,14 @@ Documentation
15
15
  Dependencies
16
16
  ------------
17
17
 
18
- * [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.2.3)
19
- * [RSpec](http://gemcutter.org/gems/rspec) (>= 1.3.0)
18
+ * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.0)
19
+ * [RSpec](http://rubygems.org/gems/rspec) (>= 2.1.0)
20
20
 
21
21
  Installation
22
22
  ------------
23
23
 
24
24
  The recommended installation method is via [RubyGems](http://rubygems.org/).
25
- To install the latest official release of `RDF::Spec`, do:
25
+ To install the latest official release of the `RDF::Spec` gem, do:
26
26
 
27
27
  % [sudo] gem install rdf-spec
28
28
 
@@ -33,25 +33,26 @@ To get a local working copy of the development repository, do:
33
33
 
34
34
  % git clone git://github.com/bendiken/rdf-spec.git
35
35
 
36
- Alternatively, you can download the latest development version as a tarball
37
- as follows:
36
+ Alternatively, download the latest development version as a tarball as
37
+ follows:
38
38
 
39
39
  % wget http://github.com/bendiken/rdf-spec/tarball/master
40
40
 
41
41
  Authors
42
42
  -------
43
43
 
44
- * [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
45
- * [Ben Lavender](mailto:blavender@gmail.com) - <http://bhuga.net/>
44
+ * [Arto Bendiken](http://github.com/bendiken) - <http://ar.to/>
45
+ * [Ben Lavender](http://github.com/bhuga) - <http://bhuga.net/>
46
+ * [Gregg Kellogg](http://github.com/gkellogg) - <http://kellogg-assoc.com/>
46
47
 
47
48
  Contributors
48
49
  ------------
49
50
 
50
- * [Gregg Kellogg](mailto:gregg@kellogg-assoc.com) - <http://kellogg-assoc.com/>
51
- * [John Fieber](mailto:jrf@ursamaris.org) - <http://github.com/jfieber>
51
+ * [John Fieber](http://github.com/jfieber) - <http://github.com/jfieber>
52
52
 
53
53
  Contributing
54
54
  ------------
55
+
55
56
  * Do your best to adhere to the existing coding conventions and idioms.
56
57
  * Don't use hard tabs, and don't leave trailing whitespace on any line.
57
58
  * Do refer to the [RubySpec Style Guide][RubySpec] for best practices.
@@ -68,8 +69,8 @@ Contributing
68
69
  License
69
70
  -------
70
71
 
71
- `RDF::Spec` is free and unencumbered public domain software. For more
72
- information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
72
+ This is free and unencumbered public domain software. For more information,
73
+ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
73
74
 
74
75
  [RDF.rb]: http://rdf.rubyforge.org/
75
76
  [RSpec]: http://rspec.info/
data/VERSION CHANGED
@@ -1 +1 @@
1
- 0.2.3
1
+ 0.3.0
data/etc/doap.nt CHANGED
@@ -12,6 +12,11 @@
12
12
  <http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/mbox> <mailto:blavender@gmail.com> .
13
13
  <http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "dbf45f4ffbd27b67aa84f02a6a31c144727d10af" .
14
14
  <http://bhuga.net/#ben> <http://xmlns.com/foaf/0.1/name> "Ben Lavender" .
15
+ <http://kellogg-assoc.com/#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
16
+ <http://kellogg-assoc.com/#me> <http://xmlns.com/foaf/0.1/homepage> <http://kellogg-assoc.com/> .
17
+ <http://kellogg-assoc.com/#me> <http://xmlns.com/foaf/0.1/mbox> <mailto:gregg@kellogg-assoc.com> .
18
+ <http://kellogg-assoc.com/#me> <http://xmlns.com/foaf/0.1/mbox_sha1sum> "35bc44e6d0070e5ad50ccbe0d24403c96af2b9bd" .
19
+ <http://kellogg-assoc.com/#me> <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg" .
15
20
  <http://rubygems.org/gems/rdf> <http://purl.org/dc/terms/creator> <http://ar.to/#self> .
16
21
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#blog> <http://ar.to/> .
17
22
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#blog> <http://blog.datagraph.org/> .
@@ -22,16 +27,23 @@
22
27
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#description> "RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data."@en .
23
28
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#developer> <http://ar.to/#self> .
24
29
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#developer> <http://bhuga.net/#ben> .
30
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#developer> <http://kellogg-assoc.com/#me> .
25
31
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#documenter> <http://ar.to/#self> .
32
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#documenter> <http://bhuga.net/#ben> .
33
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#documenter> <http://kellogg-assoc.com/#me> .
26
34
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#download-page> <http://rubyforge.org/projects/rdf/> .
27
35
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid1 .
28
36
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid2 .
29
37
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid3 .
30
38
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid4 .
31
39
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid5 .
40
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid6 .
41
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid7 .
32
42
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#homepage> <http://rdf.rubyforge.org/> .
33
43
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#license> <http://creativecommons.org/licenses/publicdomain/> .
34
44
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#maintainer> <http://ar.to/#self> .
45
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#maintainer> <http://bhuga.net/#ben> .
46
+ <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#maintainer> <http://kellogg-assoc.com/#me> .
35
47
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#name> "RDF.rb" .
36
48
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#platform> "Ruby" .
37
49
  <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#shortdesc> "A Ruby library for working with Resource Description Framework (RDF) data."@en .
@@ -39,17 +51,23 @@
39
51
  <http://rubygems.org/gems/rdf> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://usefulinc.com/ns/doap#Project> .
40
52
  <http://rubygems.org/gems/rdf> <http://xmlns.com/foaf/0.1/maker> <http://ar.to/#self> .
41
53
  _:genid1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
42
- _:genid1 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "d31fdd6af7a279a89bf09fdc9f7c44d9d08bb930" .
43
- _:genid1 <http://xmlns.com/foaf/0.1/name> "Fumihiro Kato" .
54
+ _:genid1 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "274bd18402fc773ffc0606996aa1fb90b603aa29" .
55
+ _:genid1 <http://xmlns.com/foaf/0.1/name> "C\u0103lin Ardelean" .
44
56
  _:genid2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
45
- _:genid2 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "35bc44e6d0070e5ad50ccbe0d24403c96af2b9bd" .
46
- _:genid2 <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg" .
57
+ _:genid2 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f412d743150d7b27b8468d56e69ca147917ea6fc" .
58
+ _:genid2 <http://xmlns.com/foaf/0.1/name> "Joey Geiger" .
47
59
  _:genid3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
48
- _:genid3 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "c69f3255ff0639543cc5edfd8116eac8df16fab8" .
49
- _:genid3 <http://xmlns.com/foaf/0.1/name> "Hellekin O. Wolf" .
60
+ _:genid3 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "d31fdd6af7a279a89bf09fdc9f7c44d9d08bb930" .
61
+ _:genid3 <http://xmlns.com/foaf/0.1/name> "Fumihiro Kato" .
50
62
  _:genid4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
51
- _:genid4 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f7653fc1ac0e82ebb32f092389bd5fc728eaae12" .
52
- _:genid4 <http://xmlns.com/foaf/0.1/name> "John Fieber" .
63
+ _:genid4 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "c69f3255ff0639543cc5edfd8116eac8df16fab8" .
64
+ _:genid4 <http://xmlns.com/foaf/0.1/name> "Hellekin O. Wolf" .
53
65
  _:genid5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
54
- _:genid5 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "bedbbf2451e5beb38d59687c0460032aff92cd3c" .
55
- _:genid5 <http://xmlns.com/foaf/0.1/name> "Pius Uzamere" .
66
+ _:genid5 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f7653fc1ac0e82ebb32f092389bd5fc728eaae12" .
67
+ _:genid5 <http://xmlns.com/foaf/0.1/name> "John Fieber" .
68
+ _:genid6 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
69
+ _:genid6 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "2b4247b6fd5bb4a1383378f325784318680d5ff9" .
70
+ _:genid6 <http://xmlns.com/foaf/0.1/name> "Keita Urashima" .
71
+ _:genid7 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
72
+ _:genid7 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "bedbbf2451e5beb38d59687c0460032aff92cd3c" .
73
+ _:genid7 <http://xmlns.com/foaf/0.1/name> "Pius Uzamere" .
data/lib/rdf/spec.rb CHANGED
@@ -1,4 +1,5 @@
1
- require 'rdf'
1
+ require 'rdf' # @see http://rubygems.org/gems/rdf
2
+ require 'rspec' # @see http://rubygems.org/gems/rspec
2
3
 
3
4
  module RDF
4
5
  ##
@@ -10,7 +11,7 @@ module RDF
10
11
  # @example Including the matchers in `spec/spec_helper.rb`
11
12
  # require 'rdf/spec'
12
13
  #
13
- # Spec::Runner.configure do |config|
14
+ # RSpec.configure do |config|
14
15
  # config.include(RDF::Spec::Matchers)
15
16
  # end
16
17
  #
@@ -45,5 +46,5 @@ module RDF
45
46
  module Spec
46
47
  autoload :Matchers, 'rdf/spec/matchers'
47
48
  autoload :VERSION, 'rdf/spec/version'
48
- end # module Spec
49
- end # module RDF
49
+ end # Spec
50
+ end # RDF
data/lib/rdf/spec/countable.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'rdf/spec'
2
- require 'spec'
3
2
 
4
3
  share_as :RDF_Countable do
5
4
  include RDF::Spec::Matchers
data/lib/rdf/spec/durable.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'rdf/spec'
2
- require 'spec'
3
2
 
4
3
  # To use RDF::Durable to check that a repository maintains information between
5
4
  # instantiations, add a Proc that creates a repository before each item, and
data/lib/rdf/spec/enumerable.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'rdf/spec'
2
- require 'spec'
3
2
 
4
3
  share_as :RDF_Enumerable do
5
4
  include RDF::Spec::Matchers
@@ -28,7 +27,7 @@ share_as :RDF_Enumerable do
28
27
  end
29
28
 
30
29
  it "should respond to #count and #size" do
31
- @enumerable.should respond_to(*%w(count size length))
30
+ @enumerable.should respond_to(*%w(count size))
32
31
  end
33
32
 
34
33
  it "should implement #empty?" do
@@ -37,7 +36,7 @@ share_as :RDF_Enumerable do
37
36
  end
38
37
 
39
38
  it "should implement #count and #size" do
40
- %w(count size length).each do |method|
39
+ %w(count size).each do |method|
41
40
  @enumerable.send(method).should == @statements.size
42
41
  end
43
42
  end
data/lib/rdf/spec/format.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'rdf/spec'
2
- require 'spec'
3
2
 
4
3
  share_as :RDF_Format do
5
4
  include RDF::Spec::Matchers
data/lib/rdf/spec/graph.rb CHANGED
@@ -1,4 +1,3 @@
1
- require 'rdf'
2
1
  require 'rdf/spec'
3
2
 
4
3
  share_as :RDF_Graph do
data/lib/rdf/spec/indexable.rb ADDED
@@ -0,0 +1,7 @@
1
+ require 'rdf/spec'
2
+
3
+ share_as :RDF_Indexable do
4
+ include RDF::Spec::Matchers
5
+
6
+ # TODO
7
+ end
data/lib/rdf/spec/inferable.rb ADDED
@@ -0,0 +1,7 @@
1
+ require 'rdf/spec'
2
+
3
+ share_as :RDF_Inferable do
4
+ include RDF::Spec::Matchers
5
+
6
+ # TODO
7
+ end
data/lib/rdf/spec/list.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  require 'rdf/spec'
2
- require 'spec'
3
2
 
4
3
  share_as :RDF_List do
5
4
  before :all do
data/lib/rdf/spec/literal.rb CHANGED
@@ -1,5 +1,4 @@
1
1
  # coding: utf-8
2
- require 'rdf'
3
2
  require 'rdf/spec'
4
3
 
5
4
  share_as :RDF_Literal do
@@ -9,259 +8,463 @@ share_as :RDF_Literal do
9
8
  raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
10
9
  end
11
10
 
12
- context "plain literals" do
13
- before :each do
14
- @empty = @new.call('')
15
- @hello = @new.call('Hello')
16
- @all = [@empty, @hello]
11
+ def self.literal(selector)
12
+ case selector
13
+ when :empty then ['']
14
+ when :plain then ['Hello']
15
+ when :empty_lang then ['', {:language => :en}]
16
+ when :plain_lang then ['Hello', {:language => :en}]
17
+ when :false then [false]
18
+ when :true then [true]
19
+ when :int then [123]
20
+ when :long then [9223372036854775807]
21
+ when :double then [3.1415]
22
+ when :date then [Date.new(2010)]
23
+ when :datetime then [DateTime.new(2011)]
24
+ when :time then [Time.parse('01:02:03Z')]
25
+ when :date then [Date.new(2010)]
26
+ when :xml_no_ns then ["foo <sup>bar</sup> baz!", {:datatype => RDF.XMLLiteral}]
27
+ when :xml_ns then ["foo <sup>bar</sup> baz!", {:datatype => RDF.XMLLiteral,
28
+ :namespaces => {"dc" => RDF::DC.to_s}}]
29
+ when :xml_ns2 then ["foo <sup xmlns:dc=\"http://purl.org/dc/terms/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!",
30
+ {:datatype => RDF.XMLLiteral,
31
+ :namespaces => {"" => RDF::DC.to_s}}]
32
+ when :xml_ns_lang then ["foo <sup>bar</sup> baz!", {:datatype => RDF.XMLLiteral,
33
+ :namespaces => {"dc" => RDF::DC.to_s}, :language => :fr}]
34
+ when :xml_lang_em then ["foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>",
35
+ {:datatype => RDF.XMLLiteral,
36
+ :namespaces => {"dc" => RDF::DC.to_s},
37
+ :language => :fr}]
38
+ when :xml_def_ns then ["foo <sup>bar</sup> baz!", {:datatype => RDF.XMLLiteral,
39
+ :namespaces => {"" => RDF::DC.to_s}}]
40
+ else
41
+ raise("unexpected literal: :#{selector}")
17
42
  end
43
+ end
18
44
 
19
- it "should be instantiable" do
20
- lambda { @new.call('') }.should_not raise_error
21
- @all.each do |literal|
22
- literal.plain?.should be_true
45
+ def self.literals(*selector)
46
+ selector.inject([]) do |ary, sel|
47
+ ary += case sel
48
+ when :all_plain_no_lang then [:empty, :plain].map {|sel| literal(sel)}
49
+ when :all_plain_lang then [:empty_lang, :plain_lang].map {|sel| literal(sel)}
50
+ when :all_native then [:false, :true, :int, :long, :double, :time, :date, :datetime].map {|sel| literal(sel)}
51
+ when :all_xml then [:xml_no_ns, :xml_ns, :xml_ns2, :xml_ns_lang, :xml_lang_em, :xml_def_ns].map {|sel| literal(sel)}
52
+ when :all_plain then literals(:all_plain_no_lang, :all_plain_lang)
53
+ else literals(:all_plain, :all_native, :all_xml)
23
54
  end
24
55
  end
56
+ end
25
57
 
26
- it "should not have a language" do
27
- @all.each do |literal|
28
- literal.language.should be_nil
29
- end
58
+ describe "new" do
59
+ it "instantiates empty string" do
60
+ lambda { @new.call('') }.should_not raise_error
30
61
  end
31
62
 
32
- it "should not have a datatype" do
33
- @all.each do |literal|
34
- literal.typed?.should be_false
35
- literal.datatype.should be_nil
36
- end
63
+ it "instantiates empty string with language" do
64
+ lambda { @new.call('', :language => :en) }.should_not raise_error
37
65
  end
38
66
 
39
- it "should support equality comparisons" do
40
- @all.each do |literal|
41
- copy = @new.call(literal.value)
42
- literal.should eql(copy)
43
- literal.should == copy
67
+ it "instantiates from native datatype" do
68
+ lambda { @new.call(123) }.should_not raise_error
69
+ end
44
70
 
45
- literal.should_not eql(literal.value)
46
- literal.should == literal.value # FIXME
71
+ describe "c18n" do
72
+ it "normalizes language to lower-case" do
73
+ @new.call('Upper', :language => :EN, :canonicalize => true).language.should == :en
47
74
  end
48
- end
49
75
 
50
- it "should have a string representation" do
51
- @empty.to_s.should eql("")
52
- @hello.to_s.should eql("Hello")
53
- end
76
+ it "supports sub-taged language specification" do
77
+ @new.call('Hi', :language => :"en-us", :canonicalize => true).language.should == :"en-us"
78
+ end
79
+
80
+ {
81
+ "true" => "true",
82
+ "false" => "false",
83
+ "tRuE" => "true",
84
+ "FaLsE" => "false",
85
+ "1" => "true",
86
+ "0" => "false",
87
+ }.each_pair do |value, str|
88
+ it "does not normalize boolean '#{value}' by default" do
89
+ @new.call(value, :datatype => RDF::XSD.boolean, :canonicalize => false).to_s.should == value
90
+ end
91
+
92
+ it "normalizes boolean '#{value}' to '#{str}'" do
93
+ @new.call(value, :datatype => RDF::XSD.boolean, :canonicalize => true).to_s.should == str
94
+ end
95
+
96
+ it "instantiates '#{value}' as RDF::Literal::Boolean" => true do
97
+ @new.call(value, :datatype => RDF::XSD.boolean, :canonicalize => true).should be_a(RDF::Literal::Boolean)
98
+ end
99
+
100
+ it "causes normalized '#{value}' to be == '#{str}'" do
101
+ @new.call(value, :datatype => RDF::XSD.boolean, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.boolean, :canonicalize => false)
102
+ end
103
+ end
104
+
105
+ {
106
+ "01" => "1",
107
+ "1" => "1",
108
+ "-1" => "-1",
109
+ "+1" => "1",
110
+ }.each_pair do |value, str|
111
+ it "does not normalize integer '#{value}' by default" do
112
+ @new.call(value, :datatype => RDF::XSD.integer, :canonicalize => false).to_s.should == value
113
+ end
114
+
115
+ it "normalizes integer '#{value}' to '#{str}'" do
116
+ @new.call(value, :datatype => RDF::XSD.integer, :canonicalize => true).to_s.should == str
117
+ end
118
+
119
+ it "instantiates '#{value}' as RDF::Literal::Integer" => true do
120
+ @new.call(value, :datatype => RDF::XSD.integer, :canonicalize => true).should be_a(RDF::Literal::Integer)
121
+ end
122
+
123
+ it "causes normalized '#{value}' to be == '#{str}'" do
124
+ @new.call(value, :datatype => RDF::XSD.integer, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.integer, :canonicalize => false)
125
+ end
126
+ end
127
+
128
+ {
129
+ "1" => "1.0",
130
+ "-1" => "-1.0",
131
+ "1." => "1.0",
132
+ "1.0" => "1.0",
133
+ "1.00" => "1.0",
134
+ "+001.00" => "1.0",
135
+ "123.456" => "123.456",
136
+ "2.345" => "2.345",
137
+ "1.000000000" => "1.0",
138
+ "2.3" => "2.3",
139
+ "2.234000005" => "2.234000005",
140
+ "2.2340000000000005" => "2.2340000000000005",
141
+ "2.23400000000000005" => "2.234",
142
+ "2.23400000000000000000005" => "2.234",
143
+ "1.2345678901234567890123457890" => "1.2345678901234567",
144
+ }.each_pair do |value, str|
145
+ it "does not normalize decimal '#{value}' by default" do
146
+ @new.call(value, :datatype => RDF::XSD.decimal, :canonicalize => false).to_s.should == value
147
+ end
148
+
149
+ it "normalizes decimal '#{value}' to '#{str}'" do
150
+ @new.call(value, :datatype => RDF::XSD.decimal, :canonicalize => true).to_s.should == str
151
+ end
54
152
 
55
- it "should not be #anonymous?" do
56
- @hello.should_not be_anonymous
153
+ it "instantiates '#{value}' as RDF::Literal::Decimal" => true do
154
+ @new.call(value, :datatype => RDF::XSD.decimal, :canonicalize => true).should be_a(RDF::Literal::Decimal)
155
+ end
156
+
157
+ it "causes normalized '#{value}' to be == '#{str}'" do
158
+ @new.call(value, :datatype => RDF::XSD.decimal, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.decimal, :canonicalize => false)
159
+ end
160
+ end
161
+
162
+ {
163
+ "1" => "1.0E0",
164
+ "-1" => "-1.0E0",
165
+ "+01.000" => "1.0E0",
166
+ #"1." => "1.0E0",
167
+ "1.0" => "1.0E0",
168
+ "123.456" => "1.23456E2",
169
+ "1.0e+1" => "1.0E1",
170
+ "1.0e-10" => "1.0E-10",
171
+ "123.456e4" => "1.23456E6",
172
+ }.each_pair do |value, str|
173
+ it "does not normalize double '#{value}' by default" do
174
+ @new.call(value, :datatype => RDF::XSD.double, :canonicalize => false).to_s.should == value
175
+ end
176
+
177
+ it "normalizes double '#{value}' to '#{str}'" do
178
+ @new.call(value, :datatype => RDF::XSD.double, :canonicalize => true).to_s.should == str
179
+ end
180
+
181
+ it "instantiates '#{value}' as RDF::Literal::Double" => true do
182
+ @new.call(value, :datatype => RDF::XSD.double, :canonicalize => true).should be_a(RDF::Literal::Double)
183
+ end
184
+
185
+ it "causes normalized '#{value}' to be == '#{str}'" do
186
+ @new.call(value, :datatype => RDF::XSD.double, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.double, :canonicalize => false)
187
+ end
188
+ end
189
+
190
+ # DateTime
191
+ {
192
+ "2010-01-01T00:00:00Z" => "2010-01-01T00:00:00Z",
193
+ "2010-01-01T00:00:00.0000Z" => "2010-01-01T00:00:00Z",
194
+ "2010-01-01T00:00:00" => "2010-01-01T00:00:00Z",
195
+ "2010-01-01T00:00:00+00:00" => "2010-01-01T00:00:00Z",
196
+ "2010-01-01T01:00:00+01:00" => "2010-01-01T00:00:00Z",
197
+ "2009-12-31T23:00:00-01:00" => "2010-01-01T00:00:00Z",
198
+ "-2010-01-01T00:00:00Z" => "-2010-01-01T00:00:00Z",
199
+ }.each_pair do |value, str|
200
+ it "does not normalize dateTime '#{value}' by default" do
201
+ @new.call(value, :datatype => RDF::XSD.dateTime, :canonicalize => false).to_s.should == value
202
+ end
203
+
204
+ it "normalizes dateTime '#{value}' to '#{str}'" do
205
+ @new.call(value, :datatype => RDF::XSD.dateTime, :canonicalize => true).to_s.should == str
206
+ end
207
+
208
+ it "instantiates '#{value}' as RDF::Literal::DateTime" => true do
209
+ @new.call(value, :datatype => RDF::XSD.dateTime, :canonicalize => true).should be_a(RDF::Literal::DateTime)
210
+ end
211
+
212
+ it "causes normalized '#{value}' to be == '#{str}'" do
213
+ @new.call(value, :datatype => RDF::XSD.dateTime, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.dateTime, :canonicalize => false)
214
+ end
215
+ end
216
+
217
+ # Date
218
+ {
219
+ "2010-01-01Z" => "2010-01-01Z",
220
+ "2010-01-01" => "2010-01-01Z",
221
+ "2010-01-01+00:00" => "2010-01-01Z",
222
+ "2010-01-01+01:00" => "2010-01-01Z",
223
+ "2009-12-31-01:00" => "2009-12-31Z",
224
+ "-2010-01-01Z" => "-2010-01-01Z",
225
+ }.each_pair do |value, str|
226
+ it "does not normalize date '#{value}' by default" do
227
+ @new.call(value, :datatype => RDF::XSD.date, :canonicalize => false).to_s.should == value
228
+ end
229
+
230
+ it "normalizes date '#{value}' to '#{str}'" do
231
+ @new.call(value, :datatype => RDF::XSD.date, :canonicalize => true).to_s.should == str
232
+ end
233
+
234
+ it "instantiates '#{value}' as RDF::Literal::Date" => true do
235
+ @new.call(value, :datatype => RDF::XSD.date, :canonicalize => true).should be_a(RDF::Literal::Date)
236
+ end
237
+
238
+ it "causes normalized '#{value}' to be == '#{str}'" do
239
+ @new.call(value, :datatype => RDF::XSD.date, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.date, :canonicalize => false)
240
+ end
241
+ end
242
+
243
+ # Time
244
+ {
245
+ "00:00:00Z" => "00:00:00Z",
246
+ "00:00:00.0000Z" => "00:00:00Z",
247
+ "00:00:00+00:00" => "00:00:00Z",
248
+ "01:00:00+01:00" => "00:00:00Z",
249
+ "23:00:00-01:00" => "00:00:00Z",
250
+ }.each_pair do |value, str|
251
+ it "does not normalize dateTime '#{value}' by default" do
252
+ @new.call(value, :datatype => RDF::XSD.time, :canonicalize => false).to_s.should == value
253
+ end
254
+
255
+ it "normalizes time '#{value}' to '#{str}'" do
256
+ @new.call(value, :datatype => RDF::XSD.time, :canonicalize => true).to_s.should == str
257
+ end
258
+
259
+ it "instantiates '#{value}' as RDF::Literal::Time" => true do
260
+ @new.call(value, :datatype => RDF::XSD.time, :canonicalize => true).should be_a(RDF::Literal::Time)
261
+ end
262
+
263
+ it "causes normalized '#{value}' to be == '#{str}'" do
264
+ @new.call(value, :datatype => RDF::XSD.time, :canonicalize => true).should == @new.call(str, :datatype => RDF::XSD.time, :canonicalize => false)
265
+ end
266
+ end
57
267
  end
58
268
  end
59
269
 
60
- context "languaged-tagged literals" do
61
- before :each do
62
- @empty = @new.call('', :language => :en)
63
- @hello = @new.call('Hello', :language => :en)
64
- @all = [@empty, @hello]
270
+ describe "#plain?" do
271
+ literals(:all_plain_no_lang).each do |args|
272
+ it "returns true for #{args.inspect}" do
273
+ literal = @new.call(*args)
274
+ literal.plain?.should be_true
275
+ end
65
276
  end
66
277
 
67
- it "should be instantiable" do
68
- lambda { @new.call('', :language => :en) }.should_not raise_error
278
+ literals(:all_plain_lang, :all_native, :all_xml).each do |args|
279
+ it "returns false for #{args.inspect}" do
280
+ literal = @new.call(*args)
281
+ literal.plain?.should be_false
282
+ end
283
+ end
284
+ end
285
+
286
+ describe "#language" do
287
+ literals(:all_plain_no_lang, :all_native, :all_xml).each do |args|
288
+ it "returns nil for #{args.inspect}" do
289
+ literal = @new.call(*args)
290
+ literal.language.should be_nil
291
+ end
69
292
  end
70
293
 
71
- it "should have a language" do
72
- @all.each do |literal|
73
- literal.language.should_not be_nil
294
+ literals(:all_plain_lang).each do |args|
295
+ it "returns language for #{args.inspect}" do
296
+ literal = @new.call(*args)
74
297
  literal.language.should == :en
75
298
  end
76
299
  end
300
+ end
77
301
 
78
- it "should not have a datatype" do
79
- @all.each do |literal|
80
- literal.typed?.should be_false
302
+ describe "#datatype" do
303
+ literals(:all_plain).each do |args|
304
+ it "returns nil for #{args.inspect}" do
305
+ literal = @new.call(*args)
81
306
  literal.datatype.should be_nil
82
307
  end
83
308
  end
84
309
 
85
- it "should support equality comparisons" do
86
- @all.each do |literal|
87
- copy = @new.call(literal.value, :language => literal.language)
88
- literal.should eql(copy)
89
- literal.should == copy
310
+ {
311
+ 123 => "integer",
312
+ true => "boolean",
313
+ false => "boolean",
314
+ 9223372036854775807 => "integer",
315
+ 3.1415 => "double",
316
+ Date.new(2010) => "date",
317
+ DateTime.new(2011) => "dateTime",
318
+ Time.parse("01:02:03Z") => "time"
319
+ }.each_pair do |value, type|
320
+ it "returns xsd.#{type} for #{value.inspect} #{value.class}" do
321
+ @new.call(value).datatype.should == XSD[type]
90
322
  end
91
323
  end
92
324
 
93
- it "should have a string representation" do
94
- @empty.to_s.should eql("")
95
- @hello.to_s.should eql("Hello")
96
- end
97
-
98
- context "c18n" do
99
- it "should normalize language to lower-case" do
100
- @new.call('Upper', :language => :EN, :canonicalize => true).language.should == :en
101
- end
102
-
103
- it "should support sub-taged language specification" do
104
- @new.call('Hi', :language => :"en-us", :canonicalize => true).language.should == :"en-us"
325
+ literals(:all_xml).each do |args|
326
+ it "returns datatype for #{args.inspect}" do
327
+ literal = @new.call(*args)
328
+ literal.datatype.should == RDF.XMLLiteral
105
329
  end
106
330
  end
107
331
  end
108
332
 
109
- context "datatyped literals" do
110
- require 'date'
333
+ describe "#typed?" do
334
+ literals(:all_plain).each do |args|
335
+ it "returns false for #{args.inspect}" do
336
+ literal = @new.call(*args)
337
+ literal.typed?.should be_false
338
+ end
339
+ end
111
340
 
112
- before :each do
113
- @string = @new.call('')
114
- @false = @new.call(false)
115
- @true = @new.call(true)
116
- @int = @new.call(123)
117
- @long = @new.call(9223372036854775807)
118
- @double = @new.call(3.1415)
119
- @date = @new.call(Date.new(2010))
120
- @datetime = @new.call(DateTime.new(2010))
121
- @time = @new.call(Time.parse('01:02:03Z'))
122
- @all = [@false, @true, @int, @long, @double, @time, @date, @datetime]
123
- end
341
+ literals(:all_native, :all_xml).each do |args|
342
+ it "returns true for #{args.inspect}" do
343
+ literal = @new.call(*args)
344
+ literal.typed?.should be_true
345
+ end
346
+ end
347
+ end
124
348
 
125
- it "should be instantiable" do
126
- lambda { @new.call(123) }.should_not raise_error
127
- lambda { @new.call(123, :datatype => XSD.int) }.should_not raise_error
349
+ describe "#==" do
350
+ literals(:all_plain).each do |args|
351
+ it "returns true for #{args.inspect}" do
352
+ literal = @new.call(*args)
353
+ literal.should == @new.call(*args)
354
+ end
128
355
  end
129
356
 
130
- it "should not have a language" do
131
- @all.each do |literal|
132
- literal.language.should be_nil
357
+ literals(:all_plain_no_lang).each do |args|
358
+ it "returns true for value of #{args.inspect}" do
359
+ literal = @new.call(*args)
360
+ literal.should == literal.value
133
361
  end
134
362
  end
135
363
 
136
- it "should have a datatype" do
137
- @all.each do |literal|
138
- literal.typed?.should be_true
139
- literal.datatype.should_not be_nil
364
+ literals(:all_plain_lang).each do |args|
365
+ it "returns false for value of #{args.inspect}" do
366
+ literal = @new.call(*args)
367
+ literal.should_not == literal.value
140
368
  end
141
369
  end
142
370
 
143
- it "should support implicit datatyping" do
144
- @string.datatype.should == nil
145
- @false.datatype.should == XSD.boolean
146
- @true.datatype.should == XSD.boolean
147
- @int.datatype.should == XSD.integer
148
- @long.datatype.should == XSD.integer
149
- @double.datatype.should == XSD.double
150
- @date.datatype.should == XSD.date
151
- @datetime.datatype.should == XSD.dateTime
152
- @time.datatype.should == XSD.time
153
- end
371
+ literals(:all_native).each do |args|
372
+ it "returns true for #{args.inspect}" do
373
+ literal = @new.call(*args)
374
+ literal.should == @new.call(*args)
375
+ end
154
376
 
155
- it "should support equality comparisons" do
156
- @all.each do |literal|
157
- copy = @new.call(literal.value, :datatype => literal.datatype)
158
- literal.should eql(copy)
159
- literal.should == copy
377
+ it "returns true for value of #{args.inspect}" do
378
+ literal = @new.call(*args)
379
+ #literal.should == literal.value # FIXME: fails on xsd:date, xsd:time, and xsd:dateTime
160
380
  end
161
381
  end
162
382
 
163
- it "should have a string representation" do
164
- @false.to_s.should eql("false")
165
- @true.to_s.should eql("true")
166
- @int.to_s.should eql("123")
167
- @long.to_s.should eql("9223372036854775807")
168
- @double.to_s.should eql("3.1415")
169
- @date.to_s.should eql("2010-01-01Z")
170
- @datetime.to_s.should eql("2010-01-01T00:00:00Z")
171
- @time.to_s.should eql("01:02:03Z")
172
- end
173
-
174
- it "should have an object representation" do
175
- @false.object.should eql(false)
176
- @true.object.should eql(true)
177
- @int.object.should eql(123)
178
- @long.object.should eql(9223372036854775807)
179
- @double.object.should eql(3.1415)
180
- @date.object.should eql(Date.new(2010))
181
- @datetime.object.should eql(DateTime.new(2010))
182
- @time.object.should eql(Time.parse('01:02:03Z'))
383
+ literals(:all_xml).each do |args|
384
+ it "returns true for #{args.inspect}" do
385
+ literal = @new.call(*args)
386
+ literal.should == @new.call(*args)
387
+ end
388
+
389
+ it "returns false for value of #{args.inspect}" do
390
+ literal = @new.call(*args)
391
+ literal.should_not == literal.value
392
+ end
183
393
  end
184
394
  end
185
395
 
186
- #require 'nokogiri' rescue nil
187
- describe "XML Literal" do
188
- describe "with no namespace" do
189
- subject { @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral) }
190
- it "should indicate xmlliteral?" do
191
- subject.xmlliteral?.should == true
192
- end
193
-
194
- describe "encodings" do
195
- it "should return n3" do subject.to_s.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
196
- end
197
-
198
- it "should be equal if they have the same contents" do
199
- should == @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral)
200
- end
201
-
202
- it "should be a XMLLiteral encoding" do
203
- subject.datatype.should == RDF.XMLLiteral
204
- end
205
- end
206
-
207
- describe "with a namespace" do
208
- subject {
209
- @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
210
- :namespaces => {"dc" => RDF::DC.to_s})
211
- }
212
-
213
- describe "encodings" do
214
- it "should return n3" do subject.to_s.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
215
- end
216
-
217
- describe "and language" do
218
- subject {
219
- @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
220
- :namespaces => {"dc" => RDF::DC.to_s},
221
- :language => :fr)
222
- }
223
-
224
- describe "encodings" do
225
- it "should return n3" do subject.to_s.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup> baz!\"\^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
226
- end
396
+ describe "#to_s" do
397
+ literals(:all_plain).each do |args|
398
+ it "returns value for #{args.inspect}" do
399
+ literal = @new.call(*args)
400
+ literal.to_s.should eql(literal.value)
227
401
  end
228
-
229
- describe "and language with an existing language embedded" do
230
- subject {
231
- @new.call("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>",
232
- :datatype => RDF.XMLLiteral,
233
- :language => :fr)
234
- }
402
+ end
235
403
 
236
- describe "encodings" do
237
- it "should return n3" do subject.to_s.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup><sub xml:lang=\\\"en\\\">baz</sub>\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
238
- end
404
+ {
405
+ literal(:int) => "123",
406
+ literal(:true) => "true",
407
+ literal(:false) => "false",
408
+ literal(:long) => "9223372036854775807",
409
+ literal(:double) => "3.1415",
410
+ literal(:date) => "2010-01-01Z",
411
+ literal(:datetime) => "2011-01-01T00:00:00Z",
412
+ literal(:time) => "01:02:03Z"
413
+ }.each_pair do |args, rep|
414
+ it "returns #{rep} for #{args.inspect}" do
415
+ literal = @new.call(*args)
416
+ literal.to_s.should eql(rep)
239
417
  end
240
418
  end
241
-
242
- describe "with a default namespace" do
243
- subject {
244
- R@new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
245
- :namespaces => {"" => RDF::DC.to_s})
246
- }
247
-
248
- describe "encodings" do
249
- it "should return n3" do subject.to_s.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/terms/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
419
+
420
+ {
421
+ literal(:xml_no_ns) => %("foo <sup>bar</sup> baz!"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>),
422
+ literal(:xml_ns) => %("foo <sup>bar</sup> baz!"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>),
423
+ literal(:xml_ns_lang) => %("foo <sup xml:lang=\\"fr\\">bar</sup> baz!"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>),
424
+ literal(:xml_lang_em) => %("foo <sup xml:lang=\\"fr\\">bar</sup><sub xml:lang=\\"en\\">baz</sub>"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>),
425
+ literal(:xml_def_ns) => %("foo <sup xmlns=\\"http://purl.org/dc/terms/\\">bar</sup> baz!"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>),
426
+ literal(:xml_ns2) => %(fixme),
427
+ }.each_pair do |args, rep|
428
+ it "returns n3 rep for #{args.inspect}" do
429
+ literal = @new.call(*args)
430
+ pending {literal.to_s.should == rep}
250
431
  end
251
432
  end
252
-
253
- describe "with multiple namespaces" do
254
- subject {
255
- @new.call("foo <sup xmlns:dc=\"http://purl.org/dc/terms/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", :datatype => RDF.XMLLiteral)
256
- }
257
- it "should ignore namespace order" do
258
- g = @new.call("foo <sup xmlns:dc=\"http://purl.org/dc/terms/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", :datatype => RDF.XMLLiteral)
259
- should == g
433
+ end
434
+
435
+ describe "#object" do
436
+ literals(:all_plain).each do |args|
437
+ it "returns value for #{args.inspect}" do
438
+ literal = @new.call(*args)
439
+ literal.object.should eql(literal.value)
260
440
  end
261
441
  end
262
- end if defined?(::Nokogiri)
263
-
264
- context "validation and c18n" do
442
+
443
+ {
444
+ literal(:int) => 123,
445
+ literal(:true) => true,
446
+ literal(:false) => false,
447
+ literal(:long) => 9223372036854775807,
448
+ literal(:double) => 3.1415,
449
+ literal(:date) => Date.new(2010),
450
+ literal(:datetime) => DateTime.new(2011),
451
+ literal(:time) => Time.parse('01:02:03Z')
452
+ }.each_pair do |args, value|
453
+ it "returns object for #{args.inspect}" do
454
+ literal = @new.call(*args)
455
+ literal.object.should eql(value)
456
+ end
457
+ end
458
+ end
459
+
460
+ describe "#anonymous?" do
461
+ it "returns false" do
462
+ @new.call("").anonymous?.should be_false
463
+ end
464
+ end
465
+
466
+ describe "#valid?" do
467
+ # Boolean
265
468
  {
266
469
  "true" => "true",
267
470
  "false" => "false",
@@ -269,39 +472,27 @@ share_as :RDF_Literal do
269
472
  "FaLsE" => "false",
270
473
  "1" => "true",
271
474
  "0" => "false",
272
- }.each_pair do |lit, str|
273
- it "should validate boolean '#{lit}'" do
274
- @new.call(lit, :datatype => RDF::XSD.boolean).valid?.should be_true
275
- end
276
-
277
- it "should not canonicalize boolean '#{lit}' by default" do
278
- @new.call(lit, :datatype => RDF::XSD.boolean, :canonicalize => false).to_s.should == lit
279
- end
280
-
281
- it "should canonicalize boolean '#{lit}'" do
282
- @new.call(lit, :datatype => RDF::XSD.boolean, :canonicalize => true).to_s.should == str
475
+ }.each_pair do |value, str|
476
+ it "validates boolean '#{value}'" do
477
+ @new.call(value, :datatype => RDF::XSD.boolean).valid?.should be_true
478
+ @new.call(value, :datatype => RDF::XSD.boolean).invalid?.should be_false
283
479
  end
284
480
  end
285
481
 
482
+ # Integer
286
483
  {
287
484
  "01" => "1",
288
485
  "1" => "1",
289
486
  "-1" => "-1",
290
487
  "+1" => "1",
291
- }.each_pair do |lit, str|
292
- it "should validate integer '#{lit}'" do
293
- @new.call(lit, :datatype => RDF::XSD.integer).valid?.should be_true
294
- end
295
-
296
- it "should not canonicalize integer '#{lit}' by default" do
297
- @new.call(lit, :datatype => RDF::XSD.integer, :canonicalize => false).to_s.should == lit
298
- end
299
-
300
- it "should canonicalize integer '#{lit}'" do
301
- @new.call(lit, :datatype => RDF::XSD.integer, :canonicalize => true).to_s.should == str
488
+ }.each_pair do |value, str|
489
+ it "validates integer '#{value}'" do
490
+ @new.call(value, :datatype => RDF::XSD.integer).valid?.should be_true
491
+ @new.call(value, :datatype => RDF::XSD.integer).invalid?.should be_false
302
492
  end
303
493
  end
304
494
 
495
+ # Decimal
305
496
  {
306
497
  "1" => "1.0",
307
498
  "-1" => "-1.0",
@@ -318,20 +509,14 @@ share_as :RDF_Literal do
318
509
  "2.23400000000000005" => "2.234",
319
510
  "2.23400000000000000000005" => "2.234",
320
511
  "1.2345678901234567890123457890" => "1.2345678901234567",
321
- }.each_pair do |lit, str|
322
- it "should validate decimal '#{lit}'" do
323
- @new.call(lit, :datatype => RDF::XSD.decimal).valid?.should be_true
324
- end
325
-
326
- it "should not canonicalize decimal '#{lit}' by default" do
327
- @new.call(lit, :datatype => RDF::XSD.decimal, :canonicalize => false).to_s.should == lit
328
- end
329
-
330
- it "should canonicalize decimal '#{lit}'" do
331
- @new.call(lit, :datatype => RDF::XSD.decimal, :canonicalize => true).to_s.should == str
512
+ }.each_pair do |value, str|
513
+ it "validates decimal '#{value}'" do
514
+ @new.call(value, :datatype => RDF::XSD.decimal).valid?.should be_true
515
+ @new.call(value, :datatype => RDF::XSD.decimal).invalid?.should be_false
332
516
  end
333
517
  end
334
-
518
+
519
+ # Double
335
520
  {
336
521
  "1" => "1.0E0",
337
522
  "-1" => "-1.0E0",
@@ -342,20 +527,13 @@ share_as :RDF_Literal do
342
527
  "1.0e+1" => "1.0E1",
343
528
  "1.0e-10" => "1.0E-10",
344
529
  "123.456e4" => "1.23456E6",
345
- }.each_pair do |lit, str|
346
- it "should validate double '#{lit}'" do
347
- @new.call(lit, :datatype => RDF::XSD.double).valid?.should be_true
348
- end
349
-
350
- it "should not canonicalize double '#{lit}' by default" do
351
- @new.call(lit, :datatype => RDF::XSD.double, :canonicalize => false).to_s.should == lit
352
- end
353
-
354
- it "should canonicalize double '#{lit}'" do
355
- @new.call(lit, :datatype => RDF::XSD.double, :canonicalize => true).to_s.should == str
530
+ }.each_pair do |value, str|
531
+ it "validates double '#{value}'" do
532
+ @new.call(value, :datatype => RDF::XSD.double).valid?.should be_true
533
+ @new.call(value, :datatype => RDF::XSD.double).invalid?.should be_false
356
534
  end
357
535
  end
358
-
536
+
359
537
  # DateTime
360
538
  {
361
539
  "2010-01-01T00:00:00Z" => "2010-01-01T00:00:00Z",
@@ -365,20 +543,13 @@ share_as :RDF_Literal do
365
543
  "2010-01-01T01:00:00+01:00" => "2010-01-01T01:00:00+01:00",
366
544
  "2009-12-31T23:00:00-01:00" => "2009-12-31T23:00:00-01:00",
367
545
  "-2010-01-01T00:00:00Z" => "-2010-01-01T00:00:00Z",
368
- }.each_pair do |lit, str|
369
- it "should validate dateTime '#{lit}'" do
370
- @new.call(lit, :datatype => RDF::XSD.dateTime).valid?.should be_true
371
- end
372
-
373
- it "should not canonicalize dateTime '#{lit}' by default" do
374
- @new.call(lit, :datatype => RDF::XSD.dateTime, :canonicalize => false).to_s.should == lit
375
- end
376
-
377
- it "should canonicalize dateTime '#{lit}'" do
378
- @new.call(lit, :datatype => RDF::XSD.dateTime, :canonicalize => true).to_s.should == str
546
+ }.each_pair do |value, str|
547
+ it "validates dateTime '#{value}'" do
548
+ @new.call(value, :datatype => RDF::XSD.dateTime).valid?.should be_true
549
+ @new.call(value, :datatype => RDF::XSD.dateTime).invalid?.should be_false
379
550
  end
380
551
  end
381
-
552
+
382
553
  # Date
383
554
  {
384
555
  "2010-01-01Z" => "2010-01-01Z",
@@ -387,21 +558,13 @@ share_as :RDF_Literal do
387
558
  "2010-01-01+01:00" => "2010-01-01Z",
388
559
  "2009-12-31-01:00" => "2009-12-31Z",
389
560
  "-2010-01-01Z" => "-2010-01-01Z",
390
- }.each_pair do |lit, str|
391
- it "should validate date '#{lit}'" do
392
- @new.call(lit, :datatype => RDF::XSD.date).valid?.should be_true
393
- end
394
-
395
- it "should not canonicalize date '#{lit}' by default" do
396
- @new.call(lit, :datatype => RDF::XSD.date, :canonicalize => false).to_s.should == lit
397
- end
398
-
399
- it "should canonicalize date '#{lit}'" do
400
- @new.call(lit, :datatype => RDF::XSD.date, :canonicalize => true).to_s.should == str
561
+ }.each_pair do |value, str|
562
+ it "validates date '#{value}'" do
563
+ @new.call(value, :datatype => RDF::XSD.date).valid?.should be_true
564
+ @new.call(value, :datatype => RDF::XSD.date).invalid?.should be_false
401
565
  end
402
566
  end
403
-
404
-
567
+
405
568
  # Time
406
569
  {
407
570
  "00:00:00Z" => "00:00:00Z",
@@ -410,21 +573,15 @@ share_as :RDF_Literal do
410
573
  "00:00:00+00:00" => "00:00:00Z",
411
574
  "01:00:00+01:00" => "00:00:00Z",
412
575
  "23:00:00-01:00" => "00:00:00Z",
413
- }.each_pair do |lit, str|
414
- it "should validate time '#{lit}'" do
415
- @new.call(lit, :datatype => RDF::XSD.time).valid?.should be_true
416
- end
417
-
418
- it "should not canonicalize dateTime '#{lit}' by default" do
419
- @new.call(lit, :datatype => RDF::XSD.time, :canonicalize => false).to_s.should == lit
420
- end
421
-
422
- it "should canonicalize dateTime '#{lit}'" do
423
- @new.call(lit, :datatype => RDF::XSD.time, :canonicalize => true).to_s.should == str
576
+ }.each_pair do |value, str|
577
+ it "validates time '#{value}'" do
578
+ @new.call(value, :datatype => RDF::XSD.time).valid?.should be_true
579
+ @new.call(value, :datatype => RDF::XSD.time).invalid?.should be_false
424
580
  end
425
581
  end
426
-
427
- # Invalid
582
+ end
583
+
584
+ describe "#invalid?" do
428
585
  {
429
586
  "foo" => RDF::XSD.boolean,
430
587
  "xyz" => RDF::XSD.integer,
@@ -436,20 +593,21 @@ share_as :RDF_Literal do
436
593
  "+2010-01-01T00:00:00Z" => RDF::XSD.dateTime,
437
594
  "2010-01-01T00:00:00FOO" => RDF::XSD.dateTime,
438
595
  "02010-01-01T00:00:00" => RDF::XSD.dateTime,
439
- "2010-01-01" => RDF::XSD.dateTime,
440
- "2010-1-1T00:00:00" => RDF::XSD.dateTime,
441
- "0000-01-01T00:00:00" => RDF::XSD.dateTime,
442
-
443
- "+2010-01-01Z" => RDF::XSD.date,
444
- "2010-01-01TFOO" => RDF::XSD.date,
445
- "02010-01-01" => RDF::XSD.date,
446
- "2010-1-1" => RDF::XSD.date,
447
- "0000-01-01" => RDF::XSD.date,
448
-
449
- "+00:00:00Z" => RDF::XSD.time,
450
- "-00:00:00Z" => RDF::XSD.time,
596
+ "2010-01-01" => RDF::XSD.dateTime,
597
+ "2010-1-1T00:00:00" => RDF::XSD.dateTime,
598
+ "0000-01-01T00:00:00" => RDF::XSD.dateTime,
599
+
600
+ "+2010-01-01Z" => RDF::XSD.date,
601
+ "2010-01-01TFOO" => RDF::XSD.date,
602
+ "02010-01-01" => RDF::XSD.date,
603
+ "2010-1-1" => RDF::XSD.date,
604
+ "0000-01-01" => RDF::XSD.date,
605
+
606
+ "+00:00:00Z" => RDF::XSD.time,
607
+ "-00:00:00Z" => RDF::XSD.time,
451
608
  }.each_pair do |value, datatype|
452
- it "should detect invalid encoding for '#{value}'" do
609
+ it "does not validate for '#{value}'" do
610
+ @new.call(value, :datatype => datatype).invalid?.should be_true
453
611
  @new.call(value, :datatype => datatype).valid?.should be_false
454
612
  end
455
613
  end