rdf-spec 0.3.2 → 0.3.4

data/lib/rdf/spec/node.rb

@@ -1,11 +0,0 @@
-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
-end

data/lib/rdf/spec/resource.rb

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

data/lib/rdf/spec/statement.rb

@@ -1,214 +0,0 @@
-require 'rdf/spec'
-
-share_as :RDF_Statement do
-  include RDF::Spec::Matchers
-
-  before :each do
-    raise '+@n3+ must be defined in a before(:each) block' unless instance_variable_get('@n3')
-    raise '+@s+ must be defined in a before(:each) block' unless instance_variable_get('@s')
-    raise '+@p+ must be defined in a before(:each) block' unless instance_variable_get('@p')
-    raise '+@o+ must be defined in a before(:each) block' unless instance_variable_get('@o')
-    raise '+@stmt+ must be defined in a before(:each) block' unless instance_variable_get('@stmt')
-  end
-
-  context "when initializing" do
-    it "should be instantiable with a hash argument" do
-      lambda { RDF::Statement.new(:subject => @s,
-                                  :predicate => @p,
-                                  :object => @o) }.should_not raise_error(ArgumentError)
-
-    end
-
-    it "should not alter a hash argument" do
-      hash = { :subject => @s, :predicate => @p, :object => @o }
-      original_hash = hash.dup
-      stmt = RDF::Statement.new(hash)
-      original_hash.should == hash
-    end
-
-    it "should not alter its options argument" do
-      options = { :context => RDF::DOAP.name }
-      original_options = options.dup
-      stmt = RDF::Statement.new(@s, @p, @o, options)
-      options.should == original_options
-    end
-  end
-
-  context "when created" do
-    it "should not require arguments" do
-      lambda { RDF::Statement.new }.should_not raise_error(ArgumentError)
-    end
-
-    it "should have a subject" do
-      @stmt.has_subject?.should be_true
-      @stmt.subject.should_not be_nil
-    end
-
-    it "should have a predicate" do
-      @stmt.has_predicate?.should be_true
-      @stmt.predicate.should_not be_nil
-    end
-
-    it "should have an object" do
-      @stmt.has_object?.should be_true
-      @stmt.object.should_not be_nil
-    end
-
-    it "should be asserted" do
-      @stmt.asserted?.should be_true
-    end
-
-    it "should not be quoted" do
-      @stmt.quoted?.should be_false
-    end
-
-    it "should be statement" do
-      @stmt.statement?.should be_true
-    end
-  end
-
-  context "when created with a blank node subject" do
-    before :each do
-      @stmt = RDF::Statement.new(RDF::Node.new, @p, @o)
-    end
-
-    it "should have a blank node" do
-      @stmt.has_blank_nodes?.should be_true
-    end
-  end
-
-  context "when created with a blank node object" do
-    before :each do
-      @stmt = RDF::Statement.new(@s, @p, RDF::Node.new)
-    end
-
-    it "should have a blank node" do
-      @stmt.has_blank_nodes?.should be_true
-    end
-  end
-
-  context "when created without a context" do
-    it "should not have a context" do
-      @stmt = RDF::Statement.new(@s, @p, @o, :context => nil)
-      @stmt.context.should be_nil
-      @stmt.has_context?.should be_false
-    end
-  end
-
-  context "when created with a context" do
-    it "should have a context" do
-      @stmt = RDF::Statement.new(@s, @p, @o, :context => @s)
-      @stmt.has_context?.should be_true
-      @stmt.context.should_not be_nil
-    end
-  end
-
-  context "when used like an Array" do
-    it "should respond to #to_a" do
-      @stmt.should respond_to(:to_a)
-    end
-
-    it "should respond to #[]" do
-      @stmt.should respond_to(:[])
-    end
-
-    it "should respond to #[]=" do
-      @stmt.should respond_to(:[]=)
-    end
-
-    it "should support #to_a" do
-      @stmt.to_a.should eql([@stmt.subject, @stmt.predicate, @stmt.object])
-    end
-
-    it "should support #[] for the subject" do
-      @stmt[0].should equal(@stmt.subject)
-    end
-
-    it "should support #[] for the predicate" do
-      @stmt[1].should equal(@stmt.predicate)
-    end
-
-    it "should support #[] for the object" do
-      @stmt[2].should equal(@stmt.object)
-    end
-
-    it "should support #[] for the context" do
-      @stmt[3].should equal(@stmt.context)
-    end
-
-    it "should support #[]= for the subject" do
-      stmt = @stmt.dup
-      stmt[0] = s = RDF::URI("http://example.org/subject")
-      stmt.subject.should == s
-    end
-
-    it "should support #[]= for the predicate" do
-      stmt = @stmt.dup
-      stmt[1] = p = RDF::URI("http://example.org/predicate")
-      stmt.predicate.should == p
-    end
-
-    it "should support #[]= for the object" do
-      stmt = @stmt.dup
-      stmt[2] = o = RDF::URI("http://example.org/object")
-      stmt.object.should == o
-    end
-
-    it "should support #[]= for the context" do
-      stmt = @stmt.dup
-      stmt[3] = c = RDF::URI("http://example.org/context")
-      stmt.context.should == c
-    end
-  end
-
-  context "when used like a Hash" do
-    it "should support #to_hash" do
-      @stmt.should respond_to(:to_hash)
-      @stmt.to_hash.should eql({
-        :subject   => @stmt.subject,
-        :predicate => @stmt.predicate,
-        :object    => @stmt.object,
-        :context   => @stmt.context,
-      })
-    end
-  end
-
-  context "when used like a String" do
-    it "should support #to_s" do
-      @stmt.should respond_to(:to_s)
-    end
-
-    it "should have an N-Triples representation" do
-      @stmt.to_s.should eql(@n3)
-    end
-  end
-
-  context "when comparing equality" do
-    before :each do
-      @c = RDF::URI.parse("http://example.org/context")
-      @other_stmt = RDF::Statement.new(@s, @p, @o, :context => @c)
-    end
-
-    it "should == regardless of context" do
-      @stmt.should == @other_stmt
-    end
-
-    it "should not be eql? with differing contexts" do
-      @stmt.should_not be_eql(@other_stmt)
-    end
-
-    it "should match (===) a statement with a missing component to one with that component" do
-      @stmt.should === @other_stmt
-    end
-
-    it "should not match (===) a statement with a component to one which is missing that component" do
-      @other_stmt.should_not === @stmt
-    end
-
-    it "should only equals? with object equality" do
-      @same_stmt = RDF::Statement.new @s, @p, @o
-      @stmt.should_not equal(@same_stmt)
-      @stmt.should equal(@stmt)
-    end
-  end
-end

data/lib/rdf/spec/term.rb

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

data/lib/rdf/spec/uri.rb

@@ -1,198 +0,0 @@
-require 'rdf/spec'
-
-share_as :RDF_URI 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('http://rdf.rubyforge.org/') }.should_not raise_error
-  end
-
-  it "should recognize URNs" do
-    urns = %w(urn:isbn:0451450523 urn:isan:0000-0000-9E59-0000-O-0000-0000-2 urn:issn:0167-6423 urn:ietf:rfc:2648 urn:mpeg:mpeg7:schema:2001 urn:oid:2.16.840 urn:uuid:6e8bc430-9c3a-11d9-9669-0800200c9a66 urn:uci:I001+SBSi-B10000083052)
-    urns.each do |urn|
-      uri = @new.call(urn)
-      uri.should be_a_uri
-      uri.should respond_to(:urn?)
-      uri.should be_a_urn
-      uri.should_not be_a_url
-    end
-  end
-
-  it "should recognize URLs" do
-    urls = %w(mailto:jhacker@example.org http://example.org/ ftp://example.org/)
-    urls.each do |url|
-      uri = @new.call(url)
-      uri.should be_a_uri
-      uri.should respond_to(:url?)
-      uri.should be_a_url
-      uri.should_not be_a_urn
-    end
-  end
-
-  it "should return the root URI" do
-    uri = @new.call('http://rdf.rubyforge.org/RDF/URI.html')
-    uri.should respond_to(:root)
-    uri.root.should be_a_uri
-    uri.root.should == @new.call('http://rdf.rubyforge.org/')
-  end
-
-  it "should find the parent URI" do
-    uri = @new.call('http://rdf.rubyforge.org/RDF/URI.html')
-    uri.should respond_to(:parent)
-    uri.parent.should be_a_uri
-    uri.parent.should == @new.call('http://rdf.rubyforge.org/RDF/')
-    uri.parent.parent.should == @new.call('http://rdf.rubyforge.org/')
-    uri.parent.parent.parent.should be_nil
-  end
-
-  it "should have a consistent hash code" do
-    hash1 = @new.call('http://rdf.rubyforge.org/').hash
-    hash2 = @new.call('http://rdf.rubyforge.org/').hash
-    hash1.should == hash2
-  end
-
-  it "should be duplicable" do
-    url  = Addressable::URI.parse('http://rdf.rubyforge.org/')
-    uri2 = (uri1 = @new.call(url)).dup
-
-    uri1.should_not be_equal(uri2)
-    uri1.should be_eql(uri2)
-    uri1.should == uri2
-
-    url.path = '/rdf/'
-    uri1.should_not be_equal(uri2)
-    uri1.should_not be_eql(uri2)
-    uri1.should_not == uri2
-  end
-
-  it "should not be #anonymous?" do
-    @new.call('http://example.org').should_not be_anonymous
-  end
-
-  context "using the smart separator (/)" do
-    {
-      # #!! means that I'm not sure I like the semantics, but they are cases for
-      # arguably invalid input, probably without 'correct' answers.
-
-      %w(http://foo a) => "http://foo/a",
-      %w(http://foo /a) => "http://foo/a",
-      %w(http://foo #a) => "http://foo#a",
-
-      %w(http://foo/ a) => "http://foo/a",
-      %w(http://foo/ /a) => "http://foo/a",
-      %w(http://foo/ #a) => "http://foo#a", #!!
-
-      %w(http://foo# a) => "http://foo#a",
-      %w(http://foo# /a) => "http://foo/a", #!!
-      %w(http://foo# #a) => "http://foo#a",
-
-      %w(http://foo/bar a) => "http://foo/bar/a",
-      %w(http://foo/bar /a) => "http://foo/bar/a",
-      %w(http://foo/bar #a) => "http://foo/bar#a",
-
-      %w(http://foo/bar/ a) => "http://foo/bar/a",
-      %w(http://foo/bar/ /a) => "http://foo/bar/a",
-      %w(http://foo/bar/ #a) => "http://foo/bar#a", #!!
-
-      %w(http://foo/bar# a) => "http://foo/bar#a",
-      %w(http://foo/bar# /a) => "http://foo/bar/a", #!!
-      %w(http://foo/bar# #a) => "http://foo/bar#a",
-
-      %w(urn:isbn: 0451450523) => "urn:isbn:0451450523",
-      %w(urn:isbn: :0451450523) => "urn:isbn:0451450523",
-
-      %w(urn:isbn 0451450523) => "urn:isbn:0451450523",
-      %w(urn:isbn :0451450523) => "urn:isbn:0451450523",
-    }.each_pair do |input, result|
-      it "should create <#{result}> from <#{input[0]}> and '#{input[1]}'" do
-        (RDF::URI.new(input[0]) / input[1]).to_s.should == result
-        (RDF::URI.new(input[0]) / RDF::URI.new(input[1])).to_s.should == result
-      end
-    end
-
-    it "should raise an ArgumentError when receiving an absolute URI as a fragment" do
-      lambda { RDF::URI.new('http://example.org') / RDF::URI.new('http://example.com') }.should raise_error ArgumentError
-    end
-  end
-
-  context "using concatenation (#+)" do
-    {
-      %w(http://foo/ a) => "http://foo/a",
-      %w(http://foo/ /a) => "http://foo//a",
-      %w(http://foo/ #a) => "http://foo/#a",
-
-      %w(urn:isbn :0451450523) => "urn:isbn:0451450523",
-      %w(urn:isbn 0451450523) => "urn:isbn0451450523",
-
-      %w(http://example.org/test test) => "http://example.org/testtest",
-    }.each_pair do |input, result|
-      it "should create <#{result}> from <#{input[0]}> and '#{input[1]}'" do
-        (RDF::URI.new(input[0]) + input[1]).to_s.should == result
-        (RDF::URI.new(input[0]) + RDF::URI.new(input[1])).to_s.should == result
-      end
-    end
-  end
-
-  context "using normalized merging (#join)" do
-
-    before :all do
-      @writer = RDF::Writer.for(:ntriples)
-    end
-
-    before :each do
-      @subject = RDF::URI.new("http://example.org")
-    end
-
-    it "appends fragment to uri" do
-      @subject.join("foo").to_s.should == "http://example.org/foo"
-    end
-
-    it "appends another fragment" do
-      @subject.join("foo#bar").to_s.should == "http://example.org/foo#bar"
-    end
-
-    it "appends another URI" do
-      @subject.join(RDF::URI.new("foo#bar")).to_s.should == "http://example.org/foo#bar"
-    end
-
-    {
-      %w(http://foo ) =>  "<http://foo>",
-      %w(http://foo a) => "<http://foo/a>",
-      %w(http://foo /a) => "<http://foo/a>",
-      %w(http://foo #a) => "<http://foo#a>",
-
-      %w(http://foo/ ) =>  "<http://foo/>",
-      %w(http://foo/ a) => "<http://foo/a>",
-      %w(http://foo/ /a) => "<http://foo/a>",
-      %w(http://foo/ #a) => "<http://foo/#a>",
-
-      %w(http://foo# ) =>  "<http://foo#>",
-      %w(http://foo# a) => "<http://foo/a>",
-      %w(http://foo# /a) => "<http://foo/a>",
-      %w(http://foo# #a) => "<http://foo#a>",
-
-      %w(http://foo/bar ) =>  "<http://foo/bar>",
-      %w(http://foo/bar a) => "<http://foo/a>",
-      %w(http://foo/bar /a) => "<http://foo/a>",
-      %w(http://foo/bar #a) => "<http://foo/bar#a>",
-
-      %w(http://foo/bar/ ) =>  "<http://foo/bar/>",
-      %w(http://foo/bar/ a) => "<http://foo/bar/a>",
-      %w(http://foo/bar/ /a) => "<http://foo/a>",
-      %w(http://foo/bar/ #a) => "<http://foo/bar/#a>",
-
-      %w(http://foo/bar# ) =>  "<http://foo/bar#>",
-      %w(http://foo/bar# a) => "<http://foo/a>",
-      %w(http://foo/bar# /a) => "<http://foo/a>",
-      %w(http://foo/bar# #a) => "<http://foo/bar#a>",
-
-    }.each_pair do |input, result|
-      it "creates #{result} from <#{input[0]}> and '#{input[1]}'" do
-        @writer.serialize(RDF::URI.new(input[0]).join(input[1].to_s)).should == result
-      end
-    end
-  end
-
-end

data/lib/rdf/spec/value.rb

@@ -1,28 +0,0 @@
-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')
-  end
-
-  describe RDF::Value do
-    it "should not be instantiable" do
-      lambda { @value.call }.should raise_error(NoMethodError)
-    end
-  end
-
-  describe RDF::Resource do
-    it "should instantiate blank nodes" do
-      resource = @resource.call('_:foobar')
-      resource.class.should == RDF::Node
-      resource.id.should == 'foobar'
-    end
-
-    it "should instantiate URIs" do
-      resource = @resource.call('http://rdf.rubyforge.org/')
-      resource.class.should == RDF::URI
-      resource.to_s.should == 'http://rdf.rubyforge.org/'
-    end
-  end
-end