rdf-n3 0.2.3.2 → 0.3.0

data/rdf-n3.gemspec

@@ -5,49 +5,47 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-n3}
-  s.version = "0.2.3.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2010-11-12}
-  s.description = %q{    RDF::N3 is an Notation-3 (n3-rdf) parser for Ruby using the RDF.rb library suite.
-}
+  s.date = %q{2010-12-27}
+  s.description = %q{RDF::N3 is an Notation-3 (n3-rdf) parser for Ruby using the RDF.rb library suite.}
   s.email = %q{gregg@kellogg-assoc.com}
   s.extra_rdoc_files = [
     "AUTHORS",
-     "History.txt",
-     "README.rdoc"
+     "History.md",
+     "README.md",
+     "VERSION"
   ]
   s.files = [
     ".gitignore",
      ".yardopts",
      "AUTHORS",
-     "History.txt",
-     "README.rdoc",
+     "History.md",
+     "README.md",
      "Rakefile",
      "VERSION",
+     "example-files/sp2b.n3",
      "example.rb",
      "lib/rdf/n3.rb",
      "lib/rdf/n3/format.rb",
      "lib/rdf/n3/patches/array_hacks.rb",
      "lib/rdf/n3/patches/graph_properties.rb",
-     "lib/rdf/n3/patches/qname_hacks.rb",
-     "lib/rdf/n3/patches/seq.rb",
      "lib/rdf/n3/reader.rb",
-     "lib/rdf/n3/reader/n3_grammar.rb",
-     "lib/rdf/n3/reader/n3_grammar.treetop",
-     "lib/rdf/n3/reader/n3_grammar_18.rb",
-     "lib/rdf/n3/reader/n3_grammar_18.treetop",
+     "lib/rdf/n3/reader/meta.rb",
+     "lib/rdf/n3/reader/n3-selectors.n3",
+     "lib/rdf/n3/reader/parser.rb",
      "lib/rdf/n3/version.rb",
      "lib/rdf/n3/vocab.rb",
      "lib/rdf/n3/writer.rb",
      "rdf-n3.gemspec",
+     "script/build_meta",
      "script/console",
      "script/parse",
      "script/tc",
      "spec/cwm_spec.rb",
      "spec/format_spec.rb",
-     "spec/literal_spec.rb",
      "spec/matchers.rb",
      "spec/n3reader_spec.rb",
      "spec/rdf_helper.rb",
@@ -451,6 +449,7 @@ Gem::Specification.new do |s|
      "spec/swap_test/ref/bnode.n3",
      "spec/swap_test/ref/bnode.rdf",
      "spec/swap_test/ref/colon-in-uri.n3",
+     "spec/swap_test/ref/contexts-1.n3",
      "spec/swap_test/ref/daml-ex.n3",
      "spec/swap_test/ref/daml-ont.n3",
      "spec/swap_test/ref/djb1a-out.n3",
@@ -468,6 +467,7 @@ Gem::Specification.new do |s|
      "spec/swap_test/ref/path1.n3",
      "spec/swap_test/ref/path2.n3",
      "spec/swap_test/ref/prefix1.rdf",
+     "spec/swap_test/ref/prefix2.rdf",
      "spec/swap_test/ref/prefix3.rdf",
      "spec/swap_test/ref/rdf-redefine.rdf",
      "spec/swap_test/ref/reluri-1.rdf",
@@ -533,7 +533,9 @@ Gem::Specification.new do |s|
      "spec/turtle/bad-13.ttl",
      "spec/turtle/bad-14.ttl",
      "spec/turtle/manifest-bad.ttl",
+     "spec/turtle/manifest-bad.yml",
      "spec/turtle/manifest.ttl",
+     "spec/turtle/manifest.yml",
      "spec/turtle/rdf-schema.out",
      "spec/turtle/rdf-schema.ttl",
      "spec/turtle/rdfq-results.out",
@@ -606,7 +608,7 @@ Gem::Specification.new do |s|
      "spec/turtle_spec.rb",
      "spec/writer_spec.rb"
   ]
-  s.homepage = %q{http://github.com/gkellogg/rdf-rdfa}
+  s.homepage = %q{http://github.com/gkellogg/rdf-n3}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.7}
@@ -614,7 +616,6 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/cwm_spec.rb",
      "spec/format_spec.rb",
-     "spec/literal_spec.rb",
      "spec/matchers.rb",
      "spec/n3reader_spec.rb",
      "spec/rdf_helper.rb",
@@ -629,26 +630,23 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rdf>, [">= 0.2.1"])
-      s.add_runtime_dependency(%q<treetop>, [">= 1.4.0"])
-      s.add_development_dependency(%q<rspec>, ["= 1.3.0"])
+      s.add_runtime_dependency(%q<rdf>, [">= 0.3.0"])
+      s.add_development_dependency(%q<rspec>, [">= 2.1.0"])
       s.add_development_dependency(%q<rdf-spec>, [">= 0.2.1"])
       s.add_development_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
       s.add_development_dependency(%q<rdf-isomorphic>, [">= 0"])
       s.add_development_dependency(%q<yard>, [">= 0"])
     else
-      s.add_dependency(%q<rdf>, [">= 0.2.1"])
-      s.add_dependency(%q<treetop>, [">= 1.4.0"])
-      s.add_dependency(%q<rspec>, ["= 1.3.0"])
+      s.add_dependency(%q<rdf>, [">= 0.3.0"])
+      s.add_dependency(%q<rspec>, [">= 2.1.0"])
       s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
       s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
       s.add_dependency(%q<rdf-isomorphic>, [">= 0"])
       s.add_dependency(%q<yard>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rdf>, [">= 0.2.1"])
-    s.add_dependency(%q<treetop>, [">= 1.4.0"])
-    s.add_dependency(%q<rspec>, ["= 1.3.0"])
+    s.add_dependency(%q<rdf>, [">= 0.3.0"])
+    s.add_dependency(%q<rspec>, [">= 2.1.0"])
     s.add_dependency(%q<rdf-spec>, [">= 0.2.1"])
     s.add_dependency(%q<rdf-rdfxml>, [">= 0.2.1"])
     s.add_dependency(%q<rdf-isomorphic>, [">= 0"])

data/script/build_meta

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+require 'rdf/n3'
+require 'getoptlong'
+
+# Build rdf/n3/parser/meta.rb from http://www.w3.org/2000/10/swap/grammar/n3-selectors.n3
+# Based on code from http://www.w3.org/2000/10/swap/grammar/predictiveParser.py
+
+class BNF < RDF::Vocabulary("http://www.w3.org/2000/10/swap/grammar/bnf#"); end
+class REGEX < RDF::Vocabulary("http://www.w3.org/2000/10/swap/grammar/regex#"); end
+class N3 < RDF::Vocabulary("http://www.w3.org/2000/10/swap/grammar/n3#"); end
+
+class PredictiveParser
+  attr_accessor :already, :agenda, :errors, :literalTerminals, :branchTable, :tokenRegexps
+  attr_accessor :graph
+  
+  def initialize
+    @already = []
+    @agenda = []
+    @errors = []
+    @literalTerminals = {}
+    @branchTable = {}
+    @tokenRegexps = {}
+  end
+
+  def parse(file)
+    progress("Loading " + file)
+    File.open(file) do |f|
+      @graph = RDF::Graph.new do |g|
+        RDF::N3::Reader.new(f).each do |statement|
+          g << statement
+        end
+      end
+    end
+    progress("Loaded #{@graph.count} statements.")
+  end
+
+  def recordError(str)
+    errors << str
+    "##### ERROR:  #{str}"
+  end
+
+  def progress(str); puts(str); end
+  def chatty(str); progress(str) if $verbose; end
+
+  def runProduction(lhs)
+    doProduction(lhs)
+    while !@agenda.empty?
+      x = @agenda.shift
+      @already << x
+      doProduction(x)
+    end
+
+    if !@errors.empty?
+      progress("###### FAILED with #{errors.length} errors.")
+      @errors.each {|s| progress("  #{s}")}
+      exit(-2)
+    else
+      progress("Ok for predictive parsing")
+    end 
+  end
+  
+  # Generate branch tables for one production
+  def doProduction(lhs)
+    if lhs == BNF.void
+      progress("\nvoid")
+      return
+    end
+    if lhs == BNF.eof
+      progress( "\nEOF")
+      return
+    end
+    if lhs.is_a?(RDF::Literal)
+      literalTerminals[lhs.value()] = 1
+      return
+    end
+
+    branchDict = {}
+
+    rhs = graph.first_object(:subject => lhs, :predicate => BNF.matches)
+    if rhs
+      chatty("\nToken #{lhs} matches regexp #{rhs}")
+      tokenRegexps[lhs] = rhs.value
+
+      cc = graph.query(:subject => lhs, :predicate => BNF.canStartWith)
+      progress(recordError("No record of what token #{lhs} can start with")) if cc.empty?
+      cc.each {|statement| chatty("  Can start with: #{statement.object}")}
+      return
+    end
+  
+    rhs = graph.first_object(:subject => lhs, :predicate => BNF.mustBeOneSequence)
+    unless rhs
+        progress(recordError("No definition of #{lhs}"))
+  #     raise RuntimeError("No definition of %s  in\n %s" %(`lhs`, `g`))
+        return
+    end
+
+    options = rhs
+    progress("\nProduction #{lhs} :: #{options}")
+    graph.query(:subject => lhs, :predicate => BNF.canPrecede) do |statement|
+      chatty("  Can precede '#{statement.object}'")
+    end
+
+    graph.query(:subject => lhs, :predicate => BNF.branch) do |statement|
+      branch = statement.object
+      sequence = graph.first_object(:subject => statement.object, :predicate => BNF.sequence)
+      option = RDF::List.new(sequence, graph).to_a
+      progress("  option: #{option}")
+    
+      option.each do |part|
+        agenda << part unless already.include?(part) || agenda.include?(part)
+      end
+    
+      conditions = graph.query(:subject => branch, :predicate => BNF.condition).map(&:object)
+      if conditions.empty?
+        progress(recordError("NO SELECTOR for #{lhs} option #{option}"))
+        if option.empty?
+          # Void case - the tricky one
+          graph.pattern(:subject => lhs, :predicate => BNF.canPrecede) do |st|
+            progress("      Can precede #{st.object}")
+          end
+        end
+      end
+    
+      progress("    Conditions: #{conditions.to_a.map(&:to_s)}")
+      conditions.each do |str1|
+        if branchDict.has_key?(str1)
+          progress(
+              "Conflict: #{str1} is also the condition for #{branchDict[str1]}")
+        end
+        branchDict[str1] = option
+      end
+    end
+  
+    branchDict.keys.each do |str1|
+      branchDict.keys.each do |str2|
+        s1, s2 = str1.to_s, str2.to_s
+        if (s1.index(s2) == 0 || s2.index(s1) == 0) && branchDict[str1] != branchDict[str2]
+          progress("WARNING: for #{lhs}, #{str1} indicates #{branchDict[str1]}, but #{str2} indicates #{branchDict[str2]}")
+        end
+      end
+    end
+  
+    branchTable[lhs] = branchDict
+  end
+  
+  def litOrNot(value)
+    (value.is_a?(RDF::Literal) ? "" : ":") + value.to_s.dump
+  end
+  
+  def outputBranchTable(io, indent = 0)
+    ind0 = '  ' * indent
+    ind1 = ind0 + '  '
+    ind2 = ind1 + '  '
+    ind3 = ind2 + '  '
+    io.puts "#{ind0}BRANCHES = {"
+    branchTable.keys.sort_by(&:to_s).each do |prod|
+      # Special case double, integer, and decimal to output just a numericliteral, due to a parser conflict
+      next if prod.to_s =~ /numericliteral/
+      io.puts "#{ind1}#{litOrNot(prod)} => {"
+      branchTable[prod].keys.sort_by(&:to_s).each do |term|
+        list = branchTable[prod][term].map {|t2| litOrNot(t2)}.join(",\n#{ind3}")
+        io.puts "#{ind2}#{litOrNot(term)} => [#{list}],"
+      end
+      io.puts "#{ind1}},"
+    end
+    io.puts "#{ind0}}\n"
+  end
+
+  def outputRegexpTable(io, indent = 0)
+    ind0 = '  ' * indent
+    ind1 = ind0 + '  '
+    io.puts "#{ind0}REGEXPS = {"
+    tokenRegexps.keys.sort_by(&:to_s).each do |prod|
+      # Special case double, integer, and decimal to output just a numericliteral, due to a parser conflict
+      next if prod.to_s =~ /(integer|double|decimal)/
+      io.puts "#{ind1}#{litOrNot(prod)} => Regexp.compile(" +
+      case prod.to_s
+      when /barename/     then  %q(%(^[#{BARENAME_START}][#{BARENAME_TAIL}]*))
+      when /explicituri/  then  %q("^<[^>]*>")
+      when /langcode/     then  %q("^[a-zA-Z]+(-[a-zA-Z0-9]+)*")
+      when /prefix/       then  %q(%(^([#{BARENAME_START}][#{BARENAME_TAIL}]*)?:))
+      when /qname/        then  %q(%(^(([#{BARENAME_START}][#{BARENAME_TAIL}]*)?:)?([#{BARENAME_START}][#{BARENAME_TAIL}]*)?))
+      when /variable/     then  %q(%(^\\\\?[#{BARENAME_START}][#{BARENAME_TAIL}]*))
+      else                      tokenRegexps[prod].dump
+      end + "),"
+    end
+
+    io.puts "\n#{ind1}# Hack to replace integer|double|decimal with numericliteral"
+    io.puts "#{ind1}#{litOrNot(N3.numericliteral)} => Regexp.compile(" + %q(%(^[-+]?[0-9]+(\\\\.[0-9]+)?(e[-+]?[0-9]+)?)) + ")"
+    io.puts "#{ind0}}\n"
+  end
+end
+
+$verbose = false
+$debug = false
+grammarFile = File.expand_path(File.join(File.dirname(__FILE__), "../lib/rdf/n3/reader/n3-selectors.n3"))
+parseAs = "document"
+output = STDOUT
+
+opts = GetoptLong.new(
+  ["--debug", GetoptLong::NO_ARGUMENT],
+  ["--verbose", GetoptLong::NO_ARGUMENT],
+  ["--grammar", GetoptLong::REQUIRED_ARGUMENT],
+  ["--as", GetoptLong::REQUIRED_ARGUMENT],
+  ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT]
+)
+opts.each do |opt, arg|
+  case opt
+  when '--verbose' then $verbose = true
+  when '--debug' then $debug = true
+  when '--grammar' then grammarFile = arg
+  when '--as' then parseAs = arg
+  when '--output' then output = File.open(arg, "w")
+  end
+end
+
+pp = PredictiveParser.new
+
+pp.parse(grammarFile)
+pp.runProduction(N3[parseAs])
+
+unless output == STDOUT
+  output.puts "# This file is automatically generated by #{__FILE__}"
+  output.puts "# Branch and Regexp tables derived from http://www.w3.org/2000/10/swap/grammar/n3-selectors.n3"
+  output.puts "module RDF::N3::Meta"
+end
+pp.outputBranchTable(output, 1)
+output.puts %q(
+  if RUBY_VERSION >= "1.9.0"
+    BARENAME_START = "A-Z_a-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02ff\u0370-\u037d\u037f-\u1fff\u200c-\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd\u{10000}-\u{effff}"
+    BARENAME_TAIL = "0-9#{BARENAME_START}\u00b7\u0300-\u036f\u203f-\u2040\\\\-"
+  else
+    BARENAME_START = "A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\xff"
+    BARENAME_TAIL = "0-9#{BARENAME_START}\xb7\\\\-"
+  end
+)
+pp.outputRegexpTable(output, 1)
+unless output == STDOUT
+  output.puts "end"
+end

data/script/parse

@@ -2,21 +2,65 @@
 require 'rubygems'
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'rdf/n3'
+require 'rdf/ntriples'
 require 'getoptlong'
+require 'open-uri'
 
-def parse(input, base)
-  puts RDF::Writer.for($format.to_sym).buffer(:base_uri => base) { |writer|
-    RDF::N3::Reader.new(input, :base_uri => base, :strict => true).each do |statement|
-      writer << statement
+def run(input, base)
+  reader_class = RDF::Reader.for($input_format.to_sym)
+  writer_class = RDF::Writer.for($output_format.to_sym)
+  raise "Reader not found for #{$input_format}" unless reader_class
+  raise "Writer not found for #{$output_format}" unless writer_class
+
+  start = Time.new
+  num = 0
+  if $parse_only
+    include RDF::N3::Meta
+    include RDF::N3::Parser
+    puts "\nparse #{input.read}---\n\n" unless $quiet
+    input.rewind
+    if $quiet
+      $stdout = StringIO.new
+    end
+    test(input, BRANCHES, REGEXPS)
+    if $quiet
+      $stdout = STDOUT
+      print "."
+    end
+  elsif $output_format == :ntriples || $quiet
+    reader_class.new(input, :base_uri => base, :strict => true).each do |statement|
+      num += 1
+      if $quiet
+        #print "."
+      else
+        puts statement.to_ntriples
+      end
+    end
+  elsif $output_format == :inspect
+    reader_class.new(input, :base_uri => base, :strict => true).each do |statement|
+      num += 1
+      puts statement.inspect
     end
-  }
+  else
+    puts writer_class.buffer(:base_uri => base, :standard_prefixes => true) { |writer|
+      reader_class.new(input, :base_uri => base, :strict => true).each do |statement|
+        num += 1
+        writer << statement
+      end
+    }
+  end
+  puts
+  secs = Time.new - start
+  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
 
-mode = ARGV.shift
-raise "Mode must be one of 'parse'" unless mode == "parse"
-
 $verbose = false
-$format = :ntriples
+$output_format = :ntriples
+$input_format = :n3
 base_uri  = "http://example.com"
 input = nil
 
@@ -25,7 +69,9 @@ opts = GetoptLong.new(
   ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--quiet", GetoptLong::NO_ARGUMENT],
   ["--format", GetoptLong::REQUIRED_ARGUMENT],
+  ["--input-format", GetoptLong::REQUIRED_ARGUMENT],
   ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
+  ["--parse-only", GetoptLong::NO_ARGUMENT],
   ["--uri", GetoptLong::REQUIRED_ARGUMENT]
 )
 opts.each do |opt, arg|
@@ -34,16 +80,19 @@ opts.each do |opt, arg|
   when '--quiet' then $quiet = true
   when '--debug' then ::RDF::N3::debug = true
   when '--execute' then input = arg
-  when '--format' then $format = arg
+  when '--format' then $output_format = arg.to_sym
+  when '--input-format' then $input_format = arg.to_sym
   when '--uri' then base_uri = arg
+  when '--parse-only' then $parse_only = true
   end
 end
 
 if ARGV.empty?
   s = input ? input : $stdin.read
-  parse(StringIO.new(s), base_uri)
+  run(StringIO.new(s), base_uri)
 else
   ARGV.each do |test_file|
-    parse(File.open(test_file), base_uri)
+    run(Kernel.open(test_file), base_uri)
   end
-end
+end
+puts