rdf 3.0.11 → 3.1.2

data/lib/rdf/mixin/queryable.rb

@@ -19,7 +19,7 @@ module RDF
     #
     # @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
     #
@@ -50,7 +50,7 @@ module RDF
           solutions = RDF::Query::Solutions.new
           block = lambda {|solution| solutions << solution} unless block_given?
           before_query(pattern) if respond_to?(:before_query)
-          query_execute(pattern, options, &block)
+          query_execute(pattern, **options, &block)
           after_query(pattern) if respond_to?(:after_query)
           # Returns the solutions, not an enumerator
           solutions
@@ -85,7 +85,7 @@ module RDF
 
             # Otherwise, we delegate to `#query_pattern`:
             else # pattern.variable?
-              query_pattern(pattern, options, &block)
+              query_pattern(pattern, **options, &block)
           end
           after_query(pattern) if respond_to?(:after_query)
           enum
@@ -116,7 +116,7 @@ module RDF
       # 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
 
@@ -128,6 +128,14 @@ module RDF
     # method in order to provide for storage-specific optimized triple
     # pattern matching.
     #
+    # ## RDFStar (RDF*)
+    #
+    # Statements may have embedded statements as either a subject or object, recursively.
+    #
+    # Patterns may also have embedded patterns as either a subject or object, recursively.
+    #
+    # When matching, match an embedded pattern against embedded statements, recursively. (see {RDF::Query::Pattern#eql?})
+    #
     # @param  [RDF::Query::Pattern] pattern
     #   the query pattern to match
     # @param  [Hash{Symbol => Object}] options ({})

data/lib/rdf/mixin/transactable.rb

@@ -21,14 +21,14 @@ module RDF
     #
     # @example running a transaction
     #   repository.transaction(mutable: true) do |tx|
-    #     tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
+    #     tx.insert [RDF::URI("https://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
     #   end
     #
     # Raising an error within the transaction block causes automatic rollback.
     #
     # @example manipulating a live transaction
     #   tx = repository.transaction(mutable: true)
-    #   tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
+    #   tx.insert [RDF::URI("https://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
     #   tx.execute
     #
     # @overload transaction(mutable: false)

data/lib/rdf/mixin/writable.rb

@@ -7,6 +7,7 @@ module RDF
   # @see RDF::Repository
   module Writable
     extend RDF::Util::Aliasing::LateBound
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is writable.
@@ -53,31 +54,20 @@ module RDF
     # @overload insert(*statements)
     #   @param  [Array<RDF::Statement>] statements
     #   @return [self]
+    #   @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     #
     # @overload insert(statements)
     #   @param  [Enumerable<RDF::Statement>] statements
     #   @return [self]
+    #   @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     def insert(*statements)
-      statements.map! do |value|
-        case
-          when value.respond_to?(:each_statement)
-            insert_statements(value)
-            nil
-          when (statement = Statement.from(value))
-            statement
-          else
-            raise ArgumentError.new("not a valid statement: #{value.inspect}")
-        end
-      end
-      statements.compact!
-      insert_statements(statements) unless statements.empty?
+      coerce_statements(statements) { |value| insert_statements value }
 
       return self
     end
     alias_method :insert!, :insert
 
   protected
-
     ##
     # Inserts statements from the given RDF reader into the underlying
     # storage or output stream.
@@ -132,10 +122,14 @@ module RDF
     #
     # @param  [RDF::Enumerable] statements
     # @return [void]
+    # @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     # @since  0.1.6
     def insert_statements(statements)
       each = statements.respond_to?(:each_statement) ? :each_statement : :each
       statements.__send__(each) do |statement|
+        if statement.embedded? && respond_to?(:supports?) && !supports?(:rdfstar)
+          raise ArgumentError, "Wriable does not support embedded statements"
+        end
         insert_statement(statement)
       end
     end
@@ -150,6 +144,7 @@ module RDF
     #
     # @param  [RDF::Statement] statement
     # @return [void]
+    # @raise [ArgumentError] on an attempt to insert an embedded statement when it is not supported
     # @abstract
     def insert_statement(statement)
       raise NotImplementedError.new("#{self.class}#insert_statement")

data/lib/rdf/model/dataset.rb

@@ -104,7 +104,7 @@ module RDF
     # @private
     # @see RDF::Enumerable#supports?
     def supports?(feature)
-      return true if feature == :graph_name
+      return true if [:graph_name, :rdfstar].include?(feature)
       super
     end
 

data/lib/rdf/model/graph.rb

@@ -211,7 +211,7 @@ module RDF
     # @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 @@ module RDF
     # @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
@@ -259,11 +259,11 @@ module RDF
     ##
     # Graph equivalence based on the contents of each graph being _exactly_
     # the same. To determine if the have the same _meaning_, consider
-    # [rdf-isomorphic](http://rubygems.org/gems/rdf-isomorphic).
+    # [rdf-isomorphic](https://rubygems.org/gems/rdf-isomorphic).
     #
     # @param [RDF::Graph] other
     # @return [Boolean]
-    # @see http://rubygems.org/gems/rdf-isomorphic
+    # @see https://rubygems.org/gems/rdf-isomorphic
     def ==(other)
       other.is_a?(RDF::Graph) &&
       graph_name == other.graph_name &&
@@ -283,6 +283,9 @@ module RDF
     # @private
     # @see RDF::Mutable#insert
     def insert_statement(statement)
+      if statement.embedded? && !@data.supports?(:rdfstar)
+        raise ArgumentError, "Graph does not support embedded statements"
+      end
       statement = statement.dup
       statement.graph_name = graph_name
       @data.insert(statement)

data/lib/rdf/model/list.rb

@@ -59,7 +59,7 @@ module RDF
     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 @@ module RDF
         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 @@ module RDF
 
       # 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 @@ module RDF
     # @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 @@ module RDF
       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

data/lib/rdf/model/literal.rb

@@ -49,7 +49,7 @@ module RDF
   #   RDF::Literal.new(123).datatype                 #=> XSD.integer
   #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.integer
   #   RDF::Literal.new(3.1415).datatype              #=> XSD.double
-  #   RDF::Literal.new(Time.now).datatype            #=> XSD.time
+  #   RDF::Literal.new(Time.now).datatype            #=> XSD.dateTime
   #   RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
   #   RDF::Literal.new(DateTime.new(2010)).datatype  #=> XSD.dateTime
   #
@@ -119,8 +119,8 @@ module RDF
           when ::Float      then RDF::Literal::Double
           when ::BigDecimal then RDF::Literal::Decimal
           when ::DateTime   then RDF::Literal::DateTime
+          when ::Time       then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date
-          when ::Time       then RDF::Literal::Time # FIXME: Ruby's Time class can represent datetimes as well
           when ::Symbol     then RDF::Literal::Token
           else self
         end
@@ -360,7 +360,7 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @since  0.2.1
     def valid?
-      return false if language? && language.to_s !~ /^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/
+      return false if language? && language.to_s !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
       return false if datatype? && datatype.invalid?
       grammar = self.class.const_get(:GRAMMAR) rescue nil
       grammar.nil? || value.match?(grammar)

data/lib/rdf/model/statement.rb

@@ -3,7 +3,7 @@ module RDF
   # An RDF statement.
   #
   # @example Creating an RDF statement
-  #   s = RDF::URI.new("http://rubygems.org/gems/rdf")
+  #   s = RDF::URI.new("https://rubygems.org/gems/rdf")
   #   p = RDF::Vocab::DC.creator
   #   o = RDF::URI.new("http://ar.to/#self")
   #   RDF::Statement(s, p, o)
@@ -14,7 +14,7 @@ module RDF
   #
   # @example Creating an RDF statement from a `Hash`
   #   RDF::Statement({
-  #     subject:   RDF::URI.new("http://rubygems.org/gems/rdf"),
+  #     subject:   RDF::URI.new("https://rubygems.org/gems/rdf"),
   #     predicate: RDF::Vocab::DC.creator,
   #     object:    RDF::URI.new("http://ar.to/#self"),
   #   })
@@ -26,7 +26,7 @@ module RDF
   #   RDF::Statement(s, p, "o")
   #
   class Statement
-    include RDF::Value
+    include RDF::Resource
 
     ##
     # @private
@@ -112,7 +112,7 @@ module RDF
       elsif @subject.nil?
         nil
       else
-        raise ArgumentError, "expected subject to be nil or a term, was #{@subject.inspect}"
+        raise ArgumentError, "expected subject to be nil or a resource, was #{@subject.inspect}"
       end
       @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
       @object    = if @object.is_a?(Value)
@@ -124,6 +124,15 @@ module RDF
       else
         Literal.new(@object)
       end
+      @graph_name = if @graph_name.is_a?(Value)
+        @graph_name.to_term
+      elsif @graph_name.is_a?(Symbol)
+        Node.intern(@graph_name)
+      elsif !@graph_name
+        @graph_name
+      else
+        raise ArgumentError, "expected graph_name to be nil or a resource, was #{@graph_name.inspect}"
+      end
     end
 
     ##
@@ -140,10 +149,18 @@ module RDF
     #
     # @return [Boolean]
     def variable?
-      !(has_subject?    && subject.resource? &&
-        has_predicate?  && predicate.resource? &&
-        has_object?     && (object.resource? || object.literal?) &&
-        (has_graph?     ? graph_name.resource? : true))
+      !(has_subject?    && subject.constant? &&
+        has_predicate?  && predicate.constant? &&
+        has_object?     && object.constant? &&
+        (has_graph?     ? graph_name.constant? : true))
+    end
+
+    ##
+    # Returns `true` if any element of the statement is, itself, a statement.
+    #
+    # @return [Boolean]
+    def embedded?
+      subject && subject.statement? || object && object.statement?
     end
 
     ##
@@ -386,7 +403,13 @@ module RDF
     # @return [String]
     def to_s
       (graph_name ? to_quad : to_triple).map do |term|
-        term.respond_to?(:to_base) ? term.to_base : term.inspect
+        if term.is_a?(Statement)
+          "<<#{term.to_s[0..-3]}>>"
+        elsif term.respond_to?(:to_base)
+          term.to_base
+        else
+          term.inspect
+        end
       end.join(" ") + " ."
     end
 

data/lib/rdf/model/uri.rb

@@ -7,23 +7,23 @@ module RDF
   # Also compatible with International Resource Identifier (IRI)
   #
   # @example Creating a URI reference (1)
-  #   uri = RDF::URI.new("http://rubygems.org/gems/rdf")
+  #   uri = RDF::URI.new("https://rubygems.org/gems/rdf")
   #
   # @example Creating a URI reference (2)
   #   uri = RDF::URI.new(scheme: 'http', host: 'rubygems.org', path: '/gems/rdf')
-  #     #=> RDF::URI.new("http://rubygems.org/gems/rdf")
+  #     #=> RDF::URI.new("https://rubygems.org/gems/rdf")
   #
   # @example Creating an interned URI reference
-  #   uri = RDF::URI.intern("http://rubygems.org/gems/rdf")
+  #   uri = RDF::URI.intern("https://rubygems.org/gems/rdf")
   #
   # @example Getting the string representation of a URI
-  #   uri.to_s #=> "http://rubygems.org/gems/rdf"
+  #   uri.to_s #=> "https://rubygems.org/gems/rdf"
   #
-  # http://en.wikipedia.org/wiki/Internationalized_Resource_Identifier
-  # @see http://en.wikipedia.org/wiki/Uniform_Resource_Identifier
-  # @see http://www.ietf.org/rfc/rfc3986.txt
-  # @see http://www.ietf.org/rfc/rfc3987.txt
-  # @see http://www.rubydoc.info/gems/addressable
+  # @see https://en.wikipedia.org/wiki/Internationalized_Resource_Identifier
+  # @see https://en.wikipedia.org/wiki/Uniform_Resource_Identifier
+  # @see https://www.ietf.org/rfc/rfc3986.txt
+  # @see https://www.ietf.org/rfc/rfc3987.txt
+  # @see https://rubydoc.info/gems/addressable
   class URI
     include RDF::Resource
 
@@ -141,8 +141,8 @@ module RDF
     #
     # (see #initialize)
     # @return [RDF::URI] an immutable, frozen URI object
-    def self.intern(str, *args)
-      (cache[(str = str.to_s).to_sym] ||= self.new(str, *args)).freeze
+    def self.intern(str, *args, **options)
+      (cache[(str = str.to_s).to_sym] ||= self.new(str, *args, **options)).freeze
     end
 
     ##
@@ -225,11 +225,9 @@ module RDF
       @mutex = Mutex.new
       uri = args.first
       if uri
-        @value = uri.to_s
-        if @value.encoding != Encoding::UTF_8
-          @value.dup.force_encoding(Encoding::UTF_8)
-          @value.freeze
-        end
+        @value = uri.to_s.dup
+        @value.dup.force_encoding(Encoding::UTF_8) if @value.encoding != Encoding::UTF_8
+        @value.freeze
       else
         %w(
           scheme
@@ -402,7 +400,7 @@ module RDF
     # @example Joining two URIs
     #     RDF::URI.new('http://example.org/foo/bar').join('/foo')
     #     #=> RDF::URI('http://example.org/foo')
-    # @see <http://github.com/ruby-rdf/rdf-spec/blob/master/lib/rdf/spec/uri.rb>
+    # @see <https://github.com/ruby-rdf/rdf-spec/blob/master/lib/rdf/spec/uri.rb>
     # @see <http://tools.ietf.org/html/rfc3986#section-5.2>
     # @see RDF::URI#/
     # @see RDF::URI#+
@@ -431,7 +429,9 @@ module RDF
           joined_parts[:query] = uri.query
         else
           # Merge path segments from section 5.2.3
-          base_path = path.to_s.sub(/\/[^\/]*$/, '/')
+          # Note that if the path includes no segments, the entire path is removed
+          #  > return a string consisting of the reference's path component appended to all but the last segment of the base URI's path (i.e., excluding any characters after the right-most "/" in the base URI path, or excluding the entire base URI path if it does not contain any "/" characters).
+          base_path = path.to_s.include?('/') ? path.to_s.sub(/\/[^\/]*$/, '/') : ''
           joined_parts[:path] = self.class.normalize_path(base_path + uri.path)
           joined_parts[:query] = uri.query
         end
@@ -439,7 +439,7 @@ module RDF
       end
 
       # Return joined URI
-      RDF::URI.new(joined_parts)
+      RDF::URI.new(**joined_parts)
     end
 
     ##
@@ -471,7 +471,7 @@ module RDF
     # @see RDF::URI#+
     # @see RDF::URI#join
     # @see <http://tools.ietf.org/html/rfc3986#section-5.2>
-    # @see <http://github.com/ruby-rdf/rdf-spec/blob/master/lib/rdf/spec/uri.rb>
+    # @see <https://github.com/ruby-rdf/rdf-spec/blob/master/lib/rdf/spec/uri.rb>
     # @example Building a HTTP URL
     #     RDF::URI.new('http://example.org') / 'jhacker' / 'foaf.ttl'
     #     #=> RDF::URI('http://example.org/jhacker/foaf.ttl')
@@ -507,7 +507,7 @@ module RDF
           case fragment.to_s[0,1]
           when '#'
             # Base ending with '/', fragment beginning with '#'. The fragment wins, we use '#'.
-            res.path = res.path.to_s.sub!(/\/*$/, '')
+            res.path = res.path.to_s.sub(/\/*$/, '')
             # Add fragment
             res.fragment = fragment.to_s.sub(/^#+/,'')
           else
@@ -572,7 +572,7 @@ module RDF
         self
       else
         RDF::URI.new(
-          object.merge(path: '/').
+          **object.merge(path: '/').
           keep_if {|k, v| [:scheme, :authority, :path].include?(k)})
       end
     end
@@ -657,7 +657,7 @@ module RDF
     #
     # @return [RDF::URI]
     def dup
-      self.class.new((@value || @object).dup)
+      self.class.new(@value, **(@object || {}))
     end
 
     ##
@@ -846,7 +846,7 @@ module RDF
         parts[:user] = (user.dup.force_encoding(Encoding::UTF_8) if user)
         parts[:password] = (password.dup.force_encoding(Encoding::UTF_8) if password)
         parts[:host] = (host.dup.force_encoding(Encoding::UTF_8) if host)
-        parts[:port] = (::URI.decode(port).to_i if port)
+        parts[:port] = (URI.decode(port).to_i if port)
         parts[:path] = (path.to_s.dup.force_encoding(Encoding::UTF_8) unless path.empty?)
         parts[:query] = (query[1..-1].dup.force_encoding(Encoding::UTF_8) if query)
         parts[:fragment] = (fragment[1..-1].dup.force_encoding(Encoding::UTF_8) if fragment)
@@ -902,7 +902,7 @@ module RDF
     # Normalized version of user
     # @return [String]
     def normalized_user
-      ::URI.encode(::URI.decode(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if user
+      URI.encode(URI.decode(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if user
     end
 
     ##
@@ -928,7 +928,7 @@ module RDF
     # Normalized version of password
     # @return [String]
     def normalized_password
-      ::URI.encode(::URI.decode(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if password
+      URI.encode(URI.decode(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if password
     end
 
     HOST_FROM_AUTHORITY_RE = /(?:[^@]+@)?([^:]+)(?::.*)?$/.freeze
@@ -937,7 +937,7 @@ module RDF
     # @return [String]
     def host
       object.fetch(:host) do
-        @object[:host] = ($1 if HOST_FROM_AUTHORITY_RE.match(@object[:authority]))
+        @object[:host] = ($1 if @object[:authority] && HOST_FROM_AUTHORITY_RE.match(@object[:authority]))
       end
     end
 
@@ -965,7 +965,7 @@ module RDF
     # @return [String]
     def port
       object.fetch(:port) do
-        @object[:port] = ($1 if PORT_FROM_AUTHORITY_RE.match(@object[:authority]))
+        @object[:port] = ($1 if @object[:authority] && PORT_FROM_AUTHORITY_RE.match(@object[:authority]))
       end
     end
 
@@ -1180,8 +1180,8 @@ module RDF
         inject(return_type == Hash ? {} : []) do |memo,kv|
           k,v = kv.to_s.split('=', 2)
           next if k.to_s.empty?
-          k = ::URI.decode(k)
-          v = ::URI.decode(v) if v
+          k = URI.decode(k)
+          v = URI.decode(v) if v
           if return_type == Hash
             case memo[k]
             when nil then memo[k] = v
@@ -1293,9 +1293,9 @@ module RDF
     def normalize_segment(value, expr, downcase = false)
       if value
         value = value.dup.force_encoding(Encoding::UTF_8)
-        decoded = ::URI.decode(value)
+        decoded = URI.decode(value)
         decoded.downcase! if downcase
-        ::URI.encode(decoded, /[^(?:#{expr})]/)
+        URI.encode(decoded, /[^(?:#{expr})]/)
       end
     end
 
@@ -1314,6 +1314,27 @@ module RDF
         ""
       end
     end
+
+    # URI encode matching characters in value
+    # From URI gem, as this is now generally deprecated
+    def self.encode(str, expr)
+      str.gsub(expr) do
+        us = $&
+        tmp = ''
+        us.each_byte do |uc|
+          tmp << sprintf('%%%02X', uc)
+        end
+        tmp
+      end.force_encoding(Encoding::US_ASCII)
+    end
+
+    # URI decode escape sequences in value
+    # From URI gem, as this is now generally deprecated
+    def self.decode(str)
+      enc = str.encoding
+      enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
+      str.gsub(PCT_ENCODED) { [$&[1, 2]].pack('H2').force_encoding(enc) }
+    end
   end
 
   # RDF::IRI is a synonym for RDF::URI