rdf-spec 0.2.3 → 0.3.0

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 (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