rdf-spec 0.2.2 → 0.2.3

data/README

@@ -15,7 +15,7 @@ Documentation
 Dependencies
 ------------
 
-* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.2.1)
+* [RDF.rb](http://gemcutter.org/gems/rdf) (>= 0.2.3)
 * [RSpec](http://gemcutter.org/gems/rspec) (>= 1.3.0)
 
 Installation
@@ -50,11 +50,28 @@ Contributors
 * [Gregg Kellogg](mailto:gregg@kellogg-assoc.com) - <http://kellogg-assoc.com/>
 * [John Fieber](mailto:jrf@ursamaris.org) - <http://github.com/jfieber>
 
+Contributing
+------------
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+* Do refer to the [RubySpec Style Guide][RubySpec] for best practices.
+* Don't touch the `.gemspec` or `VERSION` files. If you need to change them,
+  do so on your private branch only.
+* Do feel free to add yourself to the `CONTRIBUTORS` file and the
+  corresponding list in the the `README`. Alphabetical order applies.
+* Don't touch the `AUTHORS` file. If your contributions are significant
+  enough, be assured we will eventually add you in there.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
 License
 -------
 
 `RDF::Spec` is free and unencumbered public domain software. For more
 information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
 
-[RDF.rb]: http://rdf.rubyforge.org/
-[RSpec]:  http://rspec.info/
+[RDF.rb]:    http://rdf.rubyforge.org/
+[RSpec]:     http://rspec.info/
+[RubySpec]:  http://rubyspec.org/wiki/rubyspec/Style_Guide
+[PDD]:       http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/etc/doap.nt

@@ -27,6 +27,8 @@
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid1 .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid2 .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid3 .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid4 .
+<http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#helper> _:genid5 .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#homepage> <http://rdf.rubyforge.org/> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#license> <http://creativecommons.org/licenses/publicdomain/> .
 <http://rubygems.org/gems/rdf> <http://usefulinc.com/ns/doap#maintainer> <http://ar.to/#self> .
@@ -37,11 +39,17 @@
 <http://rubygems.org/gems/rdf> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://usefulinc.com/ns/doap#Project> .
 <http://rubygems.org/gems/rdf> <http://xmlns.com/foaf/0.1/maker> <http://ar.to/#self> .
 _:genid1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
-_:genid1 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "c69f3255ff0639543cc5edfd8116eac8df16fab8" .
-_:genid1 <http://xmlns.com/foaf/0.1/name> "Hellekin O. Wolf" .
+_:genid1 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "d31fdd6af7a279a89bf09fdc9f7c44d9d08bb930" .
+_:genid1 <http://xmlns.com/foaf/0.1/name> "Fumihiro Kato" .
 _:genid2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
-_:genid2 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f7653fc1ac0e82ebb32f092389bd5fc728eaae12" .
-_:genid2 <http://xmlns.com/foaf/0.1/name> "John Fieber" .
+_:genid2 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "35bc44e6d0070e5ad50ccbe0d24403c96af2b9bd" .
+_:genid2 <http://xmlns.com/foaf/0.1/name> "Gregg Kellogg" .
 _:genid3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
-_:genid3 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "bedbbf2451e5beb38d59687c0460032aff92cd3c" .
-_:genid3 <http://xmlns.com/foaf/0.1/name> "Pius Uzamere" .
+_:genid3 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "c69f3255ff0639543cc5edfd8116eac8df16fab8" .
+_:genid3 <http://xmlns.com/foaf/0.1/name> "Hellekin O. Wolf" .
+_:genid4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+_:genid4 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "f7653fc1ac0e82ebb32f092389bd5fc728eaae12" .
+_:genid4 <http://xmlns.com/foaf/0.1/name> "John Fieber" .
+_:genid5 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+_:genid5 <http://xmlns.com/foaf/0.1/mbox_sha1sum> "bedbbf2451e5beb38d59687c0460032aff92cd3c" .
+_:genid5 <http://xmlns.com/foaf/0.1/name> "Pius Uzamere" .

data/lib/rdf/spec/countable.rb

@@ -19,24 +19,31 @@ share_as :RDF_Countable do
     end
   end
 
-  context "when counting items" do
-    it "should respond to #empty?" do
+  describe "when counting items" do
+    it "responds to #empty?" do
       @countable.should respond_to(:empty?)
     end
 
-    it "should respond to #count and #size" do
-      @countable.should respond_to(*%w(count size))
+    it "responds to #count and #size" do
+      @countable.should respond_to(:count, :size)
     end
 
-    it "should implement #empty?" do
+    it "implements #empty?" do
       ([].extend(RDF::Countable)).empty?.should be_true
+      ([42].extend(RDF::Countable)).empty?.should be_false
       @countable.empty?.should be_false
     end
 
-    it "should implement #count and #size" do
+    it "implements #count and #size" do
       %w(count size).each do |method|
         @countable.send(method).should == @statements.size
       end
     end
+
+    it "returns countable enumerators" do
+      @countable.to_enum.should be_countable
+      @countable.enum_for.should be_countable
+      @countable.enum_for(:each).should be_countable
+    end
   end
 end

data/lib/rdf/spec/durable.rb

@@ -39,12 +39,11 @@ share_as :RDF_Durable do
   end
 
   it "should not be both durable and nondurable" do
-    @load_durable.call.nondurable?.should_not == @load_durable.call.durable? 
+    @load_durable.call.nondurable?.should_not == @load_durable.call.durable?
   end
 
   it "should save contents between instantiations" do
     @load_durable.call.load(@filename)
-    @load_durable.call.count.should == File.readlines(@filename).size 
+    @load_durable.call.count.should == File.readlines(@filename).size
   end
 end
-

data/lib/rdf/spec/graph.rb

@@ -2,7 +2,6 @@ require 'rdf'
 require 'rdf/spec'
 
 share_as :RDF_Graph do
-
   before :each do
     raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
   end
@@ -52,5 +51,4 @@ share_as :RDF_Graph do
       graph.should_not be_anonymous
     end
   end
-
 end

data/lib/rdf/spec/list.rb

@@ -0,0 +1,713 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_List do
+  before :all do
+    @nil = RDF::List::NIL
+  end
+
+  before :each do
+    @abc = RDF::List[
+      @a = RDF::Literal.new('a'),
+      @b = RDF::Literal.new('b'),
+      @c = RDF::Literal.new('c')]
+    @ten = RDF::List[*(1..10)]
+  end
+
+  ORDINALS = %w(first second third fourth fifth sixth seventh eighth ninth tenth)
+
+  it "is comparable" do
+    RDF::List.new.should be_a_kind_of(::Comparable)
+  end
+
+  it "is enumerable" do
+    RDF::List.new.should be_a_kind_of(::Enumerable)
+  end
+
+  describe RDF::List, "[] without arguments" do
+    it "constructs a new empty list" do
+      RDF::List[].should be_an(RDF::List)
+      RDF::List[].should be_empty
+      RDF::List[].should == RDF::List::NIL
+    end
+  end
+
+  describe RDF::List, "[] with arguments" do
+    it "constructs a new non-empty list" do
+      RDF::List[1, 2, 3].should be_an(RDF::List)
+      RDF::List[1, 2, 3].should_not be_empty
+    end
+
+    it "accepts list arguments" do
+      lambda { RDF::List[RDF::List[]] }.should_not raise_error
+    end
+
+    it "accepts array arguments" do
+      lambda { RDF::List[[]] }.should_not raise_error
+      RDF::List[[]].should == RDF::List[RDF::List[]]
+    end
+
+    it "accepts blank node arguments" do
+      lambda { RDF::List[RDF::Node.new] }.should_not raise_error
+    end
+
+    it "accepts URI arguments" do
+      lambda { RDF::List[RDF.nil] }.should_not raise_error
+    end
+
+    it "accepts nil arguments" do
+      lambda { RDF::List[nil] }.should_not raise_error
+    end
+
+    it "accepts literal arguments" do
+      lambda { RDF::List[RDF::Literal.new("Hello, world!", :language => :en)] }.should_not raise_error
+    end
+
+    it "accepts boolean arguments" do
+      lambda { RDF::List[true, false] }.should_not raise_error
+    end
+
+    it "accepts string arguments" do
+      lambda { RDF::List["foo", "bar"] }.should_not raise_error
+    end
+
+    it "accepts integer arguments" do
+      lambda { RDF::List[1, 2, 3] }.should_not raise_error
+    end
+
+    it "accepts float arguments" do
+      lambda { RDF::List[3.1415] }.should_not raise_error
+    end
+
+    it "accepts decimal arguments" do
+      lambda { RDF::List[BigDecimal("3.1415")] }.should_not raise_error
+    end
+
+    it "accepts time arguments" do
+      lambda { RDF::List[Time.now] }.should_not raise_error
+    end
+
+    it "accepts date arguments" do
+      lambda { RDF::List[Date.new(2010)] }.should_not raise_error
+    end
+
+    it "accepts datetime arguments" do
+      lambda { RDF::List[DateTime.new(2010)] }.should_not raise_error
+    end
+  end
+
+  describe RDF::List, "#subject" do
+    it "requires no arguments" do
+      lambda { @nil.subject }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a resource" do
+      @nil.subject.should be_a_resource
+    end
+  end
+
+  describe RDF::List, "#graph" do
+    it "requires no arguments" do
+      lambda { @nil.graph }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a graph" do
+      @nil.graph.should be_a_graph
+    end
+  end
+
+  describe RDF::List, "#&" do
+    it "accepts one argument" do
+      lambda { @nil & @nil }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:&) }.should raise_error(ArgumentError)
+    end
+
+    it "returns the set intersection of self and the given argument" do
+      (RDF::List[1, 2] & RDF::List[1, 2]).should == RDF::List[1, 2]
+      (RDF::List[1, 2] & RDF::List[2, 3]).should == RDF::List[2]
+      (RDF::List[1, 2] & RDF::List[3, 4]).should == RDF::List[]
+    end
+  end
+
+  describe RDF::List, "#|" do
+    it "accepts one argument" do
+      lambda { @nil | @nil }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:|) }.should raise_error(ArgumentError)
+    end
+
+    it "returns the set union of self and the given argument" do
+      (RDF::List[1, 2] | RDF::List[1, 2]).should == RDF::List[1, 2]
+      (RDF::List[1, 2] | RDF::List[2, 3]).should == RDF::List[1, 2, 3]
+      (RDF::List[1, 2] | RDF::List[3, 4]).should == RDF::List[1, 2, 3, 4]
+    end
+  end
+
+  describe RDF::List, "#+" do
+    it "accepts one argument" do
+      lambda { @nil + @nil }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:+) }.should raise_error(ArgumentError)
+    end
+
+    it "returns the concatenation of self and the given argument" do
+      (RDF::List[1, 2] + RDF::List[3, 4]).should == RDF::List[1, 2, 3, 4]
+    end
+  end
+
+  describe RDF::List, "#-" do
+    it "accepts one argument" do
+      lambda { @nil - @nil }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:-) }.should raise_error(ArgumentError)
+    end
+
+    it "returns the difference between self and the given argument" do
+      (RDF::List[1, 2, 2, 3] - RDF::List[2]).should == RDF::List[1, 3]
+    end
+  end
+
+  describe RDF::List, "#*" do
+    it "accepts one argument" do
+      lambda { @nil * 1 }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:*) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe RDF::List, "#* with an integer argument" do
+    it "returns a repetition of self" do
+      (RDF::List[1, 2, 3] * 2).should == RDF::List[1, 2, 3, 1, 2, 3]
+    end
+  end
+
+  describe RDF::List, "#* with a string argument" do
+    it "returns the string concatenation of all elements" do
+      (RDF::List[1, 2, 3] * ",").should == "1,2,3"
+    end
+  end
+
+  describe RDF::List, "#[]" do
+    it "accepts one argument" do
+      lambda { @nil[0] }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @nil.__send__(:[]) }.should raise_error(ArgumentError)
+    end
+
+    it "returns a value for valid indexes" do
+      @ten[0].should be_a_value
+    end
+
+    it "returns nil for invalid indexes" do
+      @nil[0].should be_nil
+      @ten[20].should be_nil
+    end
+  end
+
+  describe RDF::List, "#[]=" do
+    # TODO
+  end
+
+  describe RDF::List, "#<<" do
+    it "accepts one argument" do
+      lambda { @ten << 11 }.should_not raise_error(ArgumentError)
+    end
+
+    it "rejects fewer arguments" do
+      lambda { @ten.__send__(:<<) }.should raise_error(ArgumentError)
+    end
+
+    it "appends the new value at the tail of the list" do
+      @ten << 11
+      @ten.last.should == RDF::Literal.new(11)
+    end
+
+    it "increments the length of the list by one" do
+      @ten << 11
+      @ten.length.should == 11
+    end
+
+    it "returns self" do
+      (@ten << 11).should equal(@ten)
+    end
+  end
+
+  describe RDF::List, "#shift" do
+    # TODO
+  end
+
+  describe RDF::List, "#unshift" do
+    # TODO
+  end
+
+  describe RDF::List, "#clear" do
+    # TODO
+  end
+
+  describe RDF::List, "#eql?" do
+    it "requires an argument" do
+      lambda { @nil.send(:eql?) }.should raise_error(ArgumentError)
+    end
+
+    it "returns true when given the same list" do
+      @ten.should eql(@ten)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#<=>" do
+    it "requires an argument" do
+      lambda { @nil.send(:<=>) }.should raise_error(ArgumentError)
+    end
+
+    it "returns 0 when given the same list" do
+      @ten.should == @ten
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#==" do
+    it "requires an argument" do
+      lambda { @nil.send(:==) }.should raise_error(ArgumentError)
+    end
+
+    it "returns true when given the same list" do
+      @ten.should == @ten
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#===" do
+    it "requires an argument" do
+      lambda { @nil.send(:===) }.should raise_error(ArgumentError)
+    end
+
+    it "returns true when given the same list" do
+      @ten.should == @ten
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#empty?" do
+    it "requires no arguments" do
+      lambda { @nil.empty? }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a boolean" do
+      @nil.empty?.should be_true
+      @abc.empty?.should be_false
+      @ten.empty?.should be_false
+    end
+  end
+
+  describe RDF::List, "#length" do
+    it "requires no arguments" do
+      lambda { @nil.length }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns an integer" do
+      @nil.length.should be_an(Integer)
+    end
+
+    it "returns the length of the list" do
+      @nil.length.should == 0
+      @abc.length.should == 3
+      @ten.length.should == 10
+    end
+  end
+
+  describe RDF::List, "#size" do
+    it "aliases #length" do
+      @nil.size.should == @nil.length
+      @ten.size.should == @ten.length
+    end
+  end
+
+  describe RDF::List, "#index" do
+    it "accepts one argument" do
+      lambda { @ten.index(nil) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe RDF::List, "#slice using an element index" do
+    it "accepts one argument" do
+      lambda { @ten.slice(0) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a value" do
+      @ten.slice(0).should be_a_value
+    end
+  end
+
+  describe RDF::List, "#slice using a start index and a length" do
+    it "accepts two arguments" do
+      lambda { @ten.slice(0, 9) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a value" do
+      @ten.slice(0).should be_a_value
+    end
+  end
+
+  describe RDF::List, "#slice using a range" do
+    it "accepts one argument" do
+      lambda { @ten.slice(0..9) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe RDF::List, "#fetch" do
+    it "requires one argument" do
+      lambda { @ten.fetch }.should raise_error(ArgumentError)
+      lambda { @ten.fetch(0) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a value" do
+      @ten.fetch(0).should be_a_value
+    end
+
+    it "returns the value at the given index" do
+      @ten.fetch(0).should == RDF::Literal.new(1)
+      @ten.fetch(9).should == RDF::Literal.new(10)
+    end
+
+    it "raises IndexError for invalid indexes" do
+      lambda { @ten.fetch(20) }.should raise_error(IndexError)
+    end
+  end
+
+  describe RDF::List, "#fetch with a default value" do
+    it "accepts two arguments" do
+      lambda { @ten.fetch(0, nil) }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns the second argument for invalid indexes" do
+      lambda { @ten.fetch(20, nil) }.should_not raise_error(IndexError)
+      @ten.fetch(20, true).should == true
+    end
+  end
+
+  describe RDF::List, "#fetch with a block" do
+    it "yields to the given block for invalid indexes" do
+      lambda { @ten.fetch(20) { |index| } }.should_not raise_error(IndexError)
+      @ten.fetch(20) { |index| true }.should == true
+    end
+  end
+
+  describe RDF::List, "#at" do
+    it "accepts one argument" do
+      lambda { @ten.at(0) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe RDF::List, "#nth" do
+    it "aliases #at" do
+      (1..10).each do |n|
+        @ten.nth(n).should == @ten.at(n)
+      end
+    end
+  end
+
+  ORDINALS.each_with_index do |ordinal, index|
+    describe RDF::List, "##{ordinal}" do
+      it "requires no arguments" do
+        lambda { @ten.__send__(ordinal.to_sym) }.should_not raise_error(ArgumentError)
+      end
+
+      it "returns a value" do
+        @ten.__send__(ordinal.to_sym).should be_a_value
+      end
+
+      it "returns the #{ordinal} value in the list" do
+        @ten.__send__(ordinal.to_sym).should == RDF::Literal.new(index + 1)
+      end
+    end
+  end
+
+  describe RDF::List, "#last" do
+    it "requires no arguments" do
+      lambda { @ten.last }.should_not raise_error(ArgumentError)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#rest" do
+    it "requires no arguments" do
+      lambda { @ten.rest }.should_not raise_error(ArgumentError)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#tail" do
+    it "requires no arguments" do
+      lambda { @ten.tail }.should_not raise_error(ArgumentError)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#first_subject" do
+    it "requires no arguments" do
+      lambda { @ten.first_subject }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe RDF::List, "#rest_subject" do
+    it "requires no arguments" do
+      lambda { @ten.rest_subject }.should_not raise_error(ArgumentError)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#last_subject" do
+    it "requires no arguments" do
+      lambda { @ten.last_subject }.should_not raise_error(ArgumentError)
+    end
+
+    # TODO
+  end
+
+  describe RDF::List, "#each_subject without a block" do
+    it "requires no arguments" do
+      lambda { @ten.each_subject }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns an enumerator" do
+      @abc.each_subject.should be_an_enumerator
+    end
+  end
+
+  describe RDF::List, "#each_subject with a block" do
+    it "requires no arguments" do
+      lambda { @ten.each_subject { |subject| } }.should_not raise_error(ArgumentError)
+    end
+
+    it "yields all subject terms in the list" do
+      count = 0
+      @ten.each_subject { |subject| count += 1 }
+      count.should == 10
+    end
+  end
+
+  describe RDF::List, "#each without a block" do
+    it "requires no arguments" do
+      lambda { @ten.each }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns an enumerator" do
+      @abc.each_subject.should be_an_enumerator
+    end
+  end
+
+  describe RDF::List, "#each with a block" do
+    it "requires no arguments" do
+      lambda { @ten.each { |value| } }.should_not raise_error(ArgumentError)
+    end
+
+    it "yields the correct number of times" do
+      @abc.each.count.should == 3
+      @ten.each.count.should == 10
+    end
+  end
+
+  describe RDF::List, "#each_statement without a block" do
+    it "requires no arguments" do
+      lambda { @ten.each_statement }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns an enumerator" do
+      @abc.each_subject.should be_an_enumerator
+    end
+  end
+
+  describe RDF::List, "#each_statement with a block" do
+    it "requires no arguments" do
+      lambda { @ten.each_statement { |statement| } }.should_not raise_error(ArgumentError)
+    end
+
+    it "yields the correct number of times" do
+      @abc.each_statement.count.should == 3 * 3
+      @ten.each_statement.count.should == 10 * 3
+    end
+
+    it "yields statements" do
+      @ten.each_statement do |statement|
+        statement.should be_a_statement
+      end
+    end
+  end
+
+  describe RDF::List, "#join" do
+    it "requires no arguments" do
+      lambda { @nil.join }.should_not raise_error(ArgumentError)
+    end
+
+    it "accepts one argument" do
+      lambda { @nil.join(', ') }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a string" do
+      @ten.join.should be_a(String)
+    end
+
+    it "returns a particular string" do
+      @ten.join.should == '12345678910'
+      @ten.join(',').should == '1,2,3,4,5,6,7,8,9,10'
+    end
+  end
+
+  describe RDF::List, "#reverse" do
+    it "requires no arguments" do
+      lambda { @nil.reverse }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a list" do
+      @ten.reverse.should be_a_list
+    end
+
+    it "returns the values reversed" do
+      @ten.reverse.first.should == RDF::Literal.new(10)
+    end
+  end
+
+  describe RDF::List, "#sort without a block" do
+    it "requires no arguments" do
+      lambda { @nil.sort }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a list" do
+      @ten.sort.should be_a_list
+    end
+  end
+
+  describe RDF::List, "#sort with a block" do
+    it "requires no arguments" do
+      lambda { @nil.sort { |a, b| } }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a list" do
+      @ten.sort { |a, b| a <=> b }.should be_a_list
+    end
+  end
+
+  describe RDF::List, "#sort_by with a block" do
+    it "requires no arguments" do
+      lambda { @nil.sort_by { |value| } }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a list" do
+      @ten.sort_by(&:to_i).should be_a_list
+    end
+  end
+
+  describe RDF::List, "#uniq" do
+    it "requires no arguments" do
+      lambda { @nil.uniq }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a list" do
+      @ten.uniq.should be_a_list
+    end
+
+    it "returns a list with duplicate values removed" do
+      RDF::List[1, 2, 2, 3].uniq.should == RDF::List[1, 2, 3]
+    end
+  end
+
+  describe RDF::List, "#to_a" do
+    it "requires no arguments" do
+      lambda { @nil.to_a }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns an array" do
+      @nil.to_a.should be_an(Array)
+    end
+
+    it "returns an array of the correct size" do
+      @nil.to_a.size.should == @nil.length
+      @abc.to_a.size.should == @abc.length
+      @ten.to_a.size.should == @ten.length
+    end
+  end
+
+  describe RDF::List, "#to_set" do
+    it "requires no arguments" do
+      lambda { @nil.to_set }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a set" do
+      @nil.to_set.should be_a(Set)
+    end
+
+    it "returns a set of the correct size" do
+      @nil.to_set.size.should == @nil.length
+      @abc.to_set.size.should == @abc.length
+      @ten.to_set.size.should == @ten.length
+    end
+
+    it "returns a set without duplicates" do
+      RDF::List[1, 2, 2, 3].to_set.map(&:to_i).sort.should == [1, 2, 3]
+    end
+  end
+
+  describe RDF::List, "#to_s" do
+    it "requires no arguments" do
+      lambda { @nil.to_s }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a string" do
+      @nil.to_s.should be_a(String)
+    end
+  end
+
+  describe RDF::List, "#inspect" do
+    it "requires no arguments" do
+      lambda { @nil.inspect }.should_not raise_error(ArgumentError)
+    end
+
+    it "returns a string" do
+      @nil.inspect.should be_a(String)
+    end
+  end
+end
+
+share_as :RDF_List_NIL do
+  it "#subject returns rdf:nil" do
+    RDF::List::NIL.subject.should == RDF.nil
+  end
+
+  it "#frozen? returns true" do
+    RDF::List::NIL.frozen?.should be_true
+  end
+
+  it "#empty? returns true" do
+    RDF::List::NIL.empty?.should be_true
+  end
+
+  it "#[] returns an empty array" do
+    RDF::List::NIL.to_a.should == []
+  end
+
+  it "#inspect returns the constant name" do
+    RDF::List::NIL.inspect.should == 'RDF::List::NIL'
+  end
+end

data/lib/rdf/spec/literal.rb

@@ -3,7 +3,6 @@ require 'rdf'
 require 'rdf/spec'
 
 share_as :RDF_Literal do
-
   XSD = RDF::XSD
 
   before :each do

data/lib/rdf/spec/matchers.rb

@@ -113,6 +113,13 @@ module RDF; module Spec
       end
     end
 
+    define :be_a_list do
+      match do |value|
+        value.should be_an(RDF::List)
+        true
+      end
+    end
+
     define :be_a_vocabulary do |base_uri|
       match do |vocabulary|
         vocabulary.should be_a_kind_of(Module)

data/lib/rdf/spec/node.rb

@@ -2,12 +2,10 @@ require 'rdf'
 require 'rdf/spec'
 
 share_as :RDF_Node do
-
   before :each do
     raise '+@new+ must be defined in a before(:each) block' unless instance_variable_get('@new')
   end
 
- 
   it "should be instantiable" do
     lambda { @new.call }.should_not raise_error
   end

data/lib/rdf/spec/query.rb

@@ -0,0 +1,8 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Query do
+  include RDF::Spec::Matchers
+
+  # TODO
+end

data/lib/rdf/spec/readable.rb

@@ -0,0 +1,8 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Readable do
+  include RDF::Spec::Matchers
+
+  # TODO
+end

data/lib/rdf/spec/resource.rb

@@ -0,0 +1,8 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Resource do
+  include RDF::Spec::Matchers
+
+  # TODO
+end

data/lib/rdf/spec/value.rb

@@ -2,7 +2,6 @@ require 'rdf'
 require 'rdf/spec'
 
 share_as :RDF_Value do
-
   before :each do
     raise '+@value+ must be defined in a before(:each) block' unless instance_variable_get('@value')
     raise '+@resource+ must be defined in a before(:each) block' unless instance_variable_get('@resource')

data/lib/rdf/spec/version.rb

@@ -2,7 +2,7 @@ module RDF; module Spec
   module VERSION
     MAJOR = 0
     MINOR = 2
-    TINY  = 2
+    TINY  = 3
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

data/lib/rdf/spec/vocab.rb

@@ -0,0 +1,8 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Vocabulary do
+  include RDF::Spec::Matchers
+
+  # TODO
+end

data/lib/rdf/spec/writable.rb

@@ -0,0 +1,8 @@
+require 'rdf/spec'
+require 'spec'
+
+share_as :RDF_Writable do
+  include RDF::Spec::Matchers
+
+  # TODO
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-07 00:00:00 +02:00
+date: 2010-08-26 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -56,8 +56,8 @@ dependencies:
         segments: 
         - 0
         - 2
-        - 2
-        version: 0.2.2
+        - 3
+        version: 0.2.3
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -94,17 +94,23 @@ files:
 - lib/rdf/spec/enumerable.rb
 - lib/rdf/spec/format.rb
 - lib/rdf/spec/graph.rb
+- lib/rdf/spec/list.rb
 - lib/rdf/spec/literal.rb
 - lib/rdf/spec/matchers.rb
 - lib/rdf/spec/mutable.rb
 - lib/rdf/spec/node.rb
+- lib/rdf/spec/query.rb
 - lib/rdf/spec/queryable.rb
+- lib/rdf/spec/readable.rb
 - lib/rdf/spec/reader.rb
 - lib/rdf/spec/repository.rb
+- lib/rdf/spec/resource.rb
 - lib/rdf/spec/statement.rb
 - lib/rdf/spec/uri.rb
 - lib/rdf/spec/value.rb
 - lib/rdf/spec/version.rb
+- lib/rdf/spec/vocab.rb
+- lib/rdf/spec/writable.rb
 - lib/rdf/spec/writer.rb
 - lib/rdf/spec.rb
 - spec/countable_spec.rb