Updates for Ruby 2.7 compatibility.

Author: gkellogg

.travis.yml

@@ -13,5 +13,4 @@ sudo: false
 matrix:
   allow_failures:
     - rvm: jruby
-    - rvm: 2.7
 dist: trusty

Gemfile

@@ -5,7 +5,8 @@ gemspec
 group :develop do
   gem 'rdf-isomorphic', git: "https://github.com/ruby-rdf/rdf-isomorphic",  branch: "develop"
   gem "rdf-reasoner",   git: "https://github.com/ruby-rdf/rdf-reasoner",    branch: "develop"
-  gem "rdf-spec",       git: "https://github.com/ruby-rdf/rdf-spec",        branch: "develop"
+  gem 'rdf-spec', path: '../rdf-spec'
+  #gem "rdf-spec",       git: "https://github.com/ruby-rdf/rdf-spec",        branch: "develop"
   gem "rdf-turtle",     git: "https://github.com/ruby-rdf/rdf-turtle",      branch: "develop"
   gem "rdf-vocab",      git: "https://github.com/ruby-rdf/rdf-vocab",       branch: "develop"
   gem "rdf-xsd",        git: "https://github.com/ruby-rdf/rdf-xsd",         branch: "develop"

README.md

@@ -30,6 +30,7 @@ This is a pure-Ruby library for working with [Resource Description Framework
 * Based entirely on Ruby's autoloading, meaning that you can generally make
   use of any one part of the library without needing to load up the rest.
 * Compatible with Ruby Ruby >= 2.4, Rubinius and JRuby 9.0+.
+  * Note, changes in mapping hashes to keyword arguments for Ruby 2.7+ may require that arguments be passed more explicitly, especially when the first argument is a Hash and there are optional keyword arguments. In this case, Hash argument may need to be explicitly included within `{}` and the optional keyword arguments may need to be specified using `**{}` if there are no keyword arguments.
 * Performs auto-detection of input to select appropriate Reader class if one
   cannot be determined from file characteristics.
 
@@ -189,7 +190,7 @@ Note that no prefixes are loaded automatically, however they can be provided as
         FOAF.name => :name,
         FOAF.mbox => :email,
       }
-    })
+    }, **{})
 
     query.execute(graph) do |solution|
       puts "name=#{solution.name} email=#{solution.email}"

examples/query_bench.rb

@@ -6,9 +6,9 @@
 require 'rdf/ntriples'
 graph = RDF::Graph.load("etc/doap.nt")
 
-puts graph.query(predicate: RDF::Vocab::FOAF.name).is_a?(RDF::Queryable)
+puts graph.query({predicate: RDF::Vocab::FOAF.name}).is_a?(RDF::Queryable)
 
 Benchmark.ips do |x|
   x.config(:time => 10, :warmup => 5)
-  x.report('query_pattern') { graph.query(predicate: RDF::Vocab::FOAF.name) {} }
+  x.report('query_pattern') { graph.query({predicate: RDF::Vocab::FOAF.name}) {} }
 end

lib/rdf/format.rb

@@ -145,10 +145,10 @@ def self.each(file_name: nil,
     #   @param  [String, RDF::URI] filename
     #   @return [Class]
     #
-    # @overload for(**options)
+    # @overload for(options)
     #   Finds an RDF serialization format class based on various options.
     #
-    #   @param  [Hash{Symbol => Object}] options
+    #   @param  [Hash{Symbol => Object}] options ({})
     #   @option options [String, #to_s]   :file_name      (nil)
     #   @option options [Symbol, #to_sym] :file_extension (nil)
     #   @option options [String, #to_s]   :content_type   (nil)
@@ -164,19 +164,26 @@ def self.each(file_name: nil,
     #   @yieldreturn [String] another way to provide a sample, allows lazy for retrieving the sample.
     #
     # @return [Class]
-    def self.for(*args, **options, &block)
+    def self.for(*arg, &block)
+      case arg.length
+      when 0 then arg = nil
+      when 1 then arg = arg.first
+      else
+        raise ArgumentError, "Format.for accepts zero or one argument, got #{arg.length}."
+      end
+
+      options =  arg.is_a?(Hash) ? arg : {}
       options = {sample: block}.merge(options) if block_given?
-      formats = case args.first
+      formats = case arg
       when String, RDF::URI
         # Find a format based on the file name
-        self.each(file_name: args.first, **options).to_a
+        self.each(file_name: arg, **options).to_a
       when Symbol
         # Try to find a match based on the full class name
         # We want this to work even if autoloading fails
-        fmt = args.first
-        classes = self.each(**options).select {|f| f.symbols.include?(fmt)}
+        classes = self.each(**options).select {|f| f.symbols.include?(arg)}
         if classes.empty?
-          classes = case fmt
+          classes = case arg
           when :ntriples then [RDF::NTriples::Format]
           when :nquads   then [RDF::NQuads::Format]
           else                []

lib/rdf/mixin/queryable.rb

@@ -19,7 +19,7 @@ module Queryable
     #
     # @example Querying for statements having a given predicate
     #     queryable.query([nil, RDF::Vocab::DOAP.developer, nil])
-    #     queryable.query(predicate: RDF::Vocab::DOAP.developer) do |statement|
+    #     queryable.query({predicate: RDF::Vocab::DOAP.developer}) do |statement|
     #       puts statement.inspect
     #     end
     #
@@ -116,7 +116,7 @@ def query_execute(query, **options, &block)
       # query execution by breaking down the query into its constituent
       # triple patterns and invoking `RDF::Query::Pattern#execute` on each
       # pattern.
-      query.execute(self, options, &block)
+      query.execute(self, **options, &block)
     end
     protected :query_execute
 

lib/rdf/model/graph.rb

@@ -211,7 +211,7 @@ def anonymous?
     # @return [Integer]
     # @see    RDF::Enumerable#count
     def count
-      @data.query(graph_name: graph_name || false).count
+      @data.query({graph_name: graph_name || false}).count
     end
 
     ##
@@ -237,7 +237,7 @@ def has_statement?(statement)
     # @see    RDF::Enumerable#each_statement
     def each(&block)
       if @data.respond_to?(:query)
-        @data.query(graph_name: graph_name || false, &block)
+        @data.query({graph_name: graph_name || false}, &block)
       elsif @data.respond_to?(:each)
         @data.each(&block)
       else

lib/rdf/model/list.rb

@@ -59,7 +59,7 @@ def self.[](*values)
     def initialize(subject: nil, graph: nil, values: nil, &block)
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
-      is_empty = @graph.query(subject: subject, predicate: RDF.first).empty?
+      is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?
 
       if subject && is_empty
         # An empty list with explicit subject and value initializers
@@ -115,7 +115,7 @@ def valid?
         list_nodes << li
         rest = nil
         firsts = rests = 0
-        @graph.query(subject: li) do |st|
+        @graph.query({subject: li}) do |st|
           return false unless st.subject.node?
           case st.predicate
           when RDF.first
@@ -136,7 +136,7 @@ def valid?
 
       # All elements other than the head must be referenced exactly once
       return list_nodes.all? do |li|
-        refs = @graph.query(object: li).count
+        refs = @graph.query({object: li}).count
         case refs
         when 0 then li == subject
         when 1 then true
@@ -479,7 +479,7 @@ def <=>(other)
     # @return [Boolean]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-empty-3F
     def empty?
-      graph.query(subject: subject, predicate: RDF.first).empty?
+      graph.query({subject: subject, predicate: RDF.first}).empty?
     end
 
     ##
@@ -822,7 +822,7 @@ def each_statement(&block)
       return enum_statement unless block_given?
 
       each_subject do |subject|
-        graph.query(subject: subject, &block)
+        graph.query({subject: subject}, &block)
       end
     end
     alias_method :to_rdf, :each_statement

lib/rdf/query.rb

@@ -134,6 +134,12 @@ def self.Solutions(*args)
     # @return [Hash]
     attr_reader :options
 
+    ##
+    # Scope the query to named graphs matching value
+    #
+    # @return [RDF::Resource, RDF::Query::Variable, false] graph_name
+    attr_accessor :graph_name
+
     ##
     # Initializes a new basic graph pattern query.
     #
@@ -180,6 +186,7 @@ def initialize(*patterns, solutions: nil, graph_name: nil, name: nil, validate:
       @options = options.dup
       @solutions = Query::Solutions(solutions)
       graph_name = name if graph_name.nil?
+      @graph_name = graph_name
 
       patterns << @options if patterns.empty?
 
@@ -189,8 +196,6 @@ def initialize(*patterns, solutions: nil, graph_name: nil, name: nil, validate:
         else patterns
       end
 
-      self.graph_name = graph_name
-
       if block_given?
         case block.arity
           when 1 then block.call(self)
@@ -223,7 +228,7 @@ def <<(pattern)
     #   whether this is an optional pattern
     # @return [void] self
     def pattern(pattern, **options)
-      @patterns << Pattern.from(pattern, options)
+      @patterns << Pattern.from(pattern, **options)
       self
     end
 
@@ -235,7 +240,7 @@ def pattern(pattern, **options)
     # @return [RDF::Query] a copy of `self`
     # @since  0.3.0
     def optimize(**options)
-      self.dup.optimize!(options)
+      self.dup.optimize!(**options)
     end
 
     ##
@@ -294,9 +299,7 @@ def optimize!(**options)
     #   the resulting solution sequence
     # @see    http://www.holygoat.co.uk/blog/entry/2005-10-25-1
     # @see    http://www.w3.org/TR/sparql11-query/#emptyGroupPattern
-    def execute(queryable, solutions: Solution.new, graph_name: nil, name: nil, **options, &block)
-      options = {bindings: {}}.merge(options)
-
+    def execute(queryable, bindings: {}, solutions: Solution.new, graph_name: nil, name: nil, **options, &block)
       # Use provided solutions to allow for query chaining
       # Otherwise, a quick empty solution simplifies the logic below; no special case for
       # the first pattern
@@ -310,31 +313,30 @@ def execute(queryable, solutions: Solution.new, graph_name: nil, name: nil, **op
 
       patterns = @patterns
       graph_name = name if graph_name.nil?
-      graph_name = self.graph_name if graph_name.nil?
-      options[:graph_name] = graph_name unless graph_name.nil?
+      @graph_name = graph_name unless graph_name.nil?
 
       # Add graph_name to pattern, if necessary
-      unless graph_name.nil?
+      unless @graph_name.nil?
         if patterns.empty?
-          patterns = [Pattern.new(nil, nil, nil, graph_name: graph_name)]
+          patterns = [Pattern.new(nil, nil, nil, graph_name: @graph_name)]
         else
-          apply_graph_name(graph_name)
+          apply_graph_name(@graph_name)
         end
       end
 
       patterns.each do |pattern|
 
         old_solutions, @solutions = @solutions, Query::Solutions()
 
-        options[:bindings].each_key do |variable|
+        bindings.each_key do |variable|
           if pattern.variables.include?(variable)
             unbound_solutions, old_solutions = old_solutions, Query::Solutions()
-            options[:bindings][variable].each do |binding|
+            bindings[variable].each do |binding|
               unbound_solutions.each do |solution|
                 old_solutions << solution.merge(variable => binding)
               end
             end
-            options[:bindings].delete(variable)
+            bindings.delete(variable)
           end
         end
 
@@ -407,38 +409,26 @@ def +(other)
     # Is this query scoped to a named graph?
     # @return [Boolean]
     def named?
-      !!options[:graph_name]
+      !!graph_name
     end
 
     # Is this query scoped to the default graph?
     # @return [Boolean]
     def default?
-      options[:graph_name] == false
+      graph_name == false
     end
 
     # Is this query unscoped? This indicates that it can return results from
     # either a named graph or the default graph.
     # @return [Boolean]
     def unnamed?
-      options[:graph_name].nil?
-    end
-
-    # Scope the query to named graphs matching value
-    # @param [RDF::IRI, RDF::Query::Variable] value
-    # @return [RDF::IRI, RDF::Query::Variable]
-    def graph_name=(value)
-      options[:graph_name] = value
-    end
-
-    # Scope of this query, if any
-    # @return [RDF::IRI, RDF::Query::Variable]
-    def graph_name
-      options[:graph_name]
+      graph_name.nil?
     end
 
     # Apply the graph name specified (or configured) to all patterns that have no graph name
     # @param [RDF::IRI, RDF::Query::Variable] graph_name (self.graph_name)
-    def apply_graph_name(graph_name = options[:graph_name])
+    def apply_graph_name(graph_name = nil)
+      graph_name ||= self.graph_name
       patterns.each {|pattern| pattern.graph_name = graph_name if pattern.graph_name.nil?} unless graph_name.nil?
     end
 
@@ -515,8 +505,7 @@ def each_statement(&block)
     # @return [RDF::Query]
     def dup
       patterns = @patterns.map {|p| p.dup}
-      patterns << @options.merge(solutions: @solutions.dup)
-      Query.new(*patterns)
+      Query.new(patterns, solutions: @solutions.dup, **options)
     end
 
     ##

lib/rdf/query/hash_pattern_normalizer.rb

@@ -85,13 +85,14 @@ class << self
       #   the string format for anonymous subjects.
       # @return [Hash{Symbol => Object}]
       #   the resulting query pattern as a normalized hash.
-      def normalize!(hash_pattern = {}, options = {})
+      def normalize!(*args)
+        hash_pattern = args.shift
+        options = args.shift || {}
+        anonymous_subject_format = options.fetch(:anonymous_subject_format, '__%s__')
         raise ArgumentError, "invalid hash pattern: #{hash_pattern.inspect}" unless hash_pattern.is_a?(Hash)
 
         counter = RDF::Query::HashPatternNormalizer::Counter.new
 
-        anonymous_subject_format = (options[:anonymous_subject_format] || '__%s__').to_s
-        
         hash_pattern.inject({}) { |acc, pair|
           subject, predicate_to_object = pair
 
@@ -184,7 +185,7 @@ def initialize(**options)
     #   the query pattern as a hash.
     # @return [Hash{Symbol => Object}]
     #   the resulting query pattern as a normalized hash.
-    def normalize!(**hash_pattern)
+    def normalize!(hash_pattern)
       self.class.normalize!(hash_pattern, @options)
     end
   end # RDF::Query::HashPatternNormalizer