rdf-spec 0.1.8 → 0.1.9

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

data/lib/rdf/spec/queryable.rb

@@ -6,7 +6,7 @@ share_as :RDF_Queryable do
 
   before :each do
     # RDF::Queryable cares about the contents of this file too much to let someone set it
-    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @filename = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
     raise '+@queryable+ must be defined in a before(:each) block' unless instance_variable_get('@queryable')
     raise '+@subject+ must be defined in a before(:each) block' unless instance_variable_get('@subject')
     if @queryable.empty?
@@ -18,6 +18,9 @@ share_as :RDF_Queryable do
     end
   end
 
+  ##
+  # @see RDF::Queryable#query
+
   it "should support #query" do
     @queryable.respond_to?(:query).should be_true
   end
@@ -71,10 +74,233 @@ share_as :RDF_Queryable do
     end
 
     it "should not alter a given hash argument" do
-      query = { :subject => @subject, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person }
+      query = {:subject => @subject, :predicate => RDF::DOAP.name, :object => RDF::FOAF.Person}
       original_query = query.dup
       result = @queryable.query(query)
       query.should == original_query
     end
   end
+
+  ##
+  # @see RDF::Queryable#first
+
+  it "should support #first" do
+    @queryable.respond_to?(:first).should be_true
+  end
+
+  context "#first" do
+    before :all do
+      @failing_pattern = [RDF::Node.new] * 3
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first }.should_not raise_error(ArgumentError)
+      @queryable.first.should == @queryable.each.first # uses an Enumerator
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = [[nil, nil, nil], @queryable.each.first]
+      matching_patterns.each do |matching_pattern|
+        @queryable.first(matching_pattern).should == @queryable.query(matching_pattern).each.first
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first.should be_nil
+      queryable.first(@failing_pattern).should be_nil
+    end
+  end
+
+  ##
+  # @see RDF::Queryable#first_subject
+
+  it "should support #first_subject" do
+    @queryable.respond_to?(:first_subject).should be_true
+  end
+
+  context "#first_subject" do
+    before :all do
+      @failing_pattern = [RDF::Node.new, nil, nil]
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first_subject }.should_not raise_error(ArgumentError)
+      @queryable.first_subject.should == @queryable.first.subject
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = [[nil, nil, nil], [@queryable.first.subject, nil, nil]]
+      matching_patterns.each do |matching_pattern|
+        @queryable.first_subject(matching_pattern).should == @queryable.query(matching_pattern).first.subject
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first_subject(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first_subject.should be_nil
+      queryable.first_subject(@failing_pattern).should be_nil
+    end
+  end
+
+  ##
+  # @see RDF::Queryable#first_predicate
+
+  it "should support #first_predicate" do
+    @queryable.respond_to?(:first_predicate).should be_true
+  end
+
+  context "#first_predicate" do
+    before :all do
+      @failing_pattern = [nil, RDF::Node.new, nil]
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first_predicate }.should_not raise_error(ArgumentError)
+      @queryable.first_predicate.should == @queryable.first.predicate
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = [[nil, nil, nil], [nil, @queryable.first.predicate, nil]]
+      matching_patterns.each do |matching_pattern|
+        @queryable.first_predicate(matching_pattern).should == @queryable.query(matching_pattern).first.predicate
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first_predicate(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first_predicate.should be_nil
+      queryable.first_predicate(@failing_pattern).should be_nil
+    end
+  end
+
+  ##
+  # @see RDF::Queryable#first_object
+
+  it "should support #first_object" do
+    @queryable.respond_to?(:first_object).should be_true
+  end
+
+  context "#first_object" do
+    before :all do
+      @failing_pattern = [nil, nil, RDF::Node.new]
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first_object }.should_not raise_error(ArgumentError)
+      @queryable.first_object.should == @queryable.first.object
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = [[nil, nil, nil], [nil, nil, @queryable.first.object]]
+      matching_patterns.each do |matching_pattern|
+        @queryable.first_object(matching_pattern).should == @queryable.query(matching_pattern).first.object
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first_object(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first_object.should be_nil
+      queryable.first_object(@failing_pattern).should be_nil
+    end
+  end
+
+  ##
+  # @see RDF::Queryable#first_literal
+
+  it "should support #first_literal" do
+    @queryable.respond_to?(:first_literal).should be_true
+  end
+
+  context "#first_literal" do
+    before :each do
+      # FIXME: these tests should be using the provided @queryable, if possible.
+      @queryable = RDF::Graph.new do |graph|
+        @subject = RDF::Node.new
+        graph << [subject, RDF.type, RDF::DOAP.Project]
+        graph << [subject, RDF::DC.creator, RDF::URI.new('http://example.org/#jhacker')]
+        graph << [subject, RDF::DC.creator, @literal = RDF::Literal.new('J. Random Hacker')]
+      end
+      @failing_pattern = [nil, nil, RDF::Node.new]
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first_literal }.should_not raise_error(ArgumentError)
+      @queryable.first_literal.should == @literal
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = [[nil, nil, nil], [@subject, nil, nil], [nil, RDF::DC.creator, nil], [nil, nil, @literal]]
+      matching_patterns.each do |matching_pattern|
+        @queryable.first_literal(matching_pattern).should == @literal
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first_literal(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first_literal.should be_nil
+      queryable.first_literal(@failing_pattern).should be_nil
+    end
+  end
+
+  ##
+  # @see RDF::Queryable#first_value
+
+  it "should support #first_value" do
+    @queryable.respond_to?(:first_value).should be_true
+  end
+
+  context "#first_value" do
+    before :all do
+      @failing_pattern = [nil, nil, RDF::Node.new]
+    end
+
+    it "should be callable without a pattern" do
+      lambda { @queryable.first_value }.should_not raise_error(ArgumentError)
+      @queryable.first_value.should == @queryable.first_literal.value
+    end
+
+    it "should return the correct value when the pattern matches" do
+      matching_patterns = []
+      @queryable.each do |statement|
+        if statement.object.is_a?(RDF::Literal)
+          matching_pattern = [statement.subject, statement.predicate, nil]
+          unless matching_patterns.include?(matching_pattern)
+            matching_patterns << matching_pattern
+            @queryable.first_value(matching_pattern).should == @queryable.first_literal(matching_pattern).value
+          end
+        end
+      end
+    end
+
+    it "should return nil when the pattern fails to match anything" do
+      @queryable.first_value(@failing_pattern).should be_nil
+    end
+
+    it "should return nil when self is empty" do
+      queryable = [].extend(RDF::Queryable)
+      queryable.first_value.should be_nil
+      queryable.first_value(@failing_pattern).should be_nil
+    end
+  end
 end

data/lib/rdf/spec/version.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-18 00:00:00 +02:00
+date: 2010-04-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency