sparql 3.0.2 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (91) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +2 -2
  3. data/VERSION +1 -1
  4. data/bin/sparql +8 -8
  5. data/lib/rack/sparql.rb +1 -1
  6. data/lib/rack/sparql/conneg.rb +1 -1
  7. data/lib/sinatra/sparql.rb +1 -1
  8. data/lib/sparql.rb +4 -4
  9. data/lib/sparql/algebra.rb +4 -4
  10. data/lib/sparql/algebra/aggregate.rb +2 -2
  11. data/lib/sparql/algebra/evaluatable.rb +2 -2
  12. data/lib/sparql/algebra/expression.rb +7 -7
  13. data/lib/sparql/algebra/extensions.rb +9 -14
  14. data/lib/sparql/algebra/operator.rb +1 -1
  15. data/lib/sparql/algebra/operator/add.rb +1 -1
  16. data/lib/sparql/algebra/operator/alt.rb +2 -2
  17. data/lib/sparql/algebra/operator/and.rb +4 -4
  18. data/lib/sparql/algebra/operator/asc.rb +2 -2
  19. data/lib/sparql/algebra/operator/ask.rb +2 -2
  20. data/lib/sparql/algebra/operator/avg.rb +5 -3
  21. data/lib/sparql/algebra/operator/base.rb +2 -2
  22. data/lib/sparql/algebra/operator/bnode.rb +3 -3
  23. data/lib/sparql/algebra/operator/bound.rb +2 -2
  24. data/lib/sparql/algebra/operator/clear.rb +1 -1
  25. data/lib/sparql/algebra/operator/coalesce.rb +2 -2
  26. data/lib/sparql/algebra/operator/concat.rb +2 -2
  27. data/lib/sparql/algebra/operator/construct.rb +2 -2
  28. data/lib/sparql/algebra/operator/copy.rb +1 -1
  29. data/lib/sparql/algebra/operator/count.rb +2 -2
  30. data/lib/sparql/algebra/operator/create.rb +1 -1
  31. data/lib/sparql/algebra/operator/dataset.rb +3 -3
  32. data/lib/sparql/algebra/operator/delete.rb +4 -2
  33. data/lib/sparql/algebra/operator/delete_data.rb +1 -1
  34. data/lib/sparql/algebra/operator/delete_where.rb +3 -3
  35. data/lib/sparql/algebra/operator/describe.rb +1 -1
  36. data/lib/sparql/algebra/operator/distinct.rb +2 -2
  37. data/lib/sparql/algebra/operator/drop.rb +1 -1
  38. data/lib/sparql/algebra/operator/encode_for_uri.rb +1 -1
  39. data/lib/sparql/algebra/operator/exists.rb +4 -4
  40. data/lib/sparql/algebra/operator/exprlist.rb +2 -2
  41. data/lib/sparql/algebra/operator/extend.rb +5 -5
  42. data/lib/sparql/algebra/operator/filter.rb +3 -3
  43. data/lib/sparql/algebra/operator/graph.rb +2 -2
  44. data/lib/sparql/algebra/operator/group.rb +11 -11
  45. data/lib/sparql/algebra/operator/group_concat.rb +5 -5
  46. data/lib/sparql/algebra/operator/if.rb +4 -4
  47. data/lib/sparql/algebra/operator/in.rb +3 -3
  48. data/lib/sparql/algebra/operator/insert.rb +4 -2
  49. data/lib/sparql/algebra/operator/insert_data.rb +1 -1
  50. data/lib/sparql/algebra/operator/join.rb +3 -3
  51. data/lib/sparql/algebra/operator/left_join.rb +3 -3
  52. data/lib/sparql/algebra/operator/load.rb +1 -1
  53. data/lib/sparql/algebra/operator/max.rb +5 -3
  54. data/lib/sparql/algebra/operator/min.rb +5 -3
  55. data/lib/sparql/algebra/operator/minus.rb +3 -3
  56. data/lib/sparql/algebra/operator/modify.rb +3 -3
  57. data/lib/sparql/algebra/operator/move.rb +1 -1
  58. data/lib/sparql/algebra/operator/notexists.rb +2 -2
  59. data/lib/sparql/algebra/operator/notin.rb +3 -3
  60. data/lib/sparql/algebra/operator/notoneof.rb +3 -4
  61. data/lib/sparql/algebra/operator/or.rb +4 -4
  62. data/lib/sparql/algebra/operator/order.rb +4 -4
  63. data/lib/sparql/algebra/operator/path.rb +4 -3
  64. data/lib/sparql/algebra/operator/path_opt.rb +14 -14
  65. data/lib/sparql/algebra/operator/path_plus.rb +6 -6
  66. data/lib/sparql/algebra/operator/path_star.rb +2 -2
  67. data/lib/sparql/algebra/operator/plus.rb +1 -1
  68. data/lib/sparql/algebra/operator/prefix.rb +2 -2
  69. data/lib/sparql/algebra/operator/project.rb +2 -2
  70. data/lib/sparql/algebra/operator/reduced.rb +2 -2
  71. data/lib/sparql/algebra/operator/regex.rb +1 -1
  72. data/lib/sparql/algebra/operator/replace.rb +1 -1
  73. data/lib/sparql/algebra/operator/reverse.rb +2 -2
  74. data/lib/sparql/algebra/operator/sample.rb +2 -2
  75. data/lib/sparql/algebra/operator/seq.rb +4 -5
  76. data/lib/sparql/algebra/operator/sequence.rb +3 -3
  77. data/lib/sparql/algebra/operator/slice.rb +2 -2
  78. data/lib/sparql/algebra/operator/substr.rb +1 -1
  79. data/lib/sparql/algebra/operator/sum.rb +5 -3
  80. data/lib/sparql/algebra/operator/table.rb +1 -1
  81. data/lib/sparql/algebra/operator/union.rb +2 -2
  82. data/lib/sparql/algebra/operator/update.rb +2 -2
  83. data/lib/sparql/algebra/operator/using.rb +2 -2
  84. data/lib/sparql/algebra/operator/with.rb +4 -4
  85. data/lib/sparql/algebra/query.rb +1 -1
  86. data/lib/sparql/algebra/update.rb +1 -1
  87. data/lib/sparql/extensions.rb +4 -4
  88. data/lib/sparql/grammar.rb +7 -7
  89. data/lib/sparql/grammar/parser11.rb +15 -17
  90. data/lib/sparql/results.rb +3 -3
  91. metadata +26 -33
@@ -30,8 +30,8 @@ module SPARQL; module Algebra
30
30
  # @return [RDF::Query::Solutions]
31
31
  # the resulting solution sequence
32
32
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
33
- def execute(queryable, options = {}, &block)
34
- @solutions = queryable.query(operands.last, options.merge(depth: options[:depth].to_i + 1))
33
+ def execute(queryable, **options, &block)
34
+ @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options)
35
35
  @solutions = @solutions.project(*(operands.first))
36
36
  @solutions.each(&block) if block_given?
37
37
  @solutions
@@ -31,9 +31,9 @@ module SPARQL; module Algebra
31
31
  # @return [RDF::Query::Solutions]
32
32
  # the resulting solution sequence
33
33
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
34
- def execute(queryable, options = {}, &block)
34
+ def execute(queryable, **options, &block)
35
35
  @solutions = operands.last.
36
- execute(queryable, options.merge(depth: options[:depth].to_i + 1)).reduced
36
+ execute(queryable, depth: options[:depth].to_i + 1, **options).reduced
37
37
  @solutions.each(&block) if block_given?
38
38
  @solutions
39
39
  end
@@ -26,7 +26,7 @@ module SPARQL; module Algebra
26
26
  # @param [Hash{Symbol => Object}] options
27
27
  # any additional options (see {Operator#initialize})
28
28
  # @raise [TypeError] if any operand is invalid
29
- def initialize(text, pattern, flags = RDF::Literal(''), options = {})
29
+ def initialize(text, pattern, flags = RDF::Literal(''), **options)
30
30
  super
31
31
  end
32
32
 
@@ -27,7 +27,7 @@ module SPARQL; module Algebra
27
27
  # @param [Hash{Symbol => Object}] options
28
28
  # any additional options (see {Operator#initialize})
29
29
  # @raise [TypeError] if any operand is invalid
30
- def initialize(text, pattern, replacement, flags = RDF::Literal(''), options = {})
30
+ def initialize(text, pattern, replacement, flags = RDF::Literal(''), **options)
31
31
  super
32
32
  end
33
33
 
@@ -30,7 +30,7 @@ module SPARQL; module Algebra
30
30
  # @yieldparam [RDF::Query::Solution] solution
31
31
  # @yieldreturn [void] ignored
32
32
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
33
- def execute(queryable, options = {}, &block)
33
+ def execute(queryable, **options, &block)
34
34
  debug(options) {"Reverse #{operands.to_sse}"}
35
35
  subject, object = options[:subject], options[:object]
36
36
 
@@ -42,7 +42,7 @@ module SPARQL; module Algebra
42
42
  else
43
43
  operand(0)
44
44
  end
45
- queryable.query(query, options.merge(
45
+ queryable.query(query, **options.merge(
46
46
  subject: object,
47
47
  object: subject,
48
48
  depth: options[:depth].to_i + 1
@@ -7,8 +7,8 @@ module SPARQL; module Algebra
7
7
  # (prefix ((: <http://www.example.org/>))
8
8
  # (filter (|| (|| (= ?sample 1.0) (= ?sample 2.2)) (= ?sample 3.5))
9
9
  # (project (?sample)
10
- # (extend ((?sample ?.0))
11
- # (group () ((?.0 (sample ?o)))
10
+ # (extend ((?sample ??.0))
11
+ # (group () ((??.0 (sample ?o)))
12
12
  # (bgp (triple ?s :dec ?o)))))))
13
13
  #
14
14
  # @see http://www.w3.org/TR/sparql11-query/#defn_aggSample
@@ -29,12 +29,11 @@ module SPARQL; module Algebra
29
29
  # @yieldparam [RDF::Query::Solution] solution
30
30
  # @yieldreturn [void] ignored
31
31
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
32
- def execute(queryable, options = {}, &block)
32
+ def execute(queryable, **options, &block)
33
33
  subject, object = options[:subject], options[:object]
34
34
  debug(options) {"Seq #{[subject, operands, object].to_sse}"}
35
35
 
36
- v = RDF::Query::Variable.new
37
- v.distinguished = false
36
+ v = RDF::Query::Variable.new(distinguished: false)
38
37
  q1 = if operand(0).is_a?(RDF::Term)
39
38
  RDF::Query.new do |q|
40
39
  q.pattern [subject, operand(0), v]
@@ -50,10 +49,10 @@ module SPARQL; module Algebra
50
49
  operand(1)
51
50
  end
52
51
 
53
- left = queryable.query(q1, options.merge(object: v, depth: options[:depth].to_i + 1))
52
+ left = queryable.query(q1, **options.merge(object: v, depth: options[:depth].to_i + 1))
54
53
  debug(options) {"(seq)=>(left) #{left.map(&:to_h).to_sse}"}
55
54
 
56
- right = queryable.query(q2, options.merge(subject: v, depth: options[:depth].to_i + 1))
55
+ right = queryable.query(q2, **options.merge(subject: v, depth: options[:depth].to_i + 1))
57
56
  debug(options) {"(seq)=>(right) #{right.map(&:to_h).to_sse}"}
58
57
 
59
58
  @solutions = RDF::Query::Solutions(left.map do |s1|
@@ -35,14 +35,14 @@ module SPARQL; module Algebra
35
35
  # @yieldparam [RDF::Query::Solution] solution
36
36
  # @yieldreturn [void] ignored
37
37
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
38
- def execute(queryable, options = {})
38
+ def execute(queryable, **options)
39
39
  debug(options) {"Sequence #{operands.to_sse}"}
40
40
 
41
- last = queryable.query(operands.shift, options.merge(depth: options[:depth].to_i + 1))
41
+ last = queryable.query(operands.shift, depth: options[:depth].to_i + 1, **options)
42
42
  debug(options) {"(sequence)=>(last) #{last.map(&:to_h).to_sse}"}
43
43
 
44
44
  operands.each do |op|
45
- this = queryable.query(op, options.merge(depth: options[:depth].to_i + 1))
45
+ this = queryable.query(op, depth: options[:depth].to_i + 1, **options)
46
46
  debug(options) {"(sequence)=>(this) #{this.map(&:to_h).to_sse}"}
47
47
 
48
48
  last = last.map do |s1|
@@ -43,10 +43,10 @@ module SPARQL; module Algebra
43
43
  # @return [RDF::Query::Solutions]
44
44
  # the resulting solution sequence
45
45
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
46
- def execute(queryable, options = {}, &block)
46
+ def execute(queryable, **options, &block)
47
47
  offset = operands[0] == :_ ? 0 : operands[0].to_i
48
48
  limit = operands[1] == :_ ? -1 : operands[1].to_i
49
- @solutions = operands.last. execute(queryable, options.merge(depth: options[:depth].to_i + 1))
49
+ @solutions = operands.last. execute(queryable, depth: options[:depth].to_i + 1, **options)
50
50
  @solutions.offset(operands[0]) unless operands[0] == :_
51
51
  @solutions.limit(operands[1]) unless operands[1] == :_
52
52
  @solutions.each(&block) if block_given?
@@ -22,7 +22,7 @@ module SPARQL; module Algebra
22
22
  # @param [Hash{Symbol => Object}] options
23
23
  # any additional options (see {Operator#initialize})
24
24
  # @raise [TypeError] if any operand is invalid
25
- def initialize(source, startingLoc, length = RDF::Literal(""), options = {})
25
+ def initialize(source, startingLoc, length = RDF::Literal(""), **options)
26
26
  super
27
27
  end
28
28
 
@@ -6,12 +6,12 @@ module SPARQL; module Algebra
6
6
  # @example
7
7
  # (prefix ((: <http://www.example.org/>))
8
8
  # (project (?sum)
9
- # (extend ((?sum ?.0))
10
- # (group () ((?.0 (sum ?o)))
9
+ # (extend ((?sum ??.0))
10
+ # (group () ((??.0 (sum ?o)))
11
11
  # (bgp (triple ?s :dec ?o))))))
12
12
  #
13
13
  # @see http://www.w3.org/TR/sparql11-query/#defn_aggSum
14
- class Sum < Operator::Unary
14
+ class Sum < Operator
15
15
  include Aggregate
16
16
 
17
17
  NAME = :sum
@@ -23,6 +23,8 @@ module SPARQL; module Algebra
23
23
  # enum of evaluated operand
24
24
  # @return [RDF::Literal::Numeric] The sum of the terms
25
25
  def apply(enum)
26
+ # FIXME: we don't actually do anything with distinct
27
+ operands.shift if distinct = (operands.first == :distinct)
26
28
  if enum.empty?
27
29
  RDF::Literal(0)
28
30
  elsif enum.flatten.all? {|n| n.is_a?(RDF::Literal::Numeric)}
@@ -33,7 +33,7 @@ module SPARQL; module Algebra
33
33
  # @return [RDF::Query::Solutions]
34
34
  # the resulting solution sequence
35
35
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
36
- def execute(queryable, options = {}, &block)
36
+ def execute(queryable, **options, &block)
37
37
  @solutions = RDF::Query::Solutions()
38
38
  Array(operands[1..-1]).each do |row|
39
39
  next unless row.is_a?(Array)
@@ -31,10 +31,10 @@ module SPARQL; module Algebra
31
31
  # @return [RDF::Query::Solutions]
32
32
  # the resulting solution sequence
33
33
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
34
- def execute(queryable, options = {}, &block)
34
+ def execute(queryable, **options, &block)
35
35
  debug(options) {"Union"}
36
36
  @solutions = RDF::Query::Solutions(operands.inject([]) do |memo, op|
37
- solns = op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
37
+ solns = op.execute(queryable, depth: options[:depth].to_i + 1, **options)
38
38
  debug(options) {"=> (op) #{solns.inspect}"}
39
39
  memo + solns
40
40
  end)
@@ -31,11 +31,11 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `queryable` is immutable
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, options = {})
34
+ def execute(queryable, **options)
35
35
  debug(options) {"Update"}
36
36
  raise IOError, "queryable is not mutable" unless queryable.mutable?
37
37
  operands.each do |op|
38
- op.execute(queryable, options.merge(depth: options[:depth].to_i + 1))
38
+ op.execute(queryable, depth: options[:depth].to_i + 1, **options)
39
39
  end
40
40
  queryable
41
41
  end
@@ -31,9 +31,9 @@ module SPARQL; module Algebra
31
31
  # @raise [IOError]
32
32
  # If `from` does not exist, unless the `silent` operator is present
33
33
  # @see http://www.w3.org/TR/sparql11-update/
34
- def execute(queryable, options = {}, &block)
34
+ def execute(queryable, **options, &block)
35
35
  debug(options) {"Using"}
36
- Dataset.new(*operands).execute(queryable, options.merge(depth: options[:depth].to_i + 1), &block)
36
+ Dataset.new(*operands).execute(queryable, depth: options[:depth].to_i + 1, **options, &block)
37
37
  end
38
38
  end # Using
39
39
  end # Operator
@@ -33,7 +33,7 @@ module SPARQL; module Algebra
33
33
  # @raise [IOError]
34
34
  # If `from` does not exist, unless the `silent` operator is present
35
35
  # @see http://www.w3.org/TR/sparql11-update/
36
- def execute(queryable, options = {})
36
+ def execute(queryable, **options)
37
37
  debug(options) {"With: #{operand.to_sse}"}
38
38
  # Bound variable
39
39
  name = operands.shift
@@ -42,7 +42,7 @@ module SPARQL; module Algebra
42
42
  debug(options) {"=> default data source #{name}"}
43
43
  load_opts = {debug: options.fetch(:debug, nil), base_uri: name}
44
44
  debug(options) {"=> load #{name}"}
45
- queryable.load(name.to_s, load_opts)
45
+ queryable.load(name.to_s, **load_opts)
46
46
  end
47
47
 
48
48
  # Set name for RDF::Graph descendants having no graph_name to the name variable
@@ -58,12 +58,12 @@ module SPARQL; module Algebra
58
58
  query = operands.shift
59
59
 
60
60
  # Restrict query portion to this graph
61
- queryable.query(query, options.merge(depth: options[:depth].to_i + 1)) do |solution|
61
+ queryable.query(query, depth: options[:depth].to_i + 1, **options) do |solution|
62
62
  debug(options) {"(solution)=>#{solution.inspect}"}
63
63
 
64
64
  # Execute each operand with queryable and solution
65
65
  operands.each do |op|
66
- op.execute(queryable, solution, options.merge(depth: options[:depth].to_i + 1))
66
+ op.execute(queryable, solutions: solution, depth: options[:depth].to_i + 1, **options)
67
67
  end
68
68
  end
69
69
  end
@@ -50,7 +50,7 @@ module SPARQL; module Algebra
50
50
  # @raise [NotImplementedError]
51
51
  # If an attempt is made to perform an unsupported operation
52
52
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
53
- def execute(queryable, options = {}, &block)
53
+ def execute(queryable, **options, &block)
54
54
  raise NotImplementedError, "#{self.class}#execute(#{queryable})"
55
55
  end
56
56
 
@@ -39,7 +39,7 @@ module SPARQL; module Algebra
39
39
  # @raise [NotImplementedError]
40
40
  # If an attempt is made to perform an unsupported operation
41
41
  # @see http://www.w3.org/TR/sparql11-update/
42
- def execute(queryable, options = {}, &block)
42
+ def execute(queryable, **options, &block)
43
43
  raise NotImplementedError, "#{self.class}#execute(#{queryable})"
44
44
  end
45
45
 
@@ -54,11 +54,11 @@ module RDF::Queryable
54
54
 
55
55
  # Find terms not in self as a subject and recurse with their subjects
56
56
  terms.reject {|term| self.first(subject: term)}.each do |term|
57
- self.query(predicate: term) do |statement|
57
+ self.query({predicate: term}) do |statement|
58
58
  query_terms << statement.subject
59
59
  end
60
60
 
61
- self.query(object: term) do |statement|
61
+ self.query({object: term}) do |statement|
62
62
  query_terms << statement.subject
63
63
  end
64
64
  end
@@ -69,7 +69,7 @@ module RDF::Queryable
69
69
  # Don't consider term if already in graph
70
70
  terms.reject {|term| graph.first(subject: term)}.each do |term|
71
71
  # Find statements from queryiable with term as a subject
72
- self.query(subject: term) do |statement|
72
+ self.query({subject: term}) do |statement|
73
73
  yield(statement) if block_given?
74
74
  graph << statement
75
75
 
@@ -81,7 +81,7 @@ module RDF::Queryable
81
81
  RDF.predicate => statement.predicate,
82
82
  RDF.object => statement.object,
83
83
  }
84
- }).execute(self).each do |solution|
84
+ }, **{}).execute(self).each do |solution|
85
85
  # Recurse to include this subject
86
86
  recurse_opts = options.merge(non_subjects: false, graph: graph)
87
87
  self.concise_bounded_description(solution[:s], recurse_opts, &block)
@@ -175,8 +175,8 @@ module SPARQL
175
175
  # @param [Hash{Symbol => Object}] options
176
176
  # @return [Parser]
177
177
  # @raise [Parser::Error] on invalid input
178
- def self.parse(query, options = {}, &block)
179
- Parser.new(query, options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
178
+ def self.parse(query, **options, &block)
179
+ Parser.new(query, **options).parse(options[:update] ? :UpdateUnit : :QueryUnit)
180
180
  end
181
181
 
182
182
  ##
@@ -190,8 +190,8 @@ module SPARQL
190
190
  # @yieldparam [RDF::Reader] reader
191
191
  # @yieldreturn [void] ignored
192
192
  # @raise [RDF::FormatError] if no reader found for the specified format
193
- def self.open(filename, options = {}, &block)
194
- RDF::Util::File.open_file(filename, options) do |file|
193
+ def self.open(filename, **options, &block)
194
+ RDF::Util::File.open_file(filename, **options) do |file|
195
195
  self.parse(file, options, &block)
196
196
  end
197
197
  end
@@ -206,8 +206,8 @@ module SPARQL
206
206
  # @param [String, #to_s] query
207
207
  # @param [Hash{Symbol => Object}] options
208
208
  # @return [Boolean]
209
- def self.valid?(query, options = {})
210
- Parser.new(query, options).valid?
209
+ def self.valid?(query, **options)
210
+ Parser.new(query, **options).valid?
211
211
  end
212
212
 
213
213
  ##
@@ -225,7 +225,7 @@ module SPARQL
225
225
  # @yieldparam [Lexer] lexer
226
226
  # @return [Lexer]
227
227
  # @raise [Lexer::Error] on invalid input
228
- def self.tokenize(query, options = {}, &block)
228
+ def self.tokenize(query, **options, &block)
229
229
  Lexer.tokenize(query, options, &block)
230
230
  end
231
231
  end # Grammar
@@ -1415,7 +1415,7 @@ module SPARQL::Grammar
1415
1415
  str = lit.delete(:string)
1416
1416
  lit[:datatype] = lit.delete(:iri) if lit[:iri]
1417
1417
  lit[:language] = lit.delete(:language).last.downcase if lit[:language]
1418
- input[:literal] = RDF::Literal.new(str, lit) if str
1418
+ input[:literal] = RDF::Literal.new(str, **lit) if str
1419
1419
  end
1420
1420
  end
1421
1421
 
@@ -1466,7 +1466,7 @@ module SPARQL::Grammar
1466
1466
  # @yieldparam [SPARQL::Grammar::Parser] parser
1467
1467
  # @yieldreturn [void] ignored
1468
1468
  # @return [SPARQL::Grammar::Parser]
1469
- def initialize(input = nil, options = {}, &block)
1469
+ def initialize(input = nil, **options, &block)
1470
1470
  @input = case input
1471
1471
  when IO, StringIO then input.read
1472
1472
  else input.to_s.dup
@@ -1530,10 +1530,13 @@ module SPARQL::Grammar
1530
1530
  # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
1531
1531
  # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
1532
1532
  def parse(prod = START)
1533
- ll1_parse(@input, prod.to_sym, @options.merge(branch: BRANCH,
1534
- first: FIRST,
1535
- follow: FOLLOW,
1536
- whitespace: WS)
1533
+ ll1_parse(@input,
1534
+ prod.to_sym,
1535
+ branch: BRANCH,
1536
+ first: FIRST,
1537
+ follow: FOLLOW,
1538
+ whitespace: WS,
1539
+ **@options
1537
1540
  ) do |context, *data|
1538
1541
  case context
1539
1542
  when :trace
@@ -1718,9 +1721,7 @@ module SPARQL::Grammar
1718
1721
 
1719
1722
  if id
1720
1723
  @vars[id] ||= begin
1721
- v = RDF::Query::Variable.new(id)
1722
- v.distinguished = distinguished
1723
- v
1724
+ RDF::Query::Variable.new(id, distinguished: distinguished)
1724
1725
  end
1725
1726
  else
1726
1727
  unless distinguished
@@ -1728,9 +1729,7 @@ module SPARQL::Grammar
1728
1729
  id = @nd_var_gen
1729
1730
  @nd_var_gen = id.succ
1730
1731
  end
1731
- v = RDF::Query::Variable.new(id)
1732
- v.distinguished = distinguished
1733
- v
1732
+ RDF::Query::Variable.new(id, distinguished: distinguished)
1734
1733
  end
1735
1734
  end
1736
1735
 
@@ -1758,7 +1757,7 @@ module SPARQL::Grammar
1758
1757
  end
1759
1758
 
1760
1759
  # Create a literal
1761
- def literal(value, options = {})
1760
+ def literal(value, **options)
1762
1761
  options = options.dup
1763
1762
  # Internal representation is to not use xsd:string, although it could arguably go the other way.
1764
1763
  options.delete(:datatype) if options[:datatype] == RDF::XSD.string
@@ -1767,7 +1766,7 @@ module SPARQL::Grammar
1767
1766
  "options: #{options.inspect}, " +
1768
1767
  "validate: #{validate?.inspect}, "
1769
1768
  end
1770
- RDF::Literal.new(value, options.merge(validate: validate?))
1769
+ RDF::Literal.new(value, validate: validate?, **options)
1771
1770
  end
1772
1771
 
1773
1772
  # Take collection of objects and create RDF Collection using rdf:first, rdf:rest and rdf:nil
@@ -1798,7 +1797,7 @@ module SPARQL::Grammar
1798
1797
  #
1799
1798
  # @param [String] production Production generating pattern
1800
1799
  # @param [Hash{Symbol => Object}] options
1801
- def add_pattern(production, options)
1800
+ def add_pattern(production, **options)
1802
1801
  progress(production, "[:pattern, #{options[:subject]}, #{options[:predicate]}, #{options[:object]}]")
1803
1802
  triple = {}
1804
1803
  options.each_pair do |r, v|
@@ -1880,8 +1879,7 @@ module SPARQL::Grammar
1880
1879
  avf.first
1881
1880
  else
1882
1881
  # Allocate a temporary variable for this function, and retain the mapping for outside the group
1883
- av = RDF::Query::Variable.new(".#{agg}")
1884
- av.distinguished = false
1882
+ av = RDF::Query::Variable.new(".#{agg}", distinguished: false)
1885
1883
  agg += 1
1886
1884
  aggregates << [av, function]
1887
1885
  av
@@ -185,7 +185,7 @@ module SPARQL
185
185
  # @return [String]
186
186
  # String with serialized results and `#content_type`
187
187
  # @raise [RDF::WriterError] when inappropriate formatting options are used
188
- def serialize_results(solutions, options = {})
188
+ def serialize_results(solutions, **options)
189
189
  format = options[:format].to_sym if options[:format]
190
190
  content_type = options[:content_type].to_s.split(';').first
191
191
  content_types = Array(options[:content_types] || '*/*')
@@ -236,7 +236,7 @@ module SPARQL
236
236
  end
237
237
  format ||= fmt.to_sym
238
238
  content_type ||= fmt.content_type.first
239
- results = solutions.dump(format, options)
239
+ results = solutions.dump(format, **options)
240
240
  raise RDF::WriterError, "Unknown format #{fmt.inspect} for #{solutions.class}" unless results
241
241
  results
242
242
  when RDF::Query::Solutions
@@ -306,7 +306,7 @@ module SPARQL
306
306
  # May also be an RDF::Writer content_type to serialize DESCRIBE or CONSTRUCT results
307
307
  # @return [String]
308
308
  # String with serialized results and #content_type
309
- def serialize_exception(exception, options = {})
309
+ def serialize_exception(exception, **options)
310
310
  format = options[:format]
311
311
  content_type = options[:content_type]
312
312
  content_type ||= SPARQL::Results::MIME_TYPES[format]