sparql 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d72aeb5d5db6d7d428b89437f714b0c210e863f
-  data.tar.gz: daccd43bd940b353f85b9bfe9e4d6bf8915463b7
+  metadata.gz: c1f482dd9f82cbd685ddf363d85fce672b73ffa2
+  data.tar.gz: 42dad47f92ec19e8620b4fe9056fd56393e4e4ad
 SHA512:
-  metadata.gz: 22242763a859e2ab8c5c704f67e5fcfe4e36868ef3591c8ff8aaaceb0edffe5a4e0cda204d77b558df270c161f85d4bbbc01b8c5af1043a7e3aed93b64fd7bbc
-  data.tar.gz: 266accb58158ef89a63705165409ede9d92d3112d1c7d465cc213bca276c91cf83f23ebf8eaf318079cc9b06b9906761eb9e04e165db4668a7f0bcb2023ebc4f
+  metadata.gz: 73afb94c540c89133b1321c7075de3e77e7cba8a36e21282e673caa058e3cbe4bdff247b0ac02530ba4fd55e059dd1c480a151d74e0c2415445496d710131615
+  data.tar.gz: 8a7377e7d6a9ecda3c16e821b62751ec84557c3dbdbac26e0e9bf3f9f99bf2aee9720f044f21b9ab5bb7d4b86c27b8b6a12328c0916e83fb578af6bb3d5e8d60

data/README.md

@@ -171,16 +171,19 @@ a full set of RDF formats.
 
 ### Command line processing
 
-    sparql --default-graph etc/doap.ttl etc/from_default.rq
-    sparql -e "SELECT * FROM <etc/doap.ttl> WHERE { ?s ?p ?o }"
+    sparql execute --dataset etc/doap.ttl etc/from_default.rq
+    sparql execute -e "SELECT * FROM <etc/doap.ttl> WHERE { ?s ?p ?o }"
 
     # Generate SPARQL Algebra Expression (SSE) format
-    sparql --to-sse etc/input.rq
-    sparql --to-sse -e "SELECT * WHERE { ?s ?p ?o }"
+    sparql parse etc/input.rq
+    sparql parse -e "SELECT * WHERE { ?s ?p ?o }"
 
     # Run query using SSE input
-    sparql --default-graph etc/doap.ttl --sse etc/input.sse
-    sparql --sse -e "(dataset (<etc/doap.ttl>) (bgp (triple ?s ?p ?o))))"
+    sparql execute --dataset etc/doap.ttl --sse etc/input.sse
+    sparql execute --sse -e "(dataset (<etc/doap.ttl>) (bgp (triple ?s ?p ?o))))"
+
+    # Run a local SPARQL server using a dataset
+    sparql server etc/doap.ttl
 
 ### Adding SPARQL content negotiation to a Rails 3.x application
 

data/VERSION

@@ -1 +1 @@
-1.1.8
+1.1.9

data/bin/sparql

@@ -4,17 +4,26 @@ $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'sparql'
 begin
   require 'linkeddata'
-rescue LoadError => e
+rescue LoadError
   require 'rdf/ntriples'
 end
 require 'getoptlong'
 
+def display_results(res, options)
+  puts res.inspect if options[:verbose]
+  puts case res
+  when RDF::Graph   then res.dump(:ttl, base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
+  when RDF::Literal then res.inspect
+  else                   res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
+  end
+end
+
 def run(input, options = {})
   if options[:debug]
-    puts "input graph:\n#{options[:graph].dump(:ttl, standard_prefixes: true)}\n" if options[:graph]
+    puts "input graph:\n#{options[:dataset].dump(:trig, standard_prefixes: true)}\n" if options[:dataset]
     puts "query:\n#{input}\n"
   end
-  options[:graph] ||= RDF::Repository.new
+  options[:dataset] ||= RDF::Repository.new
 
   if options[:verbose]
     puts ("\nSPARQL:\n" + input) 
@@ -30,67 +39,115 @@ def run(input, options = {})
   puts ("\nSSE:\n" + query.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
-    res = query.execute(options[:graph], debug: options[:debug])
-    puts res.inspect if options[:verbose]
-    puts case res
-    when RDF::Graph   then res.dump(:ttl, base_uri: query.base_uri, prefixes: query.prefixes, standard_prefixes: true)
-    when RDF::Literal then res.inspect
-    else                   res.map {|s| s.bindings.map {|k,v| "#{k}: #{v}"}}.join("\n")
+    res = query.execute(options[:dataset], debug: options[:debug])
+    display_results(res, options)
+  end
+end
+
+def server(options)
+  require 'sinatra/sparql'
+  repository = options.fetch(:dataset, RDF::Repository.new)
+
+  app = Sinatra.new do
+    register Sinatra::SPARQL
+    set :repository, repository
+
+    get '/' do
+      if params["query"]
+        query = params["query"].to_s.match(/^http:/) ? RDF::Util::File.open_file(params["query"]) : ::URI.decode(params["query"].to_s)
+        SPARQL.execute(query, settings.repository)
+      else
+        settings.sparql_options.replace(standard_prefixes: true)
+        settings.sparql_options.merge!(:prefixes => {
+          ssd: "http://www.w3.org/ns/sparql-service-description#",
+          void: "http://rdfs.org/ns/void#"
+        })
+        service_description(repo: settings.repository, endpoint: url)
+      end
+    end
+
+    post '/' do
+      SPARQL.execute(params['query'], settings.repository)
     end
   end
+  Rack::Server.start(app: app)
+rescue LoadError
+  $stderr.puts "Running SPARQL server requires Rack to be in environment: #{$!.message}"
+end
+
+def usage
+  puts "Usage: #{$0} execute [options] query-file         Execute a query against the specified dataset"
+  puts "       #{$0} parse [options] query-file           Parse a query into SPARQL S-Expressions (SSE)"
+  puts "       #{$0} query [options] end-point query-file Run the query against a remote end-point"
+  puts "       #{$0} server [options] dataset-file        Start a server initialized from the specified dataset"
+  puts "Options:"
+  puts "      --execute,-e:         Use option argument as the SPARQL input if no query-file given"
+  puts "      --dataset:            File containing RDF graph or dataset"
+  puts "      --debug:              Display detailed debug output"
+  puts "      --port,-p             Port on which to run server; defaults to 9292"
+  puts "      --sse:                Query input is in SSE format"
+  puts "      --debug:              Display detailed debug output"
+  puts "      --update:             Process query as a SPARQL Update"
+  puts "      --verbose:            Display details of processing"
+  puts "      --help,-?:            This message"
+  exit(0)
 end
 
+cmd, input = ARGV.shift, nil
+
 opts = GetoptLong.new(
+  ["--dataset", GetoptLong::REQUIRED_ARGUMENT],
   ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--dump", GetoptLong::NO_ARGUMENT],
+  ["--port", "-p", GetoptLong::REQUIRED_ARGUMENT],
   ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--sse", GetoptLong::NO_ARGUMENT],
-  ["--to-sse", GetoptLong::NO_ARGUMENT],
+  ["--update", GetoptLong::NO_ARGUMENT],
   ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
-  ["--default-graph", "-g", GetoptLong::REQUIRED_ARGUMENT],
   ["--help", "-?", GetoptLong::NO_ARGUMENT]
 )
 
 options = {
-  graph: RDF::Repository.new,
+  dataset: RDF::Repository.new,
 }
 
-input = nil
-
 opts.each do |opt, arg|
   case opt
+  when '--dataset'       then options[:dataset].load(arg)
   when '--execute'       then input = arg
-  when "--default-graph" then options[:graph] = RDF::Graph.load(arg)
-  when '--dump'          then $dump = true
+  when '--port'          then options[:port] = arg.to_i
   when '--sse'           then options[:sse] = true
-  when '--to-sse'        then options[:to_sse] = true
   when '--debug'         then options[:debug] = true
   when '--update'        then options[:update] = true
   when '--verbose'       then options[:verbose] = true
-  when "--help"
-    puts "Usage: #{$0} [options] file-or-uri ..."
-    puts "Options:"
-    puts "      --execute,-e:         Use option argument as the SPARQL input if no files are given"
-    puts "      --default-graph:      Load default graph"
-    puts "      --dump:               Dump raw output, otherwise serialize to SSE"
-    puts "      --debug:              Display detailed debug output"
-    puts "      --sse:                Input is in SSE format"
-    puts "      --to-sse:             Generate SSE instead of running query"
-    puts "      --debug:              Display detailed debug output"
-    puts "      --update:             Process query as a SPARQL Update"
-    puts "      --verbose:            Display details of processing"
-    puts "      --help,-?:            This message"
-    exit(0)
+  when "--help"          then usage
   end
 end
 
-if ARGV.empty?
-  s = input ? input : $stdin.read
-  run(s, options)
-else
-  ARGV.each do |test_file|
-    puts "parse #{test_file}"
-    run(RDF::Util::File.open_file(test_file).read, options.merge(base_uri: RDF::URI(test_file)))
+unless %w(execute query parse server help).include?(cmd)
+  $stderr.puts "Unrecognized command #{cmd}"
+  usage
+end
+
+case cmd
+when 'execute', 'parse'
+  options[:to_sse] = true if cmd == 'parse'
+  input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
+  run(input, options)
+when 'query'
+  endpoint = ARGV.shift
+  unless endpoint
+    $stderr.puts "Expected SPARQL endpoint URL"
+    usage
+  end
+  input ||= ARGV.empty? ? $stdin.read : RDF::Util::File.open_file(ARGV.first).read
+  SPARQL::Client.new(endpoint) do |client|
+    res = client.query(input)
+    display_results(res, options)
+  end
+when 'server'
+  if data_file = ARGV.shift
+    options[:dataset] = RDF::Repository.load(data_file)
   end
+  server(options)
+else usage
 end
-puts

data/lib/sparql/algebra/operator.rb

@@ -584,23 +584,29 @@ module SPARQL; module Algebra
     end
 
     ##
-    # Iterate via depth-first recursive descent over operands, yielding each operator
+    # Enumerate via depth-first recursive descent over operands, yielding each operator
     # @yield operator
     # @yieldparam [Object] operator
-    def descendants(&block)
-      operands.each do |operand|
-        case operand
-        when Operator
-          operand.descendants(&block)
-        when Array
-          operand.each do |op|
-            op.descendants(&block) if op.is_a?(Operator)
-            block.call(op)
+    # @return [Enumerator]
+    def each_descendant(&block)
+      if block_given?
+        operands.each do |operand|
+          case operand
+          when Array
+            operand.each do |op|
+              op.each_descendant(&block) if op.respond_to?(:each_descendant)
+              block.call(op)
+            end
+          else
+            operand.each_descendant(&block) if operand.respond_to?(:each_descendant)
           end
+          block.call(operand)
         end
-        block.call(operand)
       end
+      enum_for(:each_descendant)
     end
+    alias_method :descendants, :each_descendant
+    alias_method :each, :each_descendant
 
     ##
     # Parent expression, if any

data/lib/sparql/algebra/operator/create.rb

@@ -37,7 +37,6 @@ module SPARQL; module Algebra
         operands.shift if silent
 
         iri = operands.first
-        #require 'byebug'; byebug
         raise ArgumentError, "clear expected a single IRI" if operands.length != 1 || !iri.is_a?(RDF::URI)
         if queryable.has_context?(iri)
           raise IOError, "create operation graph #{iri.to_ntriples} exists" unless silent

data/lib/sparql/algebra/operator/with.rb

@@ -46,7 +46,7 @@ module SPARQL; module Algebra
         end
 
         # Set name for RDF::Graph descendants having no context to the name variable
-        descendants do |op|
+        each_descendant do |op|
           case op
           when RDF::Query, RDF::Query::Pattern
             unless op.context

data/lib/sparql/algebra/query.rb

@@ -120,6 +120,5 @@ module SPARQL; module Algebra
     def each_solution(&block)
       solutions.each(&block)
     end
-    alias_method :each, :each_solution
   end # Query
 end; end # SPARQL::Algebra

data/lib/sparql/grammar/parser11.rb

@@ -552,6 +552,7 @@ module SPARQL::Grammar
     end
     production(:QuadData) do |input, data, callback|
       # Transform using statements instead of patterns, and verify there are no variables
+      raise Error, "QuadData empty" unless data[:pattern]
       raise Error, "QuadData contains variable operands: #{data[:pattern].to_sse}" if data[:pattern].first.variable?
       self.nd_var_gen = "0"
       input[:pattern] = data[:pattern]
@@ -881,8 +882,6 @@ module SPARQL::Grammar
 
     # [85]  	VerbSimple	  ::=  	Var
     production(:VerbSimple) do |input, data, callback|
-      #require 'byebug'; byebug
-      #data.values.each {|v| add_prod_datum(:Verb, v)}
       input[:Verb] = data.values.flatten.first
     end
 
@@ -1691,17 +1690,14 @@ module SPARQL::Grammar
     # Create URIs
     def iri(value)
       # If we have a base URI, use that when constructing a new URI
-      iri = if base_uri
-        u = base_uri.join(value.to_s)
-        u.lexical = "<#{value}>" unless u.to_s == value.to_s || resolve_iris?
+      value = RDF::URI(value)
+      if base_uri && value.relative?
+        u = base_uri.join(value)
+        u.lexical = "<#{value}>" unless resolve_iris?
         u
       else
-        RDF::URI(value)
+        value
       end
-
-      #iri.validate! if validate? && iri.respond_to?(:validate)
-      #iri = RDF::URI.intern(iri) if intern?
-      iri
     end
 
     def ns(prefix, suffix)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - Gregg Kellogg
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-27 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf