rdf 3.0.11 → 3.1.2

data/lib/rdf/nquads.rb

@@ -69,9 +69,9 @@ module RDF
 
           begin
             unless blank? || read_comment
-              subject   = read_uriref || read_node || fail_subject
+              subject   = read_uriref || read_node || read_rdfstar || fail_subject
               predicate = read_uriref(intern: true) || fail_predicate
-              object    = read_uriref || read_node || read_literal || fail_object
+              object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
               graph_name    = read_uriref || read_node
               if validate? && !read_eos
                 log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
@@ -96,7 +96,7 @@ module RDF
       # @param  [RDF::Term]     object
       # @return [void]
       def write_quad(subject, predicate, object, graph_name)
-        puts format_quad(subject, predicate, object, graph_name, @options)
+        puts format_quad(subject, predicate, object, graph_name, **@options)
       end
 
       ##
@@ -107,7 +107,7 @@ module RDF
       # @return [String]
       # @since  0.4.0
       def format_statement(statement, **options)
-        format_quad(*statement.to_quad, options)
+        format_quad(*statement.to_quad, **options)
       end
 
       ##
@@ -120,8 +120,8 @@ module RDF
       # @param  [Hash{Symbol => Object}] options = ({})
       # @return [String]
       def format_quad(subject, predicate, object, graph_name, **options)
-        s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value, options) }
-        s += format_term(graph_name, options) + " " if graph_name
+        s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value, **options) }
+        s += format_term(graph_name, **options) + " " if graph_name
         s + "."
       end
     end # Writer

data/lib/rdf/ntriples.rb

@@ -13,17 +13,19 @@ module RDF
   #
   # An example of an RDF statement in N-Triples format:
   #
-  #     <http://rubygems.org/gems/rdf> <http://purl.org/dc/terms/title> "rdf" .
+  #     <https://rubygems.org/gems/rdf> <http://purl.org/dc/terms/title> "rdf" .
   #
-  # Installation
-  # ------------
+  # ## RDFStar (RDF*)
+  #
+  # Supports statements as resources using `<<s p o>>`.
+  #
+  # ## Installation
   #
   # This is the only RDF serialization format that is directly supported by
   # RDF.rb. Support for other formats is available in the form of add-on
   # gems, e.g. 'rdf-xml' or 'rdf-json'.
   #
-  # Documentation
-  # -------------
+  # ## Documentation
   #
   # * {RDF::NTriples::Format}
   # * {RDF::NTriples::Reader}

data/lib/rdf/ntriples/reader.rb

@@ -25,6 +25,10 @@ module RDF::NTriples
   #     end
   #   end
   #
+  # ** RDFStar (RDF*)
+  #
+  # Supports statements as resources using `<<s p o>>`.
+  #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   # @see http://www.w3.org/TR/n-triples/
   class Reader < RDF::Reader
@@ -70,6 +74,10 @@ module RDF::NTriples
     # 22
     STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{UCHAR})*)"/.freeze
 
+    # RDF*
+    ST_START              = /^<</.freeze
+    ST_END                = /^\s*>>/.freeze
+
     # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar
     COMMENT               = /^#\s*(.*)$/.freeze
     NODEID                = /^#{BLANK_NODE_LABEL}/.freeze
@@ -96,7 +104,7 @@ module RDF::NTriples
     def self.unserialize(input, **options)
       case input
         when nil then nil
-        else self.new(input, {logger: []}.merge(options)).read_value
+        else self.new(input, logger: [], **options).read_value
       end
     end
 
@@ -104,20 +112,20 @@ module RDF::NTriples
     # (see unserialize)
     # @return [RDF::Resource]
     def self.parse_subject(input, **options)
-      parse_uri(input, options) || parse_node(input, options)
+      parse_uri(input, **options) || parse_node(input, **options)
     end
 
     ##
     # (see unserialize)
     # @return [RDF::URI]
-    def self.parse_predicate(input, *options)
+    def self.parse_predicate(input, **options)
       parse_uri(input, intern: true)
     end
 
     ##
     # (see unserialize)
     def self.parse_object(input, **options)
-      parse_uri(input, options) || parse_node(input, options) || parse_literal(input, options)
+      parse_uri(input, **options) || parse_node(input, **options) || parse_literal(input, **options)
     end
 
     ##
@@ -202,7 +210,7 @@ module RDF::NTriples
       begin
         read_statement
       rescue RDF::ReaderError
-        value = read_uriref || read_node || read_literal
+        value = read_uriref || read_node || read_literal || read_rdfstar
         log_recover
         value
       end
@@ -218,9 +226,9 @@ module RDF::NTriples
 
         begin
           unless blank? || read_comment
-            subject   = read_uriref || read_node || fail_subject
+            subject   = read_uriref || read_node || read_rdfstar || fail_subject
             predicate = read_uriref(intern: true) || fail_predicate
-            object    = read_uriref || read_node || read_literal || fail_object
+            object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
 
             if validate? && !read_eos
               log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
@@ -234,6 +242,20 @@ module RDF::NTriples
       end
     end
 
+    ##
+    # @return [RDF::Statement]
+    def read_rdfstar
+      if @options[:rdfstar] && match(ST_START)
+        subject   = read_uriref || read_node || read_rdfstar || fail_subject
+        predicate = read_uriref(intern: true) || fail_predicate
+        object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+        if !match(ST_END)
+          log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
+        end
+        RDF::Statement.new(subject, predicate, object)
+      end
+    end
+
     ##
     # @return [Boolean]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (comment)

data/lib/rdf/ntriples/writer.rb

@@ -208,7 +208,7 @@ module RDF::NTriples
     # @param  [RDF::Term]     object
     # @return [void]
     def write_triple(subject, predicate, object)
-      puts format_triple(subject, predicate, object, @options)
+      puts format_triple(subject, predicate, object, **@options)
     end
 
     ##
@@ -221,6 +221,15 @@ module RDF::NTriples
       format_triple(*statement.to_triple, **options)
     end
 
+    ##
+    # Returns the N-Triples representation of an RDF* reified statement.
+    #
+    # @param  [RDF::Statement] statement
+    # @param  [Hash{Symbol => Object}] options ({})
+    # @return [String]
+    def format_rdfstar(statement, **options)
+      "<<%s %s %s>>" % statement.to_a.map { |value| format_term(value, **options) }
+    end
     ##
     # Returns the N-Triples representation of a triple.
     #

data/lib/rdf/query.rb

@@ -90,7 +90,7 @@ module RDF
     #   the resulting solution sequence
     # @see    RDF::Query#execute
     def self.execute(queryable, patterns = {}, options = {}, &block)
-      self.new(patterns, options, &block).execute(queryable, options)
+      self.new(patterns, **options, &block).execute(queryable, **options)
     end
 
     ##
@@ -134,6 +134,12 @@ module RDF
     # @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 @@ module RDF
       @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 @@ module RDF
         else patterns
       end
 
-      self.graph_name = graph_name
-
       if block_given?
         case block.arity
           when 1 then block.call(self)
@@ -223,7 +228,7 @@ module RDF
     #   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 @@ module RDF
     # @return [RDF::Query] a copy of `self`
     # @since  0.3.0
     def optimize(**options)
-      self.dup.optimize!(options)
+      self.dup.optimize!(**options)
     end
 
     ##
@@ -284,6 +289,8 @@ module RDF
     #   any additional keyword options
     # @option options [Hash{Symbol => RDF::Term}] bindings
     #   optional variable bindings to use
+    # @option options [Boolean] :optimize
+    #   Optimize query before execution.
     # @option options [RDF::Query::Solutions] solutions
     #   optional initial solutions for chained queries
     # @yield  [solution]
@@ -294,9 +301,7 @@ module RDF
     #   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
@@ -308,17 +313,17 @@ module RDF
         return @solutions
       end
 
+      self.optimize! if options[:optimize]
       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
 
@@ -326,15 +331,15 @@ module RDF
 
         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 +412,26 @@ module RDF
     # 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 +508,7 @@ module RDF
     # @return [RDF::Query]
     def dup
       patterns = @patterns.map {|p| p.dup}
-      patterns << @options.merge(solutions: @solutions.dup)
-      Query.new(*patterns)
+      Query.new(patterns, graph_name: graph_name, solutions: @solutions.dup, **options)
     end
 
     ##

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 " ."