sparql 3.0.0 → 3.1.3

data/lib/sparql/grammar/parser11.rb

@@ -6,8 +6,8 @@ module SPARQL::Grammar
   ##
   # A parser for the SPARQL 1.1 grammar.
   #
-  # @see http://www.w3.org/TR/sparql11-query/#grammar
-  # @see http://en.wikipedia.org/wiki/LR_parser
+  # @see https://www.w3.org/TR/sparql11-query/#grammar
+  # @see https://en.wikipedia.org/wiki/LR_parser
   class Parser
     include SPARQL::Grammar::Meta
     include SPARQL::Grammar::Terminals
@@ -216,7 +216,7 @@ module SPARQL::Grammar
       unless resolve_iris?
         # Only output if we're not resolving URIs internally
         add_prod_datum(:BaseDecl, data[:BaseDecl])
-        add_prod_datum(:PrefixDecl, data[:PrefixDecl]) if data[:PrefixDecl]
+        add_prod_datum(:PrefixDecl, data[:PrefixDecl])
       end
     end
 
@@ -624,11 +624,14 @@ module SPARQL::Grammar
         if (lhs = (input.delete(:query) || []).first) && !lhs.empty?
           query = SPARQL::Algebra::Operator::Join.new(lhs, query)
         end
+        if data[:path]
+          query = SPARQL::Algebra::Operator::Join.new(query, Array(data[:path]).first)
+        end
         add_prod_datum(:query, query)
       elsif !Array(data[:query]).empty?
         # Join query and path
         add_prod_datum(:query, SPARQL::Algebra::Operator::Join.new(data[:path].first, data[:query].first))
-      else
+      elsif data[:path]
         add_prod_datum(:query, data[:path])
       end
     end
@@ -698,9 +701,9 @@ module SPARQL::Grammar
       end
     end
 
-    # [60]  Bind                    ::= 'BIND' '(' Expression 'AS' Var ')'
+    # [60]  Bind                    ::= 'BIND' '(' (Expression || EmbTP) 'AS' Var ')'
     production(:Bind) do |input, data, callback|
-      add_prod_datum :extend, [data[:Expression].unshift(data[:Var].first)]
+      add_prod_datum :extend, [(data[:Expression] || data[:pattern]).unshift(data[:Var].first)]
     end
 
     # [61]  InlineData	            ::= 'VALUES' DataBlock
@@ -716,7 +719,7 @@ module SPARQL::Grammar
     production(:InlineDataOneVar) do |input, data, callback|
       add_prod_datum :Var, data[:Var]
 
-      data[:DataBlockValue].each do |d|
+      Array(data[:DataBlockValue]).each do |d|
         add_prod_datum :row, [[:row, data[:Var].dup << d]]
       end
     end
@@ -856,11 +859,8 @@ module SPARQL::Grammar
       data[:Subject] = prod_data[:Subject]
       error(nil, "Expected Subject", production: :ObjectList) if !prod_data[:Subject] && validate?
       error(nil, "Expected Verb", production: :ObjectList) if !(prod_data[:Verb] || prod_data[:VerbPath]) && validate?
-      if prod_data[:Verb]
-        data[:Verb] = prod_data[:Verb]
-      else
-        data[:VerbPath] = prod_data[:VerbPath]
-      end
+      data[:Verb] = prod_data[:Verb] if prod_data[:Verb]
+      data[:VerbPath] = prod_data[:VerbPath] if prod_data[:VerbPath]
     end
     production(:ObjectList) do |input, data, callback|
       add_prod_datum(:pattern, data[:pattern])
@@ -874,7 +874,7 @@ module SPARQL::Grammar
         if prod_data[:Verb]
           add_pattern(:Object, subject: prod_data[:Subject], predicate: prod_data[:Verb], object: object)
           add_prod_datum(:pattern, data[:pattern])
-        else
+        elsif prod_data[:VerbPath]
           add_prod_datum(:path,
             SPARQL::Algebra::Expression(:path,
                                         prod_data[:Subject].first,
@@ -886,11 +886,8 @@ module SPARQL::Grammar
 
     # [81]	TriplesSameSubjectPath	::=	VarOrTerm PropertyListPathNotEmpty | TriplesNode PropertyListPath
     production(:TriplesSameSubjectPath) do |input, data, callback|
-      if data[:pattern]
-        add_prod_datum(:pattern, data[:pattern])
-      else
-        add_prod_datum(:path, data[:path])
-      end
+      add_prod_datum(:pattern, data[:pattern])
+      add_prod_datum(:path, data[:path])
     end
 
     # [83]  	PropertyListPathNotEmpty	  ::=  	( VerbPath | VerbSimple ) ObjectList ( ';' ( ( VerbPath | VerbSimple ) ObjectList )? )*
@@ -900,16 +897,14 @@ module SPARQL::Grammar
       data[:Subject] = subject
     end
     production(:PropertyListPathNotEmpty) do |input, data, callback|
-      if data[:pattern]
-        add_prod_datum(:pattern, data[:pattern])
-      else
-        add_prod_datum(:path, data[:path])
-      end
+      add_prod_datum(:pattern, data[:pattern])
+      add_prod_datum(:path, data[:path])
     end
 
     # [84]  	VerbPath	  ::=  	Path
     production(:VerbPath) do |input, data, callback|
       if data[:Path]
+        input.delete(:Verb)
         input[:VerbPath] = data[:Path]
       else
         input[:Verb] = data[:iri]
@@ -1109,11 +1104,21 @@ module SPARQL::Grammar
       data.values.each {|v| add_prod_datum(:VarOrTerm, v)}
     end
 
+    # [106s]  	VarOrTermOrEmbTP        ::= Var | GraphTerm | EmbTP
+    production(:VarOrTermOrEmbTP) do |input, data, callback|
+      data.values.each {|v| add_prod_datum(:VarOrTerm, v)}
+    end
+
     # [107]  	VarOrIri	  ::=  	Var | iri
     production(:VarOrIri) do |input, data, callback|
       data.values.each {|v| add_prod_datum(:VarOrIri, v)}
     end
 
+    # [107s]  	VarOrBlankNodeOrIriOrEmbTP ::= Var | BlankNode| iri | EmbTP
+    production(:VarOrBlankNodeOrIriOrEmbTP) do |input, data, callback|
+      data.values.each {|v| add_prod_datum(:VarOrBlankNodeOrIriOrEmbTP, v)}
+    end
+
     # [109]  	GraphTerm	  ::=  	iri |	RDFLiteral |	NumericLiteral
     #                         |	BooleanLiteral |	BlankNode |	NIL
     production(:GraphTerm) do |input, data, callback|
@@ -1124,6 +1129,17 @@ module SPARQL::Grammar
                       data[:NIL])
     end
 
+    # [1xx] EmbTP ::= '<<' VarOrBlankNodeOrIriOrEmbTP Verb VarOrTermOrEmbTP '>>'
+    production(:EmbTP) do |input, data, callback|
+      subject = data[:VarOrBlankNodeOrIriOrEmbTP]
+      predicate = data[:Verb]
+      object = data[:VarOrTerm]
+      add_pattern(:EmbTP,
+                  subject: subject,
+                  predicate: predicate,
+                  object: object)
+    end
+
     # [110]  	Expression	  ::=  	ConditionalOrExpression
     production(:Expression) do |input, data, callback|
       add_prod_datum(:Expression, data[:Expression])
@@ -1420,7 +1436,7 @@ module SPARQL::Grammar
         str = lit.delete(:string)
         lit[:datatype] = lit.delete(:iri) if lit[:iri]
         lit[:language] = lit.delete(:language).last.downcase if lit[:language]
-        input[:literal] = RDF::Literal.new(str, lit) if str
+        input[:literal] = RDF::Literal.new(str, **lit) if str
       end
     end
 
@@ -1471,7 +1487,7 @@ module SPARQL::Grammar
     # @yieldparam  [SPARQL::Grammar::Parser] parser
     # @yieldreturn [void] ignored
     # @return [SPARQL::Grammar::Parser]
-    def initialize(input = nil, options = {}, &block)
+    def initialize(input = nil, **options, &block)
       @input = case input
       when IO, StringIO then input.read
       else input.to_s.dup
@@ -1532,13 +1548,16 @@ module SPARQL::Grammar
     # @param [Symbol, #to_s] prod The starting production for the parser.
     #   It may be a URI from the grammar, or a symbol representing the local_name portion of the grammar URI.
     # @return [Array]
-    # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
-    # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
+    # @see https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+    # @see https://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
-      ll1_parse(@input, prod.to_sym, @options.merge(branch: BRANCH,
-                                                    first: FIRST,
-                                                    follow: FOLLOW,
-                                                    whitespace: WS)
+      ll1_parse(@input,
+        prod.to_sym,
+        branch: BRANCH,
+        first: FIRST,
+        follow: FOLLOW,
+        whitespace: WS,
+        **@options
       ) do |context, *data|
         case context
         when :trace
@@ -1723,9 +1742,7 @@ module SPARQL::Grammar
 
       if id
         @vars[id] ||= begin
-          v = RDF::Query::Variable.new(id)
-          v.distinguished = distinguished
-          v
+          RDF::Query::Variable.new(id, distinguished: distinguished)
         end
       else
         unless distinguished
@@ -1733,9 +1750,7 @@ module SPARQL::Grammar
           id = @nd_var_gen
           @nd_var_gen = id.succ
         end
-        v = RDF::Query::Variable.new(id)
-        v.distinguished = distinguished
-        v
+        RDF::Query::Variable.new(id, distinguished: distinguished)
       end
     end
 
@@ -1763,7 +1778,7 @@ module SPARQL::Grammar
     end
 
     # Create a literal
-    def literal(value, options = {})
+    def literal(value, **options)
       options = options.dup
       # Internal representation is to not use xsd:string, although it could arguably go the other way.
       options.delete(:datatype) if options[:datatype] == RDF::XSD.string
@@ -1772,7 +1787,7 @@ module SPARQL::Grammar
         "options: #{options.inspect}, " +
         "validate: #{validate?.inspect}, "
       end
-      RDF::Literal.new(value, options.merge(validate: validate?))
+      RDF::Literal.new(value, validate: validate?, **options)
     end
 
     # Take collection of objects and create RDF Collection using rdf:first, rdf:rest and rdf:nil
@@ -1803,7 +1818,7 @@ module SPARQL::Grammar
     #
     # @param [String] production Production generating pattern
     # @param [Hash{Symbol => Object}] options
-    def add_pattern(production, options)
+    def add_pattern(production, **options)
       progress(production, "[:pattern, #{options[:subject]}, #{options[:predicate]}, #{options[:object]}]")
       triple = {}
       options.each_pair do |r, v|
@@ -1885,8 +1900,7 @@ module SPARQL::Grammar
               avf.first
             else
               # Allocate a temporary variable for this function, and retain the mapping for outside the group
-              av = RDF::Query::Variable.new(".#{agg}")
-              av.distinguished = false
+              av = RDF::Query::Variable.new(".#{agg}", distinguished: false)
               agg += 1
               aggregates << [av, function]
               av

data/lib/sparql/grammar/terminals11.rb

@@ -110,6 +110,7 @@ module SPARQL::Grammar
                  |isBLANK|isIRI|isURI|isLITERAL|isNUMERIC|sameTerm
                  |true
                  |false
+                 |<<|>>
                  |&&|!=|!|<=|>=|\^\^|\|\||[\(\),.;\[\]\{\}\+\-=<>\?\^\|\*\/a]
               )xim.freeze
 

data/lib/sparql/results.rb

@@ -14,28 +14,38 @@ module SPARQL
     ##
     # Generate Solutions as JSON
     # @return [String]
-    # @see http://www.w3.org/TR/rdf-sparql-json-res/
+    # @see https://www.w3.org/TR/rdf-sparql-json-res/
     def to_json
       require 'json' unless defined?(::JSON)
-      
-      bindings = self.map do |solution|
-        variable_names.inject({}) do |memo, n|
-          memo.merge case s = solution[n]
-          when RDF::URI
-            {n => {type: "uri", value: s.to_s }}
-          when RDF::Node
-            {n => {type: "bnode", value: s.id }}
-          when RDF::Literal
-            if s.datatype?
-              {n => {type: "typed-literal", datatype: s.datatype.to_s, value: s.to_s }}
-            elsif s.language
-              {n => {type: "literal", "xml:lang" => s.language.to_s, value: s.to_s }}
-            else
-              {n => {type: "literal", value: s.to_s }}
-            end
+
+      format = ->(value) do
+        case value
+        when RDF::URI then {type: "uri", value: value.to_s }
+        when RDF::Node then {type: "bnode", value: value.id }
+        when RDF::Literal
+          if value.datatype?
+            {type: "typed-literal", datatype: value.datatype.to_s, value: value.to_s }
+          elsif value.language?
+            {type: "literal", "xml:lang" => value.language.to_s, value: value.to_s }
           else
-            {}
+            {type: "literal", value: value.to_s }
           end
+        when RDF::Statement
+          {
+            type: 'triple',
+            value: {
+              s: format.call(value.subject),
+              p: format.call(value.predicate),
+              o: format.call(value.object)
+            }
+          }
+        end
+      end
+
+      bindings = self.map do |solution|
+        variable_names.inject({}) do |memo, n|
+          rep = format.call(solution[n])
+          rep ? memo.merge(n => rep) : memo
         end
       end
 
@@ -48,12 +58,36 @@ module SPARQL
     ##
     # Generate Solutions as XML
     # @return [String]
-    # @see http://www.w3.org/TR/rdf-sparql-XMLres/
+    # @see https://www.w3.org/TR/rdf-sparql-XMLres/
     def to_xml
       require 'builder' unless defined?(::Builder)
       
       xml = ::Builder::XmlMarkup.new(indent: 2)
       xml.instruct!
+
+      format = ->(s) do
+        case s
+        when RDF::URI
+          xml.uri(s.to_s)
+        when RDF::Node
+          xml.bnode(s.id)
+        when RDF::Literal
+          if s.datatype?
+            xml.literal(s.to_s, "datatype" => s.datatype.to_s)
+          elsif s.language
+            xml.literal(s.to_s, "xml:lang" => s.language.to_s)
+          else
+            xml.literal(s.to_s)
+          end
+        when RDF::Statement
+          xml.triple do
+            xml.s {format.call(s.subject)}
+            xml.p {format.call(s.predicate)}
+            xml.o {format.call(s.object)}
+          end
+        end
+      end
+
       xml.sparql(xmlns: "http://www.w3.org/2005/sparql-results#") do
         xml.head do
           variable_names.each do |n|
@@ -67,20 +101,7 @@ module SPARQL
                 s = solution[n]
                 next unless s
                 xml.binding(name: n) do
-                  case s
-                  when RDF::URI
-                    xml.uri(s.to_s)
-                  when RDF::Node
-                    xml.bnode(s.id)
-                  when RDF::Literal
-                    if s.datatype?
-                      xml.literal(s.to_s, "datatype" => s.datatype.to_s)
-                    elsif s.language
-                      xml.literal(s.to_s, "xml:lang" => s.language.to_s)
-                    else
-                      xml.literal(s.to_s)
-                    end
-                  end
+                  format.call(s)
                 end
               end
             end
@@ -118,7 +139,7 @@ module SPARQL
     ##
     # Generate Solutions as CSV
     # @return [String]
-    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    # @see https://www.w3.org/TR/2013/REC-sparql11-results-csv-tsv-20130321/
     def to_csv
       require 'csv' unless defined?(::CSV)
       bnode_map = {}
@@ -135,7 +156,7 @@ module SPARQL
                 this
               end
             else
-              solution[n].to_s
+              solution[n].to_s.strip
             end
           end
         end
@@ -144,11 +165,9 @@ module SPARQL
     ##
     # Generate Solutions as TSV
     # @return [String]
-    # @see http://www.w3.org/TR/rdf-sparql-json-res/#results
+    # @see https://www.w3.org/TR/2013/REC-sparql11-results-csv-tsv-20130321/
     def to_tsv
       require 'csv' unless defined?(::CSV)
-      bnode_map = {}
-      bnode_gen = "_:a"
       results = [
         variable_names.map {|v| "?#{v}"}.join("\t")
       ] + self.map do |solution|
@@ -159,7 +178,7 @@ module SPARQL
           when nil
             ""
           else
-            RDF::NTriples.serialize(term)
+            RDF::NTriples.serialize(term).strip
           end
         end.join("\t")
       end
@@ -185,7 +204,7 @@ module SPARQL
   # @return [String]
   #   String with serialized results and `#content_type`
   # @raise [RDF::WriterError] when inappropriate formatting options are used
-  def serialize_results(solutions, options = {})
+  def serialize_results(solutions, **options)
     format = options[:format].to_sym if options[:format]
     content_type = options[:content_type].to_s.split(';').first
     content_types = Array(options[:content_types] || '*/*')
@@ -226,7 +245,7 @@ module SPARQL
     when RDF::Queryable
       begin
         require 'linkeddata'
-      rescue LoadError => e
+      rescue LoadError
         require 'rdf/ntriples'
       end
       fmt = RDF::Format.for(format ? format.to_sym : {content_type: content_type})
@@ -236,7 +255,7 @@ module SPARQL
       end
       format ||= fmt.to_sym
       content_type ||= fmt.content_type.first
-      results = solutions.dump(format, options)
+      results = solutions.dump(format, **options)
       raise RDF::WriterError, "Unknown format #{fmt.inspect} for #{solutions.class}" unless results
       results
     when RDF::Query::Solutions
@@ -280,7 +299,7 @@ module SPARQL
   # @param [Array<String>] available
   # @return [String]
   #
-  # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+  # @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
   def first_content_type(acceptable, available)
     return acceptable.first if available.empty?
     available.flatten!
@@ -306,7 +325,7 @@ module SPARQL
   #   May also be an RDF::Writer content_type to serialize DESCRIBE or CONSTRUCT results
   # @return [String]
   #   String with serialized results and #content_type
-  def serialize_exception(exception, options = {})
+  def serialize_exception(exception, **options)
     format = options[:format]
     content_type = options[:content_type]
     content_type ||= SPARQL::Results::MIME_TYPES[format]

data/lib/sparql/version.rb

@@ -1,6 +1,6 @@
 module SPARQL
   module VERSION
-    VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "VERSION")
+    VERSION_FILE = File.expand_path("../../../VERSION", __FILE__)
     MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chomp.split(".")
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')