rdf-n3 0.3.4.1 → 0.3.5

data/rdf-n3.gemspec

@@ -1,111 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{rdf-n3}
-  s.version = "0.3.4.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Gregg Kellogg"]
-  s.date = %q{2011-07-11}
-  s.description = %q{RDF::N3 is an Notation-3 and Turtle reader/writer for the RDF.rb library suite.}
-  s.email = %q{gregg@kellogg-assoc.com}
-  s.extra_rdoc_files = [
-    "AUTHORS",
-    "History.md",
-    "README.md",
-    "UNLICENSE",
-    "VERSION"
-  ]
-  s.files = [
-    ".yardopts",
-    "AUTHORS",
-    "History.md",
-    "README",
-    "README.md",
-    "Rakefile",
-    "UNLICENSE",
-    "VERSION",
-    "example-files/arnau-registered-vocab.rb",
-    "example-files/arnau-stack-overflow.ttl",
-    "example-files/best-buy.nt",
-    "example-files/dwbutler-mj.n3",
-    "example-files/dwbutler-mj.ttl",
-    "example-files/lee-reilly-list.rb",
-    "example-files/recipe.ttl",
-    "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/reader.rb",
-    "lib/rdf/n3/reader/bnf-rules.n3",
-    "lib/rdf/n3/reader/meta.rb",
-    "lib/rdf/n3/reader/n3-selectors.n3",
-    "lib/rdf/n3/reader/n3.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",
-    "script/yard-to-rubyforge",
-    "spec/.gitignore",
-    "spec/cwm_spec.rb",
-    "spec/cwm_test.rb",
-    "spec/format_spec.rb",
-    "spec/matchers.rb",
-    "spec/reader_spec.rb",
-    "spec/spec.opts",
-    "spec/spec_helper.rb",
-    "spec/swap_spec.rb",
-    "spec/swap_test.rb",
-    "spec/turtle_spec.rb",
-    "spec/turtle_test.rb",
-    "spec/writer_spec.rb"
-  ]
-  s.homepage = %q{http://github.com/gkellogg/rdf-n3}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
-  s.summary = %q{N3/Turtle reader/writer for RDF.rb.}
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rdf>, [">= 0.3.3"])
-      s.add_development_dependency(%q<open-uri-cached>, [">= 0"])
-      s.add_development_dependency(%q<spira>, [">= 0.0.12"])
-      s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_development_dependency(%q<rdf-spec>, [">= 0.3.3"])
-      s.add_development_dependency(%q<rdf-rdfxml>, [">= 0.3.3"])
-      s.add_development_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-    else
-      s.add_dependency(%q<rdf>, [">= 0.3.3"])
-      s.add_dependency(%q<open-uri-cached>, [">= 0"])
-      s.add_dependency(%q<spira>, [">= 0.0.12"])
-      s.add_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_dependency(%q<rdf-spec>, [">= 0.3.3"])
-      s.add_dependency(%q<rdf-rdfxml>, [">= 0.3.3"])
-      s.add_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-      s.add_dependency(%q<yard>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<rdf>, [">= 0.3.3"])
-    s.add_dependency(%q<open-uri-cached>, [">= 0"])
-    s.add_dependency(%q<spira>, [">= 0.0.12"])
-    s.add_dependency(%q<rspec>, [">= 2.5.0"])
-    s.add_dependency(%q<rdf-spec>, [">= 0.3.3"])
-    s.add_dependency(%q<rdf-rdfxml>, [">= 0.3.3"])
-    s.add_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-    s.add_dependency(%q<yard>, [">= 0"])
-  end
-end
-

data/script/build_meta

@@ -1,249 +0,0 @@
-#!/usr/bin/env ruby
-# build_meta --- generator of parser tables for SPARQL::Grammar::Parser
-#     Derived from: 
-#        http://www.w3.org/2000/10/swap/grammar/predictiveParser.py
-#        - predictiveParser.py, Tim Berners-Lee, 2004
-#
-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
-
-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)
-    @graph = RDF::Graph.load(file)
-    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"))
-start = N3.document
-output = STDOUT
-
-opts = GetoptLong.new(
-  ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--grammar", GetoptLong::REQUIRED_ARGUMENT],
-  ["--start", GetoptLong::REQUIRED_ARGUMENT],
-  ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
-  ["--help", "-?", GetoptLong::NO_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")
-  when '--help'
-    puts %(Usage: build_meta --grammar=file --as=uri [--output=file]
-        --grammar=file  This is the RDF augmented grammar
-        --start=uri     This is the URI of the production as which the document
-                        is to be parsed
-        --output=file   Where to save output
-)
-    exit(0)
-  end
-end
-
-pp = PredictiveParser.new
-
-pp.parse(grammarFile)
-pp.runProduction(start)
-
-unless output == STDOUT
-  output.puts "# This file is automatically generated by #{__FILE__}"
-  output.puts "# Branch and Regexp tables derived from #{grammarFile}"
-  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/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-
-libs =  " -r irb/completion"
-RDF = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "rdf", "lib"))
-libs << " -I #{RDF}" if File.directory?(RDF)
-libs <<  " -r #{File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib", "rdf", "n3.rb")}"
-puts "Loading rdf-n3 gem"
-exec "#{irb} #{libs} --simple-prompt"

data/script/parse

@@ -1,103 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
-require 'rdf/n3'
-require 'rdf/ntriples'
-require 'rdf/rdfxml' rescue nil
-require 'rdf/rdfa' rescue nil
-require 'getoptlong'
-require 'open-uri'
-
-def run(input, options)
-  reader_class = RDF::Reader.for(options[:input_format].to_sym)
-  raise "Reader not found for #{options[:input_format]}" unless reader_class
-
-  prefixes = {}
-  start = Time.new
-  num = 0
-  if options[:parse_only]
-    include RDF::N3::Meta
-    include RDF::N3::Parser
-    puts "\nparse #{input.read}---\n\n" unless options[:quiet]
-    input.rewind
-    if options[:quiet]
-      $stdout = StringIO.new
-    end
-    test(input, BRANCHES, REGEXPS)
-    if options[:quiet]
-      $stdout = STDOUT
-      print "."
-    end
-  elsif 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, :base_uri => options[:base_uri], :strict => true)
-    g = RDF::Graph.new << r
-    num = g.count
-    options[:output].puts g.dump(options[:output_format], :base_uri => options[:base_uri], :prefixes => r.prefixes, :standard_prefixes => true)
-  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
-
-options = {
-  :validate => false,
-  :strict => true,
-  :output => STDOUT,
-  :output_format => :ntriples,
-  :input_format => :n3,
-  :base_uri => "http://example.com",
-}
-input = nil
-
-opts = GetoptLong.new(
-  ["--dbg", GetoptLong::NO_ARGUMENT],
-  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--input-format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
-  ["--parse-only", GetoptLong::NO_ARGUMENT],
-  ["--quiet", GetoptLong::NO_ARGUMENT],
-  ["--uri", GetoptLong::REQUIRED_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT]
-)
-opts.each do |opt, arg|
-  case opt
-  when '--dbg'        then ::RDF::N3::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 '--output'       then options[:output] = File.open(arg, "w")
-  when '--parse-only'   then options[:parse_only] = true
-  when '--quiet'        then options[:quiet] = true
-  when '--uri'          then options[:base_uri] = arg
-  when '--verbose'      then $verbose = true
-  end
-end
-
-if ARGV.empty?
-  s = input ? input : $stdin.read
-  run(StringIO.new(s), options)
-else
-  ARGV.each do |test_file|
-    run(Kernel.open(test_file), options)
-  end
-end
-puts