rdf-rdfa 0.3.1.2 → 0.3.3

data/script/intern_vocabulary

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+#
+# Generate a Ruby version of an RDFa vocabulary to be directly accessible from RDF::RDFa::Profile
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+require 'linkeddata'
+require 'getoptlong'
+require 'open-uri'
+
+def help
+  puts "Usage: #{$0} [options] file-or-uri ..."
+  puts "Options:"
+  puts "      --dump:               Dump raw output, otherwise serialize to Ruby"
+  puts "      --debug:              Display detailed debug output"
+  puts "      --verbose:            Verbose processing"
+  puts "      --output:             Write to file"
+  puts "      --help,-?:            This message"
+  exit(0)
+end
+
+dump = false
+output = STDOUT
+
+opts = GetoptLong.new(
+  ["--debug", GetoptLong::NO_ARGUMENT],
+  ["--dump", GetoptLong::NO_ARGUMENT],
+  ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
+  ["--verbose", GetoptLong::NO_ARGUMENT],
+  ["--help", "-?", GetoptLong::NO_ARGUMENT]
+)
+opts.each do |opt, arg|
+  case opt
+  when '--verbose'  then $verbose = true
+  when '--debug'    then ::RDF::RDFa::debug = true
+  when '--dump'     then dump = true
+  when '--output'   then output = File.open(arg, "w")
+  when '--help'     then help
+  end
+end
+
+help if ARGV.empty?
+
+ARGV.each do |file|
+  uri = RDF::URI(file)
+  if RDF::RDFa::Profile.cache[uri]
+    STDERR.puts "Remove cached entry for #{uri} before attempting to parse"
+    exit(1)
+  end
+  
+  profile = RDF::RDFa::Profile.find(uri)
+  if dump
+    puts profile.inspect
+  else
+    output.puts  <<START
+# This file is automatically generated by #{__FILE__}
+# RDFa vocabulary for #{file}
+
+profile = RDF::RDFa::Profile.new(RDF::URI("#{file}"), {
+START
+
+    output.puts %{  :vocabulary => "#{profile.vocabulary},"} if profile.vocabulary
+    
+    [:prefixes, :terms].each do |t|
+      hash = profile.send(t)
+      key_width = hash.keys.inject(0) {|width, k| k.inspect.length > width ? k.inspect.length : width}
+      unless hash.empty?
+        output.puts %(  :#{t} => {)
+          hash.keys.map(&:to_s).sort.each do |k|
+            v = hash[k.to_sym]
+            output.printf(%(    %*s => %s,\n), -key_width, k.to_sym.inspect, v.inspect)
+          end
+        output.puts %(  },)
+      end
+    end
+    
+    output.puts <<END
+})
+
+RDF::RDFa::Profile.cache[RDF::URI("#{file}")] = profile
+END
+
+  end
+end

data/script/parse

@@ -2,55 +2,90 @@
 require 'rubygems'
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'rdf/rdfa'
-require 'rdf/rdfxml' rescue nil
 require 'rdf/n3' rescue nil
+require 'rdf/rdfxml' rescue nil
 require 'getoptlong'
 require 'open-uri'
 
-def parse(input, base)
-  reader_class = RDF::Reader.for($input_format.to_sym)
-  writer_class = RDF::Writer.for($output_format.to_sym)
+def run(input, options)
+  reader_class = RDF::Reader.for(options[:input_format].to_sym)
   raise "Reader not found for #{$input_format}" unless reader_class
-  raise "Writer not found for #{$output_format}" unless writer_class
-  puts writer_class.buffer { |writer|
-    reader_class.new(input, :base_uri => base, :validate => true).each do |statement|
-      writer << statement
+
+  start = Time.new
+  num = 0
+
+  if options[:output_format] == :ntriples || options[:quiet]
+    reader_class.new(input, :base_uri => options[:base_uri], :strict => true).each do |statement|
+      num += 1
+      if options[:quiet]
+        #print "."
+      else
+        options[:output].puts statement.to_ntriples
+      end
+    end
+  elsif options[:output_format] == :inspect
+    reader_class.new(input, :base_uri => options[:base_uri], :strict => true).each do |statement|
+      num += 1
+      options[:output].puts statement.inspect
     end
-  }
+  else
+    r = reader_class.new(input, options)
+    g = RDF::Graph.new << r
+    num = g.count
+    options[:output].puts g.dump(options[:output_format], options.merge(:prefixes => r.prefixes))
+  end
+  STDERR.puts
+  secs = Time.new - start
+  STDERR.puts "Parsed #{num} statements in #{secs} seconds @ #{num/secs} statements/second."
+rescue
+  fname = input.respond_to?(:path) ? input.path : "-stdin-"
+  STDERR.puts("Error in #{fname}")
+  raise
 end
 
-$verbose = false
-$output_format = :ntriples
-$input_format = :rdfa
-base_uri  = "http://example.com"
+options = {
+  :verbose => false,
+  :validate => false,
+  :strict => true,
+  :output => STDOUT,
+  :output_format => :ntriples,
+  :input_format => :rdfa,
+  :base_uri => "http://example.com",
+}
 input = nil
 
 opts = GetoptLong.new(
   ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--quiet", GetoptLong::NO_ARGUMENT],
+  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
   ["--format", GetoptLong::REQUIRED_ARGUMENT],
   ["--input-format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
-  ["--uri", GetoptLong::REQUIRED_ARGUMENT]
+  ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
+  ["--quiet", GetoptLong::NO_ARGUMENT],
+  ["--template", GetoptLong::REQUIRED_ARGUMENT],
+  ["--uri", GetoptLong::REQUIRED_ARGUMENT],
+  ["--validate", GetoptLong::NO_ARGUMENT],
+  ["--verbose", GetoptLong::NO_ARGUMENT]
 )
 opts.each do |opt, arg|
   case opt
-  when '--verbose' then $verbose = true
-  when '--quiet' then $quiet = true
-  when '--debug' then ::RDF::RDFa::debug = true
-  when '--execute' then input = arg
-  when '--format' then $output_format = arg
-  when '--input-format' then $input_format = arg
-  when '--uri' then base_uri = arg
+  when '--debug'        then ::RDF::RDFa::debug = true
+  when '--execute'      then input = arg
+  when '--format'       then options[:output_format] = arg.to_sym
+  when '--input-format' then options[:input_format] = arg.to_sym
+  when '--quiet'        then options[:quiet] = true
+  when '--output'       then options[:output] = File.open(arg, "w")
+  when '--template'     then options[:haml] = arg.to_sym
+  when '--uri'          then options[:base_uri] = arg
+  when '--verbose'      then options[:verbose] = true
+  when '--validate'     then options[:validate] = true
   end
 end
 
 if ARGV.empty?
   s = input ? input : $stdin.read
-  parse(StringIO.new(s), base_uri)
+  run(StringIO.new(s), options)
 else
   ARGV.each do |test_file|
-    parse(Kernel.open(test_file), base_uri)
+    run(Kernel.open(test_file), options)
   end
-end
+end

data/script/tc

@@ -1,65 +1,115 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
-require 'rdf/n3'
-require 'rdf/rdfxml'
 require 'rdf/rdfa'
-require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'rdfa_helper'))
+require 'sparql/grammar'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'test_helper'))
 require 'getoptlong'
 
-def run_tc(tc)
-  puts "run #{tc.name}"
-  puts tc.input if $verbose
-  pg = RDF::Graph.new if $pg_format
-  RDF::Writer.for($output_format.to_sym).new do |writer|
-    RDF::RDFa::Reader.new(tc.input,
-      :base_uri => tc.informationResourceInput,
-      :validate => $validate,
+def run_tc(tc, options)
+  input_uri = tc.input(options[:host_language], options[:version])
+  results_uri = tc.results(options[:host_language], options[:version])
+
+  STDOUT.write "run #{tc.name}"
+
+  if options[:verbose]
+    puts("\nTestCase: #{tc.inspect}") 
+    puts("\nInput:\n" + Kernel.open(input_uri) {|f| f.read}) 
+    puts("\nQuery:\n" + Kernel.open(results_uri) {|f| f.read})
+  end
+
+  pg = RDF::Graph.new if options[:processor_graph]
+
+  begin
+    reader = RDF::RDFa::Reader.new(Kernel.open(input_uri),
+      :base_uri => input_uri,
+      :validate => options[:validate],
       :processor_graph => pg,
-      :version => tc.version).each do |statement|
-      writer << statement
+      :version => options[:version])
+
+    graph = RDF::Graph.new << reader
+  rescue Exception => e
+    puts "#{"exception:" unless options[:quiet]}: #{e}"
+    if options[:quiet]
+      return
+    else
+      raise
     end
   end
-  puts ""
   
-  if pg
+  puts("\nResult:\n" + graph.dump(options[:format])) unless options[:quiet]
+  
+  begin
+    result = SPARQL::Grammar.parse(Kernel.open(results_uri)).execute(graph)
+  rescue Exception => e
+    puts "#{"exception:" unless options[:quiet]}: #{e}"
+    return
+  end
+  puts "#{"test result:" unless options[:quiet]} #{(result == (tc.expectedResults || true)) ? 'ok' : 'fail'}"
+  
+  if pg && !options[:quiet]
     puts "\nProcessor Graph:\n"
     puts pg.inspect
-    RDF::Writer.for($pg_format.to_sym).new do |writer|
+    RDF::Writer.for(options[:format]).new do |writer|
       writer << pg
     end
   end
 end
 
-$verbose = false
-$output_format = :ntriples
-$pg_format = nil
-$validate = false
-suite = "xhtml"
+options = {
+  :verbose         => false,
+  :quite           => false,
+  :validate        => false,
+  :format          => :ntriples,
+  :processor_graph => nil,
+  :host_language   => "xhtml1",
+  :version         => "rdfa1.1"
+}
+
 opts = GetoptLong.new(
-  ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
+  ["--help", "-?", GetoptLong::NO_ARGUMENT],
+  ["--dbg", GetoptLong::NO_ARGUMENT],
+  ["--format", GetoptLong::REQUIRED_ARGUMENT],
+  ["--host-language", "-h", GetoptLong::OPTIONAL_ARGUMENT],
+  ["--processor-graph", GetoptLong::NO_ARGUMENT],
   ["--quiet", GetoptLong::NO_ARGUMENT],
-  ["--suite", GetoptLong::OPTIONAL_ARGUMENT],
   ["--validate", GetoptLong::NO_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--pg-format", GetoptLong::REQUIRED_ARGUMENT]
+  ["--verbose", GetoptLong::NO_ARGUMENT],
+  ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT],
 )
+
+def help(options)
+  puts "Usage: #{$0} [options] [test-number ...]"
+  puts "Options:"
+  puts "      --dump:               Dump raw output, otherwise serialize to Ruby"
+  puts "      --debug:              Display detailed debug output"
+  puts "      --format:             Format for output, defaults to #{options[:format].inspect}"
+  puts "      --host-language:      Run for specified host language, defaults to #{options[:host_language]}"
+  puts "      --processor-graph:    Output processor graph"
+  puts "      --quiet:              Minimal output"
+  puts "      --validate:           Validate input"
+  puts "      --verbose:            Verbose processing"
+  puts "      --version:            Version of processor to use (rdf1.0, rdf1.1). Defaults to #{options[:version]}"
+  puts "      --help,-?:            This message"
+  exit(0)
+end
+
 opts.each do |opt, arg|
   case opt
-  when '--verbose' then $verbose = true
-  when '--quiet' then $quiet = true
-  when '--debug' then ::RDF::RDFa::debug = true
-  when '--format' then $output_format = arg
-  when '--pg-format' then $pg_format = arg
-  when '--suite' then suite = arg
-  when '--validate' then $validate = true
+  when '--help'             then help(options)
+  when '--verbose'          then options[:verbose] = true
+  when '--quiet'            then options[:quiet] = true
+  when '--dbg'              then ::RDF::RDFa::debug = true
+  when '--format'           then options[:format] = arg.to_sym
+  when '--processor-graph'  then options[:processor_graph] = true
+  when '--host-language'    then options[:host_language] = arg
+  when '--version'          then options[:version] = arg
+  when '--validate'         then options[:validate] = true
   end
 end
 
-test_cases = RdfaHelper::TestCase.test_cases(suite)
-
-test_cases.each do |tc|
+Fixtures::TestCase.for_specific(options[:host_language], options[:version]) do |tc|
   next unless ARGV.empty? || ARGV.any? {|n| tc.name.match(/#{n}/)}
-  run_tc(tc)
+  run_tc(tc, options)
 end

data/spec/.gitignore

@@ -0,0 +1 @@
+/uri-cache/

data/spec/matchers.rb

@@ -1,171 +1,106 @@
-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
-
-    def matches?(actual)
-      @actual = normalize(actual)
-      @actual == @expected
-    end
+require 'rspec/matchers'
+require 'sparql/grammar'
 
-    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"
+RSpec::Matchers.define :have_xpath do |xpath, value|
+  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("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
+    case value
+    when false
+      @doc.root.at_xpath(xpath, @namespaces).should be_nil
+    when true
+      @doc.root.at_xpath(xpath, @namespaces).should_not be_nil
+    when Array
+      @doc.root.at_xpath(xpath, @namespaces).to_s.split(" ").should include(*value)
+    when Regexp
+      @doc.root.at_xpath(xpath, @namespaces).to_s.should =~ value
+    else
+      @doc.root.at_xpath(xpath, @namespaces).to_s.should == value
     end
   end
   
-  def be_equivalent_graph(expected, info = nil)
-    BeEquivalentGraph.new(expected, info)
+  failure_message_for_should do |actual|
+    msg = "expected that #{xpath.inspect} would be #{value.inspect} in:\n" + actual.to_s
+    msg += "was: #{@doc.root.at_xpath(xpath, @namespaces)}"
   end
+end
 
-  # Run expected SPARQL query against actual
-  if $redland_enabled
-    class PassQuery
-      def initialize(expected, info)
-        @expected = expected
-        @query = Redland::Query.new(expected)
-        @info = info
-        #puts "PassQuery: expected #{expected.inspect}"
-      end
-      def matches?(actual)
-        @actual = actual
-        @expected_results = @info.respond_to?(:expectedResults) ? @info.expectedResults : true
-        model = Redland::Model.new
-        ntriples_parser = Redland::Parser.ntriples
-        ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
-
-        @results = @query.execute(model)
-        #puts "Redland query results: #{@results.inspect}"
-        if @expected_results && @results
-          @results.is_boolean? && @results.get_boolean?
-        else
-          @results.nil? || @results.is_boolean? && !@results.get_boolean?
-        end
-      end
-      def failure_message_for_should
-        info = @info.respond_to?(:information) ? @info.information : ""
-        "#{info + "\n" unless info.empty?}" +
-        if @results.nil?
-          "Query failed to return results"
-        elsif !@results.is_boolean?
-          "Query returned non-boolean results"
-        elsif @expected_results
-          "Query returned false"
-        else
-          "Query returned true (expected false)"
-        end +
-        "\n#{@expected}" +
-        "\n#{@info.input}" +
-        "\nResults:\n#{@actual.to_ntriples}" +
-        "\nDebug:\n#{@info.trace}"
-      end
-    end
-
-    def pass_query(expected, info = "")
-      PassQuery.new(expected, info)
-    end
+def normalize(graph)
+  case graph
+  when RDF::Graph then graph
+  when IO, StringIO
+    RDF::Graph.new.load(graph, :base_uri => @info.about)
   else
-    def pass_query(expect, info = ""); false; end
+    # 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
 
-  class BeValidXML
-    def initialize(info)
-      @info = info
-    end
-    def matches?(actual)
-      @actual = actual
-      @doc = Nokogiri::XML.parse(actual)
-      @results = @doc.validate
-      @results.nil?
-    rescue
-      false
-    end
-    def failure_message_for_should
-      "#{@info + "\n" unless @info.empty?}" +
-      if @doc.nil?
-        "did not parse"
-      else
-        "\n#{@results}" +
-        "\nParsed:\n#{@doc}"
-      end   +
-        "\nActual:\n#{@actual}"
+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_valid_xml(info = "")
-    BeValidXML.new(info)
-  end
-
-  class BeEquivalentXML
-    def initialize(expected, info)
-      @expected = expected
-      @info = info
-    end
-    
-    def matches?(actual)
-      @actual = actual
+  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
 
-      a = @actual.index("<") == 0 ? @actual : "<foo>#{@actual}</foo>"
-      e = @expected.index("<") == 0 ? @expected : "<foo>#{@expected}</foo>"
-      a_hash = ActiveSupport::XmlMini.parse(a)
-      e_hash = ActiveSupport::XmlMini.parse(e)
-      a_hash == e_hash
-    rescue
-      puts $!
-      @fault = $!.message
-      false
-    end
+RSpec::Matchers.define :pass_query do |expected, info|
+  match do |actual|
+    @expected = expected.read
+    query = SPARQL::Grammar.parse(@expected)
+    @results = query.execute(actual)
 
-    def failure_message_for_should
-      "#{@info + "\n" unless @info.empty?}" +
-      "Fault: #{@fault + "\n" if @fault}" +
-      "Expected:#{@expected}\n" +
-      "Actual:#{@actual}"
-    end
+    @results.should == info.expectedResults
   end
   
-  def be_equivalent_xml(expected, info = "")
-    BeEquivalentXML.new(expected, info)
-  end
+  failure_message_for_should do |actual|
+    information = info.respond_to?(:information) ? info.information : ""
+    "#{information + "\n" unless information.empty?}" +
+    if @results.nil?
+      "Query failed to return results"
+    elsif !@results.is_a?(RDF::Literal::Boolean)
+      "Query returned non-boolean results"
+    elsif info.expectedResults
+      "Query returned false"
+    else
+      "Query returned true (expected false)"
+    end +
+    "\n#{@expected}" +
+    "\nResults:\n#{@actual.dump(:ntriples)}" +
+    "\nDebug:\n#{info.trace}"
+  end  
 end