rdf-rdfxml 0.3.2.1 → 0.3.3

data/spec/matchers.rb

@@ -1,61 +1,79 @@
-module Matchers
-  class BeEquivalentGraph
-    Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
-    def normalize(graph)
-      case graph
-      when RDF::Graph then graph
-      when IO, StringIO
-        RDF::Graph.new.load(graph, :base_uri => @info.about)
-      else
-        # Figure out which parser to use
-        g = RDF::Graph.new
-        reader_class = detect_format(graph)
-        reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
-        g
-      end
-    end
-    
-    def initialize(expected, info)
-      @info = if info.respond_to?(:about)
-        info
-      elsif info.is_a?(Hash)
-        identifier = info[:identifier] || expected.is_a?(RDF::Graph) ? expected.context : info[:about]
-        trace = info[:trace]
-        trace = trace.join("\n") if trace.is_a?(Array)
-        Info.new(identifier, info[:information] || "", trace, info[:compare])
-      else
-        Info.new(expected.is_a?(RDF::Graph) ? expected.context : info, info.to_s)
-      end
-      @expected = normalize(expected)
-    end
+require 'rspec/matchers'
 
-    def matches?(actual)
-      @actual = normalize(actual)
-      @actual == @expected
+RSpec::Matchers.define :have_xpath do |xpath, value, namespaces = {}|
+  match do |actual|
+    @doc = Nokogiri::XML.parse(actual)
+    @doc.should be_a(Nokogiri::XML::Document)
+    @doc.root.should be_a(Nokogiri::XML::Element)
+    @namespaces = @doc.namespaces.
+      merge(namespaces).
+      merge("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
+    @result = @doc.root.at_xpath(xpath, @namespaces) rescue false
+    case value
+    when false
+      @result.should be_nil
+    when Array
+      @result.to_s.split(" ").should include(*value)
+    when Regexp
+      @result.to_s.should =~ value
+    else
+      @result.to_s.should == value
     end
+  end
+  
+  failure_message_for_should do |actual|
+    msg = "expected to that #{xpath.inspect} would be #{value.inspect} in:\n" + actual.to_s
+    msg += "was: #{@result}"
+  end
+end
 
-    def failure_message_for_should
-      info = @info.respond_to?(:information) ? @info.information : @info.inspect
-      if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
-        "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
-      elsif @expected.is_a?(Array) && @actual.size != @expected.length
-        "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
-      else
-        "Graph differs"
-      end +
-      "\n#{info + "\n" unless info.empty?}" +
-      (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
-      (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
-      "Unsorted Expected:\n#{@expected.to_ntriples}" +
-      "Unsorted Results:\n#{@actual.to_ntriples}" +
-      (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
-    end
-    def negative_failure_message
-      "Graphs do not differ\n"
+def normalize(graph)
+  case graph
+  when RDF::Graph then graph
+  when IO, StringIO
+    RDF::Graph.new.load(graph, :base_uri => @info.about)
+  else
+    # Figure out which parser to use
+    g = RDF::Graph.new
+    reader_class = RDF::Reader.for(detect_format(graph))
+    reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
+    g
+  end
+end
+
+Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
+
+RSpec::Matchers.define :be_equivalent_graph do |expected, info|
+  match do |actual|
+    @info = if info.respond_to?(:about)
+      info
+    elsif info.is_a?(Hash)
+      identifier = info[:identifier] || expected.is_a?(RDF::Graph) ? expected.context : info[:about]
+      trace = info[:trace]
+      trace = trace.join("\n") if trace.is_a?(Array)
+      Info.new(identifier, info[:information] || "", trace, info[:compare])
+    else
+      Info.new(expected.is_a?(RDF::Graph) ? expected.context : info, info.to_s)
     end
+    @expected = normalize(expected)
+    @actual = normalize(actual)
+    @actual.isomorphic_with?(@expected)
   end
   
-  def be_equivalent_graph(expected, info = nil)
-    BeEquivalentGraph.new(expected, info)
-  end
+  failure_message_for_should do |actual|
+    info = @info.respond_to?(:information) ? @info.information : @info.inspect
+    if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
+      "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+    elsif @expected.is_a?(Array) && @actual.size != @expected.length
+      "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+    else
+      "Graph differs"
+    end +
+    "\n#{info + "\n" unless info.empty?}" +
+    (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+    (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
+    "Unsorted Expected:\n#{@expected.dump(:ntriples)}" +
+    "Unsorted Results:\n#{@actual.dump(:ntriples)}" +
+    (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
+  end  
 end

data/spec/rdf_test.rb

@@ -46,29 +46,8 @@ module Fixtures
         ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
         "]"
       end
-
-      # Run test case, yields input for parser to create triples
-      def run_test(options = {})
-        # Run
-        graph = yield
-        
-        return unless self.outputDocument
-
-        case self.compare
-        when :none
-          # Don't check output, just parse to graph
-        when :array
-          @parser.graph.should be_equivalent_graph(self.output, self)
-        else
-          #puts "parse #{self.outputDocument} as #{RDF::Reader.for(self.outputDocument)}"
-          format = detect_format(self.output)
-          output_graph = RDF::Graph.load(self.outputDocument, :format => format, :base_uri => self.inputDocument)
-          puts "result: #{CGI.escapeHTML(graph.to_ntriples)}" if ::RDF::N3::debug?
-          graph.should Matchers::be_equivalent_graph(output_graph, self)
-        end
-      end
     end
-    
+
     class PositiveParserTest < Entry
       default_source :entries
       type Test.PositiveParserTest

data/spec/reader_spec.rb

@@ -144,7 +144,7 @@ EOF
       graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
       #puts @debug
       graph.size.should == 10
-      # print graph.to_ntriples
+      # print graph.dump(:ntriples
       # TODO: add datatype parsing
       # TODO: make sure the BNode forging is done correctly - an internal element->nodeID mapping
       # TODO: proper test
@@ -309,17 +309,17 @@ EOF
         #puts t.inspect
         specify "#{t.name}: " + (t.description || "#{t.inputDocument} against #{t.outputDocument}") do
           begin
-            t.run_test do
-              t.debug = []
-              g = RDF::Graph.new
-              @reader.new(t.input,
-                  :base_uri => t.inputDocument,
-                  :validate => false,
-                  :debug => t.debug).each do |statement|
-                g << statement
-              end
-              g
-            end
+            graph = RDF::Graph.new << @reader.new(t.input,
+              :base_uri => t.inputDocument,
+              :validate => false,
+              :debug => t.debug)
+
+            # Parse result graph
+            #puts "parse #{self.outputDocument} as #{RDF::Reader.for(self.outputDocument)}"
+            format = detect_format(t.output)
+            output_graph = RDF::Graph.load(t.outputDocument, :format => format, :base_uri => t.inputDocument)
+            puts "result: #{CGI.escapeHTML(graph.dump(:ntriples))}" if ::RDF::N3::debug?
+            graph.should be_equivalent_graph(output_graph, t)
           rescue RSpec::Expectations::ExpectationNotMetError => e
             if t.inputDocument =~ %r(xml-literal|xml-canon)
               pending("XMLLiteral canonicalization not implemented yet")
@@ -339,17 +339,11 @@ EOF
         #next unless t.name =~ /1/
         #puts t.inspect
         specify "test #{t.name}: " + (t.description || t.inputDocument) do
-          t.run_test do
-            lambda do
-              g = RDF::Graph.new
-              @reader.new(t.input,
-                  :base_uri => t.inputDocument,
-                  :validate => true).each do |statement|
-                g << statement
-              end
-              g.should be_empty
-            end.should raise_error(RDF::ReaderError)
-          end
+          lambda do
+            RDF::Graph.new << @reader.new(t.input,
+              :base_uri => t.inputDocument,
+              :validate => true)
+          end.should raise_error(RDF::ReaderError)
         end
       end
     end

data/spec/spec_helper.rb

@@ -5,16 +5,14 @@ $:.unshift File.dirname(__FILE__)
 require 'rubygems'
 require 'rspec'
 require 'matchers'
-require 'bigdecimal'  # XXX Remove Me
 require 'rdf/rdfxml'
 require 'rdf/ntriples'
 require 'rdf/spec'
 require 'rdf/spec/matchers'
 require 'rdf/isomorphic'
+require 'yaml'    # XXX should be in open-uri/cached
 require 'open-uri/cached'
 
-include Matchers
-
 # Create and maintain a cache of downloaded URIs
 URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
 Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
@@ -24,15 +22,6 @@ module RDF
   module Isomorphic
     alias_method :==, :isomorphic_with?
   end
-  class Graph
-    def to_ntriples
-      RDF::Writer.for(:ntriples).buffer do |writer|
-        self.each_statement do |statement|
-          writer << statement
-        end
-      end
-    end
-  end
 end
 
 ::RSpec.configure do |c|
@@ -41,7 +30,6 @@ end
   c.exclusion_filter = {
     :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
   }
-  c.include(Matchers)
   c.include(RDF::Spec::Matchers)
 end
 
@@ -56,10 +44,10 @@ def detect_format(stream)
     string = stream.to_s
   end
   case string
-  when /<\w+:RDF/ then RDF::RDFXML::Reader
-  when /<RDF/     then RDF::RDFXML::Reader
-  #when /<html/i   then RDF::RDFa::Reader
-  when /@prefix/i then RDF::N3::Reader
-  else                 RDF::NTriples::Reader
+  when /<\w+:RDF/ then :rdf
+  when /<RDF/     then :rdf
+  #when /<html/i   then :rdfa
+  when /@prefix/i then :n3
+  else                 :ntriples
   end
 end