rdf 3.0.13 → 3.1.4

data/lib/rdf/query/hash_pattern_normalizer.rb

@@ -77,21 +77,23 @@ module RDF; class Query
       ##
       # Returns the normalization of the specified `hash_pattern`.
       #
-      # @param [Hash{Symbol => Object}] hash_pattern (Hash.new)
-      #   the query pattern as a hash.
-      # @param [Hash{Symbol => Object}] options (Hash.new)
-      #   any additional normalization options.
-      # @option options [String] :anonymous_subject_format ("__%s__")
-      #   the string format for anonymous subjects.
-      # @return [Hash{Symbol => Object}]
-      #   the resulting query pattern as a normalized hash.
-      def normalize!(hash_pattern = {}, options = {})
+      # @overload normalize!(hash_pattern, **options)
+      #   @param [Hash{Symbol => Object}] hash_pattern (Hash.new)
+      #     the query pattern as a hash.
+      #   @param [Hash{Symbol => Object}] **options
+      #     any additional normalization options.
+      #   @option options [String] :anonymous_subject_format ("__%s__")
+      #     the string format for anonymous subjects.
+      #   @return [Hash{Symbol => Object}]
+      #     the resulting query pattern as a normalized hash.
+      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 +186,7 @@ module RDF; class Query
     #   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

data/lib/rdf/query/pattern.rb

@@ -17,7 +17,7 @@ module RDF; class Query
     end
 
     ##
-    # @overload initialize(**options)
+    # @overload initialize(options = {})
     #   @param  [Hash{Symbol => Object}]     options
     #   @option options [Variable, Resource, Symbol, nil] :subject   (nil)
     #   @option options [Variable, URI, Symbol, nil]      :predicate (nil)
@@ -26,7 +26,7 @@ module RDF; class Query
     #     A graph_name of nil matches any graph, a graph_name of false, matches only the default graph.
     #   @option options [Boolean]            :optional  (false)
     #
-    # @overload initialize(subject, predicate, object, **options)
+    # @overload initialize(subject, predicate, object, options = {})
     #   @param  [Variable, Resource, Symbol, nil]         subject
     #   @param  [Variable, URI, Symbol, nil]              predicate
     #   @param  [Variable, Termm, Symbol, nil]            object
@@ -50,10 +50,12 @@ module RDF; class Query
 
       # Estmate cost positionally, with variables being least expensive as objects, then predicates, then subjects, then graph_names.
       # XXX does not consider bound variables, which would need to be dynamically calculated.
-      @cost = (@object.nil?     || @object.is_a?(Variable)      ? 1 : 0) +
-              (@predicate.nil?  || @predicate.is_a?(Variable)   ? 2 : 0) +
-              (@subject.nil?    || @subject.is_a?(Variable)     ? 4 : 0) +
-              (@graph_name.is_a?(Variable)                      ? 8 : 0)
+      @cost = (@object.nil?     || @object.is_a?(Variable)      ? 8 : 0) +
+              (@predicate.nil?  || @predicate.is_a?(Variable)   ? 4 : 0) +
+              (@subject.nil?    || @subject.is_a?(Variable)     ? 2 : 0) +
+              (@graph_name.is_a?(Variable)                      ? 1 : 0) +
+              (@object.is_a?(Pattern)                           ? (@object.cost * 4) : 0) +
+              (@subject.is_a?(Pattern)                          ? (@subject.cost * 2) : 0)
       super
     end
 
@@ -84,10 +86,10 @@ module RDF; class Query
     # @return [Boolean] `true` or `false`
     # @since  0.3.0
     def has_variables?
-      subject.is_a?(Variable) ||
-        predicate.is_a?(Variable) ||
-        object.is_a?(Variable) ||
-        graph_name.is_a?(Variable)
+      subject    && subject.variable? ||
+      predicate  && predicate.variable? ||
+      object     && object.variable? ||
+      graph_name && graph_name.variable?
     end
     alias_method :variables?, :has_variables?
 
@@ -117,13 +119,33 @@ module RDF; class Query
       false
     end
 
+    ##
+    # Checks pattern equality against a statement, considering nesting.
+    #
+    # * A pattern which has a pattern as a subject or an object, matches
+    #   a statement having a statement as a subject or an object using {#eql?}.
+    #
+    # @param  [Statement] other
+    # @return [Boolean]
+    #
+    # @see RDF::URI#==
+    # @see RDF::Node#==
+    # @see RDF::Literal#==
+    # @see RDF::Query::Variable#==
+    def eql?(other)
+      return false unless other.is_a?(Statement) && (self.graph_name || false) == (other.graph_name || false)
+
+      predicate == other.predicate &&
+      (subject.is_a?(Pattern) ? subject.eql?(other.subject) : subject == other.subject) &&
+      (object.is_a?(Pattern) ? object.eql?(other.object) : object == other.object)
+    end
+
     ##
     # Executes this query pattern on the given `queryable` object.
     #
     # Values are matched using using Queryable#query_pattern.
     #
-    # If the optional `bindings` are given, variables will be substituted with their values
-    # when executing the query.
+    # If the optional `bindings` are given, variables will be substituted with their values when executing the query.
     #
     # To match triples only in the default graph, set graph_name to `false`.
     #
@@ -198,6 +220,8 @@ module RDF; class Query
         solution[predicate.to_sym]  = statement.predicate  if predicate.is_a?(Variable)
         solution[object.to_sym]     = statement.object     if object.is_a?(Variable)
         solution[graph_name.to_sym] = statement.graph_name if graph_name.is_a?(Variable)
+        solution.merge!(subject.solution(statement.subject)) if subject.is_a?(Pattern)
+        solution.merge!(object.solution(statement.object)) if object.is_a?(Pattern)
       end
     end
 
@@ -229,7 +253,8 @@ module RDF; class Query
     # @return [Integer] (0..3)
     def variable_count
       [subject, predicate, object, graph_name].inject(0) do |memo, term|
-        memo += (term.is_a?(Variable) ? 1 : 0)
+        memo += (term.is_a?(Variable) ? 1 :
+                 (term.is_a?(Pattern) ? term.variable_count : 0))
       end
     end
     alias_method :cardinality, :variable_count
@@ -243,7 +268,7 @@ module RDF; class Query
     # @return [Hash{Symbol => Variable}]
     def variables
       [subject, predicate, object, graph_name].inject({}) do |memo, term|
-        term.is_a?(Variable) ? memo.merge(term.variables) : memo
+        term && term.variable? ? memo.merge(term.variables) : memo
       end
     end
 
@@ -254,8 +279,10 @@ module RDF; class Query
     # @return [self]
     def bind(solution)
       self.to_quad.each_with_index do |term, index|
-        if term && term.variable? && solution[term]
+        if term.is_a?(Variable) && solution[term]
           self[index] = solution[term] 
+        elsif term.is_a?(Pattern)
+          term.bind(solution)
         end
       end
       self
@@ -283,9 +310,9 @@ module RDF; class Query
     # @return [Hash{Symbol => RDF::Term}]
     def bindings
       bindings = {}
-      bindings.merge!(subject.bindings)    if subject.is_a?(Variable)
+      bindings.merge!(subject.bindings)    if subject && subject.variable?
       bindings.merge!(predicate.bindings)  if predicate.is_a?(Variable)
-      bindings.merge!(object.bindings)     if object.is_a?(Variable)
+      bindings.merge!(object.bindings)     if object && object.variable?
       bindings.merge!(graph_name.bindings) if graph_name.is_a?(Variable)
       bindings
     end
@@ -330,7 +357,13 @@ module RDF; class Query
       StringIO.open do |buffer| # FIXME in RDF::Statement
         buffer << 'OPTIONAL ' if optional?
         buffer << [subject, predicate, object].map do |r|
-          r.is_a?(RDF::Query::Variable) ? r.to_s : RDF::NTriples.serialize(r)
+          if r.is_a?(RDF::Query::Variable)
+            r.to_s
+          elsif r.is_a?(RDF::Query::Pattern)
+            "<<#{r.to_s[0..-3]}>>"
+          else
+            RDF::NTriples.serialize(r)
+          end
         end.join(" ")
         buffer << case graph_name
           when nil, false then " ."

data/lib/rdf/query/solution.rb

@@ -195,12 +195,31 @@ class RDF::Query
     # Merges the bindings from the given `other` query solution into this
     # one, overwriting any existing ones having the same name.
     #
+    # ## RDFStar (RDF*)
+    #
+    # If merging a binding for a statement to a pattern,
+    # merge their embedded solutions.
+    #
     # @param  [RDF::Query::Solution, #to_h] other
     #   another query solution or hash bindings
     # @return [void] self
     # @since  0.3.0
     def merge!(other)
-      @bindings.merge!(other.to_h)
+      @bindings.merge!(other.to_h) do |key, v1, v2|
+        # Don't merge a pattern over a statement
+        # This happens because JOIN does a reverse merge,
+        # and a pattern is set in v2.
+        v2.is_a?(Pattern) ? v1 : v2
+      end
+      # Merge bindings from patterns
+      embedded_solutions = []
+      @bindings.each do |k, v|
+        if v.is_a?(Pattern) && other[k].is_a?(RDF::Statement)
+          embedded_solutions << v.solution(other[k])
+        end
+      end
+      # Merge embedded solutions
+      embedded_solutions.each {|soln| merge!(soln)}
       self
     end
 

data/lib/rdf/query/solutions.rb

@@ -66,13 +66,15 @@ module RDF; class Query
     #
     # @return [Array<Symbol>]
     def variable_names
-      variables = self.inject({}) do |result, solution|
-        solution.each_name do |name|
-          result[name] ||= true
+      @variable_names ||= begin
+        variables = self.inject({}) do |result, solution|
+          solution.each_name do |name|
+            result[name] ||= true
+          end
+          result
         end
-        result
+        variables.keys
       end
-      variables.keys
     end
 
     ##
@@ -136,6 +138,7 @@ module RDF; class Query
     # @yieldreturn [Boolean]
     # @return [self]
     def filter(criteria = {})
+      @variable_names = nil
       if block_given?
         self.reject! do |solution|
           !yield(solution.is_a?(Solution) ? solution : Solution.new(solution))
@@ -223,6 +226,13 @@ module RDF; class Query
           solution.bindings.delete_if { |k, v| !variables.include?(k.to_sym) }
         end
       end
+
+      # Make sure variable_names are ordered by projected variables
+      projected_vars, vars = variables.map(&:to_sym), variable_names
+      vars = variable_names
+
+      # Maintain projected order, and add any non-projected variables
+      @variable_names = (projected_vars & vars) + (vars - projected_vars)
       self
     end
     alias_method :select, :project

data/lib/rdf/query/variable.rb

@@ -157,12 +157,24 @@ class RDF::Query
     ##
     # Rebinds this variable to the given `value`.
     #
-    # @param  [RDF::Term] value
-    # @return [RDF::Term] the previous value, if any.
+    # @overload bind(value)
+    #   @param [RDF::Query::Solution] value
+    #   @return [self] the bound variable
+    #
+    # @overload bind(value)
+    #   @param [RDF::Term] value
+    #   @return [RDF::Term] the previous value, if any.
     def bind(value)
-      old_value = self.value
-      self.value = value
-      old_value
+      if value.is_a?(RDF::Query::Solution)
+        self.value = value.to_h.fetch(name, self.value)
+        self
+      else
+        warn "[DEPRECATION] RDF::Query::Variable#bind should be used with a solution, not a term.\n" +
+             "Called from #{Gem.location_of_caller.join(':')}"
+        old_value = self.value
+        self.value = value
+        old_value
+      end
     end
     alias_method :bind!, :bind
 

data/lib/rdf/reader.rb

@@ -88,9 +88,15 @@ module RDF
     #   @yieldreturn [String] another way to provide a sample, allows lazy for retrieving the sample.
     #
     # @return [Class]
-    def self.for(options = {}, &block)
-      options = options.merge(has_reader: true) if options.is_a?(Hash)
-      if format = self.format || Format.for(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
+      arg = arg.merge(has_reader: true) if arg.is_a?(Hash)
+      if format = self.format || Format.for(arg, &block)
         format.reader
       end
     end
@@ -115,6 +121,12 @@ module RDF
     # @return [Array<RDF::CLI::Option>]
     def self.options
       [
+        RDF::CLI::Option.new(
+          symbol: :base_uri,
+          control: :url,
+          datatype: RDF::URI,
+          on: ["--uri URI"],
+          description: "Base URI of input file, defaults to the filename.") {|arg| RDF::URI(arg)},
         RDF::CLI::Option.new(
           symbol: :canonicalize,
           datatype: TrueClass,
@@ -147,11 +159,11 @@ module RDF
             end
         end,
         RDF::CLI::Option.new(
-          symbol: :base_uri,
-          control: :url,
-          datatype: RDF::URI,
-          on: ["--uri URI"],
-          description: "Base URI of input file, defaults to the filename.") {|arg| RDF::URI(arg)},
+          symbol: :rdfstar,
+          control: :select,
+          datatype: [:PG, :SA],
+          on: ["--rdf-star MODE"],
+          description: "Parse RDF*, either in Property Graph mode (PG) or Separate Assertions mode (SA).") {|arg| arg.to_sym},
         RDF::CLI::Option.new(
           symbol: :validate,
           datatype: TrueClass,
@@ -206,7 +218,7 @@ module RDF
         headers['Accept'] ||= (self.format.accept_type + %w(*/*;q=0.1)).join(", ")
       end
 
-      Util::File.open_file(filename, options) do |file|
+      Util::File.open_file(filename, **options) do |file|
         format_options = options.dup
         format_options[:content_type] ||= file.content_type if
           file.respond_to?(:content_type) &&
@@ -229,7 +241,7 @@ module RDF
         options[:filename] ||= filename
 
         if reader
-          reader.new(file, options, &block)
+          reader.new(file, **options, &block)
         else
           raise FormatError, "unknown RDF format: #{format_options.inspect}#{"\nThis may be resolved with a require of the 'linkeddata' gem." unless Object.const_defined?(:LinkedData)}"
         end
@@ -255,42 +267,48 @@ module RDF
     #
     # @param  [IO, File, String] input
     #   the input stream to read
-    # @param [Encoding] encoding     (Encoding::UTF_8)
-    #   the encoding of the input stream
-    # @param [Boolean]  validate     (false)
-    #   whether to validate the parsed statements and values
+    # @param [#to_s]    base_uri     (nil)
+    #   the base URI to use when resolving relative URIs (not supported by
+    #   all readers)
     # @param [Boolean]  canonicalize (false)
     #   whether to canonicalize parsed literals
+    # @param [Encoding] encoding     (Encoding::UTF_8)
+    #   the encoding of the input stream
     # @param [Boolean]  intern       (true)
     #   whether to intern all parsed URIs
+    # @param [:PG, :SA] rdfstar      (nil)
+    #   support parsing RDF* statement resources.
+    #   If `:PG`, referenced statements are also emitted.
+    #   If `:SA`, referenced statements are not emitted.
     # @param [Hash]     prefixes     (Hash.new)
     #   the prefix mappings to use (not supported by all readers)
-    # @param [#to_s]    base_uri     (nil)
-    #   the base URI to use when resolving relative URIs (not supported by
-    #   all readers)
     # @param  [Hash{Symbol => Object}] options
     #   any additional options
+    # @param [Boolean]  validate     (false)
+    #   whether to validate the parsed statements and values
     # @yield  [reader] `self`
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
     def initialize(input = $stdin,
-                   encoding:      Encoding::UTF_8,
-                   validate:      false,
+                   base_uri:      nil,
                    canonicalize:  false,
+                   encoding:      Encoding::UTF_8,
                    intern:        true,
                    prefixes:      Hash.new,
-                   base_uri:      nil,
+                   rdfstar:       nil,
+                   validate:      false,
                    **options,
                    &block)
 
       base_uri     ||= input.base_uri if input.respond_to?(:base_uri)
       @options = options.merge({
-        encoding:       encoding,
-        validate:       validate,
+        base_uri:       base_uri,
         canonicalize:   canonicalize,
+        encoding:       encoding,
         intern:         intern,
         prefixes:       prefixes,
-        base_uri:       base_uri
+        rdfstar:        rdfstar,
+        validate:       validate
       })
 
       @input = case input
@@ -383,6 +401,9 @@ module RDF
     # Statements are yielded in the order that they are read from the input
     # stream.
     #
+    # If the `rdfstar` option is `:PG` and triples include
+    # embedded statements, they are also enumerated.
+    #
     # @overload each_statement
     #   @yield  [statement]
     #     each statement
@@ -399,7 +420,11 @@ module RDF
     def each_statement(&block)
       if block_given?
         begin
-          loop { block.call(read_statement) }
+          loop do
+            st = read_statement
+            block.call(st)
+            each_pg_statement(st, &block) if options[:rdfstar] == :PG
+          end
         rescue EOFError
           rewind rescue nil
         end
@@ -416,6 +441,9 @@ module RDF
     # Triples are yielded in the order that they are read from the input
     # stream.
     #
+    # If the `rdfstar` option is `:PG` and triples include
+    # embedded statements, they are also enumerated.
+    #
     # @overload each_triple
     #   @yield  [subject, predicate, object]
     #     each triple
@@ -433,7 +461,14 @@ module RDF
     def each_triple(&block)
       if block_given?
         begin
-          loop { block.call(*read_triple) }
+          loop do
+            triple = read_triple
+            block.call(*triple)
+            if options[:rdfstar] == :PG
+              block.call(*triple[0].to_a) if triple[0].is_a?(Statement)
+              block.call(*triple[2].to_a) if triple[2].is_a?(Statement)
+            end
+          end
         rescue EOFError
           rewind rescue nil
         end
@@ -544,6 +579,22 @@ module RDF
       log_error("Expected object (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
     end
 
+    ##
+    # Recursively emit embedded statements in Property Graph mode
+    #
+    # @param [RDF::Statement] statement
+    def each_pg_statement(statement, &block)
+      if statement.subject.is_a?(Statement)
+        block.call(statement.subject)
+        each_pg_statement(statement.subject, &block)
+      end
+
+      if statement.object.is_a?(Statement)
+        block.call(statement.object)
+        each_pg_statement(statement.object, &block)
+      end
+    end
+
   public
     ##
     # Returns the encoding of the input stream.