rdf 3.0.11 → 3.1.2

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.

data/lib/rdf/repository.rb

@@ -119,9 +119,9 @@ module RDF
     # @yieldparam [Repository]
     # @return [void]
     def self.load(urls, **options, &block)
-      self.new(options) do |repository|
+      self.new(**options) do |repository|
         Array(urls).each do |url|
-          repository.load(url, options)
+          repository.load(url, **options)
         end
 
         if block_given?
@@ -182,6 +182,7 @@ module RDF
       when :validity         then @options.fetch(:with_validity, true)
       when :literal_equality then true
       when :atomic_write     then false
+      when :rdfstar          then false
       when :snapshots        then false
       else false
       end
@@ -266,6 +267,7 @@ module RDF
         when :validity         then @options.fetch(:with_validity, true)
         when :literal_equality then true
         when :atomic_write     then true
+        when :rdfstar          then true
         when :snapshots        then true
         else false
         end
@@ -340,7 +342,14 @@ module RDF
       # @see Mutable#apply_changeset
       def apply_changeset(changeset)
         data = @data
-        changeset.deletes.each { |del| data = delete_from(data, del) }
+        changeset.deletes.each do |del|
+          if del.constant?
+            data = delete_from(data, del)
+          else
+            # we need this condition to handle wildcard statements
+            query_pattern(del) { |stmt| data = delete_from(data, stmt) }
+          end
+        end
         changeset.inserts.each { |ins| data = insert_to(data, ins) }
         @data = data
       end
@@ -388,20 +397,25 @@ module RDF
                         graph_name.eql?(c)
 
             ss = if subject.nil? || subject.is_a?(RDF::Query::Variable)
-                   ss
-                 elsif ss.has_key?(subject)
-                   { subject => ss[subject] }
-                 else
-                   []
-                 end
+              ss
+            elsif subject.is_a?(RDF::Query::Pattern)
+              # Match subjects which are statements matching this pattern
+              ss.keys.select {|s| s.statement? && subject.eql?(s)}.inject({}) do |memo, st|
+                memo.merge(st => ss[st])
+              end
+            elsif ss.has_key?(subject)
+              { subject => ss[subject] }
+            else
+              []
+            end
             ss.each do |s, ps|
               ps = if predicate.nil? || predicate.is_a?(RDF::Query::Variable)
-                     ps
-                   elsif ps.has_key?(predicate)
-                     { predicate => ps[predicate] }
-                   else
-                     []
-                   end
+                  ps
+                elsif ps.has_key?(predicate)
+                  { predicate => ps[predicate] }
+                else
+                  []
+                end
               ps.each do |p, os|
                 os.each do |o, object_options|
                   next unless object.nil? || object.eql?(o)
@@ -411,7 +425,7 @@ module RDF
             end
           end
         else
-          enum_for(:query_pattern, pattern, options)
+          enum_for(:query_pattern, pattern, **options)
         end
       end
 
@@ -512,8 +526,8 @@ module RDF
       class SerializedTransaction < Transaction
         ##
         # @see Transaction#initialize
-        def initialize(*)
-          super
+        def initialize(*args, **options, &block)
+          super(*args, **options, &block)
           @base_snapshot = @snapshot
         end
         

data/lib/rdf/transaction.rb

@@ -24,7 +24,7 @@ module RDF
   #   repository = RDF::Repository.new
   #
   #   RDF::Transaction.begin(repository) do |tx|
-  #     tx.query(predicate: RDF::Vocab::DOAP.developer) do |statement|
+  #     tx.query({predicate: RDF::Vocab::DOAP.developer}) do |statement|
   #       puts statement.inspect
   #     end
   #   end

data/lib/rdf/util.rb

@@ -1,7 +1,8 @@
 module RDF; module Util
-  autoload :Aliasing, 'rdf/util/aliasing'
-  autoload :Cache,    'rdf/util/cache'
-  autoload :File,     'rdf/util/file'
-  autoload :Logger,   'rdf/util/logger'
-  autoload :UUID,     'rdf/util/uuid'
+  autoload :Aliasing,  'rdf/util/aliasing'
+  autoload :Cache,     'rdf/util/cache'
+  autoload :File,      'rdf/util/file'
+  autoload :Logger,    'rdf/util/logger'
+  autoload :UUID,      'rdf/util/uuid'
+  autoload :Coercions, 'rdf/util/coercions'
 end; end

data/lib/rdf/util/cache.rb

@@ -9,8 +9,8 @@ module RDF; module Util
   #
   # While this cache is something of an internal implementation detail of
   # RDF.rb, some external libraries do currently make use of it as well,
-  # including [SPARQL](http://github.com/ruby-rdf/sparql/) and
-  # [Spira](http://github.com/ruby-rdf/spira). Do be sure to include any changes
+  # including [SPARQL](https://github.com/ruby-rdf/sparql/) and
+  # [Spira](https://github.com/ruby-rdf/spira). Do be sure to include any changes
   # here in the RDF.rb changelog.
   #
   # @see   RDF::URI.intern

data/lib/rdf/util/coercions.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+module RDF
+  module Util
+    module Coercions
+      # This is a provisional module intended to house input
+      # coercions. Currently the only coercion is a statement
+      # preprocessor that is used in e.g. {RDF::Writable#insert} and
+      # {RDF::Mutable#delete}.
+
+      protected
+
+      ##
+      # Coerce an array of arguments into {RDF::Statement}, or
+      # {RDF::Enumerable} and then yield to a block. Note that this
+      # code was amalgamated from that which was sandwiched around
+      # both {RDF::Writable#insert_statements} and
+      # {RDF::Mutable#delete_statements}. The parameters `query` and
+      # `constant` are therefore present to handle the conditions
+      # where the statements contain wildcards and what to do about
+      # them.
+      # 
+      # @example
+      #  coerce_statements(statements) { |value| do_something(value) }
+      #
+      # @param statements [#map] The arbitrary-ish input to be manipulated
+      # @param query [false, true] Whether to call `query` before the block
+      #  (as expected by {Mutable#delete_statements})
+      # @param constant [false, true] Whether to test if the statements
+      #  are constant (as expected by {Mutable#delete_statements})
+      # @yield [RDF::Statement, RDF::Enumerable] 
+      # @return statements
+      def coerce_statements(statements, query: false, constant: false, &block)
+        raise ArgumentError, 'expecting a block' unless block_given?
+
+        statements = statements.map do |value|
+          case
+          when value.respond_to?(:each_statement)
+            block.call(value)
+            nil
+          when (statement = Statement.from(value)) &&
+              (!constant || statement.constant?)
+            statement
+          when query
+            # XXX note that this only makes sense when the module is include()d
+            block.call(self.query(value))
+            nil
+          else
+            raise ArgumentError, "Not a valid statement: #{value.inspect}"
+          end
+        end.compact
+
+        block.call(statements) unless statements.empty?
+
+        # eh might as well return these
+        statements
+      end
+
+    end
+  end
+end