rdf 3.0.12 → 3.1.3

data/lib/rdf/model/uri.rb

@@ -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

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

@@ -15,15 +15,17 @@ module 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
 
     ##