rdf 3.1.2 → 3.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39ba8235c527933f06e9685428f3948547e46563c68ca5d0e1f3ac22f12b3d60
-  data.tar.gz: 00fb02e10e11e2e011c58766c609ca186dc1e2c74ef44f09af704297681e94b8
+  metadata.gz: 7e220d98b1d53ade20bf5999761a948e495597dc74eaccd6830c22adadc77fa4
+  data.tar.gz: 13b643963aeb32f99e2c455490e3cbc661c56153abb6dd38ff192e42ce0ee5f5
 SHA512:
-  metadata.gz: 46e0b83df6bf5fbdecdee12cc9bb2e34f93dce625a1a86edbd3251366a6ac6ef09fa4a1520c883c0f7a0a5d2bdb492e97fddeed739b4db28e6e69e278cc78e33
-  data.tar.gz: db8b82296da844a5b8c0ab8547038cdd4f96e41231db41f2f8f0abd2d04859918a90adee3ded6369c9a37f20c192e16cc9d656910661533bb3bbbf5fb46a6aa5
+  metadata.gz: 9a845aa06b3cb0af80aa3e2ca0d9f051d4158258d5007032f73b974c4976e0dd9a34b8d1c55eda3fe2b5fd8c5f9ee9528647514f81387f0032e4adcbc8a0f46d
+  data.tar.gz: 388f74852651a13a7a24f10c6dee8767d76d44b7d002d58efc356dfae76629c7fccd0c462a19df874ee64c39516b838661e4b586847718084a41ad72644483fa

data/README.md

@@ -438,7 +438,10 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   enough, be assured we will eventually add you in there.
 * Do note that in order for us to merge any non-trivial changes (as a rule
   of thumb, additions larger than about 15 lines of code), we need an
-  explicit [public domain dedication][PDD] on record from you.
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
+
 
 ## License
 
@@ -450,7 +453,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [N-Quads]:          https://www.w3.org/TR/n-quads/
 [YARD]:             https://yardoc.org/
 [YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:              https://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[PDD]:              https://unlicense.org/#unlicensing-contributions
 [JSONLD doc]:       https://rubydoc.info/github/ruby-rdf/json-ld
 [LinkedData doc]:   https://rubydoc.info/github/ruby-rdf/linkeddata
 [Microdata doc]:    https://rubydoc.info/github/ruby-rdf/rdf-microdata

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.7

data/bin/rdf

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+$:.unshift(File.expand_path("../../lib", __FILE__))
 require 'rubygems'
-require 'rdf/cli'
+require 'rdf'
 
 options = RDF::CLI.options(ARGV)
 

data/lib/rdf.rb

@@ -76,6 +76,9 @@ module RDF
   # Utilities
   autoload :Util,        'rdf/util'
 
+  # CLI
+  autoload :CLI,         'rdf/cli'
+
   ##
   # Alias for `RDF::Resource.new`.
   #

data/lib/rdf/changeset.rb

@@ -218,5 +218,12 @@ module RDF
       stmts.each { |s| send(target) << s }
     end
 
+    # This simply returns its argument as a query in order to trick
+    # {RDF::Mutable#delete} into working.
+    def query(stmt)
+      RDF::Query.new RDF::Query::Pattern.from(stmt)
+    end
+
+    undef_method :load
   end # Changeset
 end # RDF

data/lib/rdf/cli.rb

@@ -8,7 +8,7 @@ begin
   require 'linkeddata'
 rescue LoadError
   # Silently load without linkeddata, but try some others
-  %w(reasoner rdfa rdfxml turtle vocab json/ld ld/patch).each do |ser|
+  %w(microdata n3 rdfa rdfxml reasoner tabular trig trix turtle vocab xsd json/ld ld/patch).each do |ser|
     begin
       require ser.include?('/') ? ser : "rdf/#{ser}"
     rescue LoadError
@@ -296,6 +296,12 @@ module RDF
         control: :none,
         on: ["-o", "--output FILE"],
         description: "File to write output, defaults to STDOUT") {|arg| File.open(arg, "w")},
+      RDF::CLI::Option.new(
+        symbol: :ordered,
+        control: :checkbox,
+        datatype: TrueClass,
+        on: ["--ordered"],
+        description: "Use order preserving repository"),
       RDF::CLI::Option.new(
         symbol: :format,
         control: :select,
@@ -495,14 +501,16 @@ module RDF
       options[:format] = options[:format].to_sym if options[:format]
       options[:output_format] = options[:output_format].to_sym if options[:output_format]
 
-      @repository = RDF::Repository.new
+      @repository = options[:ordered] ?
+        [].extend(RDF::Enumerable, RDF::Queryable) :
+        RDF::Repository.new
 
       # Parse input files if any command requires it
       if cmds.any? {|c| COMMANDS[c.to_sym][:parse]}
         start = Time.new
         count = 0
         self.parse(args, **options) do |reader|
-          @repository << reader
+          reader.each_statement {|st| @repository << st}
         end
         secs = Time.new - start
         options[:logger].info "Parsed #{repository.count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."

data/lib/rdf/model/list.rb

@@ -45,7 +45,7 @@ module RDF
     # identified by `subject`, but will be invalid.
     #
     # @example add constructed list to existing graph
-    #     l = RDF::List(nil, nil (1, 2, 3))
+    #     l = RDF::List(values: (1, 2, 3))
     #     g = RDF::Graph.new << l
     #     g.count # => l.count
     #
@@ -68,8 +68,8 @@ module RDF
         if first || values.length > 0
           # Intantiate the list from values, and insert the first value using subject.
           values.reverse_each {|value| self.unshift(value)}
-          graph.insert RDF::Statement(subject, RDF.first, first || RDF.nil)
-          graph.insert RDF::Statement(subject, RDF.rest, @subject)
+          @graph.insert RDF::Statement(subject, RDF.first, first || RDF.nil)
+          @graph.insert RDF::Statement(subject, RDF.rest, @subject)
         end
         @subject = subject
       else
@@ -175,7 +175,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-26
     def &(other)
-      RDF::List[*(to_a & other.to_a)]
+      self.class.new(values: (to_a & other.to_a))
     end
 
     ##
@@ -193,7 +193,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-7C
     def |(other)
-      RDF::List[*(to_a | other.to_a)]
+      self.class.new(values: (to_a | other.to_a))
     end
 
     ##
@@ -206,7 +206,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2B
     def +(other)
-      RDF::List[*(to_a + other.to_a)]
+      self.class.new(values: (to_a + other.to_a))
     end
 
     ##
@@ -220,7 +220,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2D
     def -(other)
-      RDF::List[*(to_a - other.to_a)]
+      self.class.new(values: (to_a - other.to_a))
     end
 
     ##
@@ -250,7 +250,7 @@ module RDF
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-2A
     def *(int_or_str)
       case int_or_str
-        when Integer then RDF::List[*(to_a * int_or_str)]
+        when Integer then self.class.new(values: (to_a * int_or_str))
         else join(int_or_str.to_s)
       end
     end
@@ -538,13 +538,13 @@ module RDF
     ##
     # @private
     def slice_with_start_and_length(start, length)
-      RDF::List[*to_a.slice(start, length)]
+      self.class.new(values: to_a.slice(start, length))
     end
 
     ##
     # @private
     def slice_with_range(range)
-      RDF::List[*to_a.slice(range)]
+      self.class.new(values: to_a.slice(range))
     end
 
     protected :slice_with_start_and_length
@@ -851,7 +851,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-reverse
     def reverse
-      RDF::List[*to_a.reverse]
+      self.class.new(values: to_a.reverse)
     end
 
     ##
@@ -863,7 +863,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-sort
     def sort(&block)
-      RDF::List[*super]
+      self.class.new(values: super)
     end
 
     ##
@@ -875,7 +875,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-sort_by
     def sort_by(&block)
-      RDF::List[*super]
+      self.class.new(values: super)
     end
 
     ##
@@ -887,7 +887,7 @@ module RDF
     # @return [RDF::List]
     # @see    http://ruby-doc.org/core-2.2.2/Array.html#method-i-uniq
     def uniq
-      RDF::List[*to_a.uniq]
+      self.class.new(values: to_a.uniq)
     end
 
     ##
@@ -964,7 +964,7 @@ module RDF
       case value
         when nil         then RDF.nil
         when RDF::Value  then value
-        when Array       then RDF::List.new(subject: nil, graph: graph, values: value)
+        when Array       then self.class.new(subject: nil, graph: graph, values: value)
         else value
       end
     end

data/lib/rdf/model/literal.rb

@@ -118,6 +118,7 @@ module RDF
           when ::Integer    then RDF::Literal::Integer
           when ::Float      then RDF::Literal::Double
           when ::BigDecimal then RDF::Literal::Decimal
+          when ::Rational   then RDF::Literal::Double
           when ::DateTime   then RDF::Literal::DateTime
           when ::Time       then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date

data/lib/rdf/model/literal/decimal.rb

@@ -63,9 +63,15 @@ module RDF; class Literal
     ##
     # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Decimal]
     def round
-      self.class.new(to_d.round)
+      rounded = to_d.round(half: (to_d < 0 ? :down : :up))
+      if rounded == -0.0
+        # to avoid -0.0
+        self.class.new(0.0)
+      else
+        self.class.new(rounded)
+      end
     end
 
     ##
@@ -74,9 +80,9 @@ module RDF; class Literal
     # @example
     #   RDF::Literal(1).ceil            #=> RDF::Literal(1)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     def ceil
-      self.class.new(to_d.ceil)
+      RDF::Literal::Integer.new(to_d.ceil)
     end
 
     ##
@@ -85,9 +91,9 @@ module RDF; class Literal
     # @example
     #   RDF::Literal(1).floor            #=> RDF::Literal(1)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     def floor
-      self.class.new(to_d.floor)
+      RDF::Literal::Integer.new(to_d.floor)
     end
 
     ##

data/lib/rdf/model/literal/double.rb

@@ -142,7 +142,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the smallest number greater than or equal to `self`.
+    # Returns the smallest integer greater than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
@@ -150,14 +150,14 @@ module RDF; class Literal
     #   RDF::Literal(2.0).ceil            #=> RDF::Literal(2)
     #   RDF::Literal(-2.0).ceil           #=> RDF::Literal(-2)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     # @since  0.2.3
     def ceil
-      self.class.new(to_f.ceil)
+      RDF::Literal::Integer.new(to_f.ceil)
     end
 
     ##
-    # Returns the largest number less than or equal to `self`.
+    # Returns the largest integer less than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).floor           #=> RDF::Literal(1)
@@ -165,10 +165,10 @@ module RDF; class Literal
     #   RDF::Literal(2.0).floor           #=> RDF::Literal(2)
     #   RDF::Literal(-2.0).floor          #=> RDF::Literal(-2)
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Integer]
     # @since  0.2.3
     def floor
-      self.class.new(to_f.floor)
+      RDF::Literal::Integer.new(to_f.floor)
     end
 
     ##
@@ -183,9 +183,9 @@ module RDF; class Literal
     ##
     # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
     #
-    # @return [RDF::Literal]
+    # @return [RDF::Literal::Double]
     def round
-      self.class.new(to_f.round)
+      self.class.new(to_d.round(half: (to_d < 0 ? :down : :up)))
     end
 
     ##

data/lib/rdf/model/literal/numeric.rb

@@ -123,6 +123,40 @@ module RDF; class Literal
       end
     end
 
+    ##
+    # Exponent − Performs exponential (power) calculation on operators.
+    #
+    # Promotes values, as necessary, with the result type depending on the input values.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    # @see https://www.w3.org/TR/xpath-functions/#func-math-pow
+    def **(other)
+      RDF::Literal(object ** (other.is_a?(RDF::Literal::Numeric) ? other.object : other))
+    rescue ZeroDivisionError
+      RDF::Literal::Double.new('INF')
+    end
+
+    ##
+    # Exponent − Performs remainder of `self` divided by `other`.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    # @see https://www.w3.org/TR/xpath-functions/#func-numeric-mod
+    def %(other)
+      if self.class == Double || [Double, ::Float].include?(other.class)
+        self.class.new(to_f % other.to_f)
+      elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
+        self.class.new(to_f % other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        self.class.new(to_d % (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        self.class.new(to_i % other.to_i)
+      end
+    end
+
     ##
     # Returns the quotient of `self` divided by `other`.
     #

data/lib/rdf/model/uri.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-require 'uri'
+require 'cgi'
 
 module RDF
   ##
@@ -311,12 +311,22 @@ module RDF
     # @param [#to_s] base_uri
     # @return [RDF::URI]
     def relativize(base_uri)
-      if base_uri.to_s.end_with?("/", "#") &&
+      if self.to_s.start_with?(base_uri.to_s) && %w(# ?).include?(self.to_s[base_uri.to_s.length, 1]) ||
+         base_uri.to_s.end_with?("/", "#") &&
          self.to_s.start_with?(base_uri.to_s)
-        RDF::URI(self.to_s[base_uri.to_s.length..-1])
+        return RDF::URI(self.to_s[base_uri.to_s.length..-1])
       else
-        self
+        # Create a list of parents, for which this IRI may be relative.
+        u = RDF::URI(base_uri)
+        iri_set = u.to_s.end_with?('/') ? [u.to_s] : []
+        iri_set << u.to_s while (u = u.parent)
+        iri_set.each_with_index do |bb, index|
+          next unless self.to_s.start_with?(bb)
+          rel = "../" * index + self.to_s[bb.length..-1]
+          return rel.empty? ? "./" : rel
+        end
       end
+      self
     end
 
     ##
@@ -846,7 +856,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] = (CGI.unescape(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 +912,7 @@ module RDF
     # Normalized version of user
     # @return [String]
     def normalized_user
-      URI.encode(URI.decode(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if user
+      URI.encode(CGI.unescape(user), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/).force_encoding(Encoding::UTF_8) if user
     end
 
     ##
@@ -928,7 +938,7 @@ module RDF
     # Normalized version of password
     # @return [String]
     def normalized_password
-      URI.encode(URI.decode(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/) if password
+      URI.encode(CGI.unescape(password), /[^#{IUNRESERVED}|#{SUB_DELIMS}]/).force_encoding(Encoding::UTF_8) if password
     end
 
     HOST_FROM_AUTHORITY_RE = /(?:[^@]+@)?([^:]+)(?::.*)?$/.freeze
@@ -1180,8 +1190,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 = CGI.unescape(k)
+          v = CGI.unescape(v) if v
           if return_type == Hash
             case memo[k]
             when nil then memo[k] = v
@@ -1293,9 +1303,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 = CGI.unescape(value)
         decoded.downcase! if downcase
-        URI.encode(decoded, /[^(?:#{expr})]/)
+        URI.encode(decoded, /[^(?:#{expr})]/).force_encoding(Encoding::UTF_8)
       end
     end
 

data/lib/rdf/ntriples/reader.rb

@@ -1,4 +1,7 @@
 # -*- encoding: utf-8 -*-
+
+require 'strscan'
+
 module RDF::NTriples
   ##
   # N-Triples parser.

data/lib/rdf/query.rb

@@ -247,15 +247,22 @@ module RDF
     # Optimizes this query by reordering its constituent triple patterns
     # according to their cost estimates.
     #
+    # Optional patterns have greater cost than non-optional patterns so they will always come after non-optional patterns
+    #
     # @param  [Hash{Symbol => Object}] options
     #   any additional options for optimization
     # @return [self]
     # @see    RDF::Query::Pattern#cost
     # @since  0.3.0
     def optimize!(**options)
-      @patterns.sort! do |a, b|
+      optional, required = @patterns.partition(&:optional?)
+      required.sort! do |a, b|
+        (a.cost || 0) <=> (b.cost || 0)
+      end
+      optional.sort! do |a, b|
         (a.cost || 0) <=> (b.cost || 0)
       end
+      @patterns = required + optional
       self
     end
 

data/lib/rdf/query/pattern.rb

@@ -181,16 +181,10 @@ module RDF; class Query
 
       # No, some terms actually refer to the same variable...
       else
-        # Figure out which terms refer to the same variable:
-        terms = variables.each_key.find do |name|
-          terms = variable_terms(name)
-          break terms if terms.size > 1
-        end
+        # Considering embedding, figure out if variables that may appear more than once resolve to the same value.
+        vars = variables.keys
         queryable.query(query).select do |statement|
-          # Only yield those matching statements where the variable
-          # constraint is also satisfied:
-          # FIXME: `Array#uniq` uses `#eql?` and `#hash`, not `#==`
-          if terms.map { |term| statement.send(term) }.uniq.size.equal?(1)
+          if vars.all? {|var| self.var_values(var, statement).uniq.size == 1}
             yield statement if block_given?
             true
           end
@@ -220,8 +214,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)
+        solution.merge!(subject.solution(statement.subject)) if subject.respond_to?(:solution)
+        solution.merge!(object.solution(statement.object)) if object.respond_to?(:solution)
       end
     end
 
@@ -234,8 +228,11 @@ module RDF; class Query
     # @param  [Symbol, #to_sym] name
     #   an optional variable name
     # @return [Array<Symbol>]
+    # @deprecated use {#var_values} instead
     # @since  0.3.0
     def variable_terms(name = nil)
+      warn "[DEPRECATION] RDF::Query::Pattern#variable_terms is deprecated and will be removed in a future version.\n" +
+           "Called from #{Gem.location_of_caller.join(':')}"
       terms = []
       terms << :subject    if subject.is_a?(Variable)    && (!name || name.eql?(subject.name))
       terms << :predicate  if predicate.is_a?(Variable)  && (!name || name.eql?(predicate.name))
@@ -244,6 +241,20 @@ module RDF; class Query
       terms
     end
 
+    ##
+    # Returns all values the statement in the same pattern position
+    #
+    # @param [Symbol] var
+    # @param [RDF::Statement] statement
+    # @return [Array<RDF::Term>]
+    def var_values(var, statement)
+      [:subject, :predicate, :object, :graph_name].map do |position|
+        po = self.send(position)
+        so = statement.send(position)
+        po.var_values(var, so) if po.respond_to?(:var_values)
+      end.flatten.compact
+    end
+
     ##
     # Returns the number of variables in this pattern.
     #
@@ -254,7 +265,7 @@ module RDF; class Query
     def variable_count
       [subject, predicate, object, graph_name].inject(0) do |memo, term|
         memo += (term.is_a?(Variable) ? 1 :
-                 (term.is_a?(Pattern) ? term.variable_count : 0))
+                 (term.respond_to?(:variable_count) ? term.variable_count : 0))
       end
     end
     alias_method :cardinality, :variable_count
@@ -311,9 +322,9 @@ module RDF; class Query
     def bindings
       bindings = {}
       bindings.merge!(subject.bindings)    if subject && subject.variable?
-      bindings.merge!(predicate.bindings)  if predicate.is_a?(Variable)
+      bindings.merge!(predicate.bindings)  if predicate && predicate.variable?
       bindings.merge!(object.bindings)     if object && object.variable?
-      bindings.merge!(graph_name.bindings) if graph_name.is_a?(Variable)
+      bindings.merge!(graph_name.bindings) if graph_name && graph_name.variable?
       bindings
     end
 
@@ -354,24 +365,7 @@ module RDF; class Query
     #
     # @return [String]
     def to_s
-      StringIO.open do |buffer| # FIXME in RDF::Statement
-        buffer << 'OPTIONAL ' if optional?
-        buffer << [subject, predicate, object].map do |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 " ."
-          when Variable then " #{graph_name.to_s} ."
-          else " #{RDF::NTriples.serialize(graph_name)} ."
-        end
-        buffer.string
-      end
+      (optional? ? 'OPTIONAL ' : '') + super
     end
   end # Pattern
 end; end # RDF::Query

data/lib/rdf/query/variable.rb

@@ -65,7 +65,7 @@ class RDF::Query
     #   the variable name
     # @param  [RDF::Term] value
     #   an optional variable value
-    # @param [Boolean] distinguished (true) Also interpreted by leading '??' or '$$' in name.
+    # @param [Boolean] distinguished (true) Also interpreted by leading '?' or '$' in name. If non-distinguished, '??' or '$$'.
     # @param [Boolean] existential (true) Also interpreted by leading '$' in name
     def initialize(name = nil, value = nil, distinguished: nil, existential: nil)
       name = (name || "g#{__id__.to_i.abs}").to_s
@@ -246,6 +246,16 @@ class RDF::Query
       end
     end
 
+    ##
+    # Returns term if var is the same as this variable.
+    #
+    # @param [Symbol] var
+    # @param [RDF::Term] term
+    # @return [RDF::Term]
+    def var_values(var, term)
+      term if var == name
+    end
+
     ##
     # Returns a string representation of this variable.
     #
@@ -265,5 +275,6 @@ class RDF::Query
       prefix = distinguished? ? (existential? ? '$' : '?') : (existential? ? '$$' : '??')
       unbound? ? "#{prefix}#{name}" : "#{prefix}#{name}=#{value}"
     end
+    alias_method :to_base, :to_s
   end # Variable
 end # RDF::Query

data/lib/rdf/repository.rb

@@ -410,12 +410,12 @@ module RDF
             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)

data/lib/rdf/util/file.rb

@@ -14,7 +14,7 @@ module RDF; module Util
   # allowing the use of `Rack::Cache` to avoid network access.
   #
   # To use other HTTP clients, consumers can subclass 
-  # {RDF::Util::File::HttpAdapter} and set the {RDF::Util::File.http_adapter}.
+  # {RDF::Util::File::HttpAdapter} and set the {RDF::Util::File.}.
   #
   # Also supports the file: scheme for access to local files.
   #
@@ -121,8 +121,8 @@ module RDF; module Util
 
         redirect_count = 0
         max_redirects = 5
-        parsed_url = ::URI.parse(base_uri)
-        parsed_proxy = ::URI.parse(proxy.to_s)
+        parsed_url = RDF::URI.parse(base_uri)
+        parsed_proxy = RDF::URI.parse(proxy.to_s)
         base_uri = parsed_url.to_s
         remote_document = nil
 

data/lib/rdf/util/logger.rb

@@ -219,9 +219,9 @@ module RDF; module Util
     #   @return [void]
     def logger_common(*args, level:, **options)
       logger = self.logger(**options)
-      logger.log_statistics[level] = logger.log_statistics[level].to_i + 1
       # Some older code uses integer level numbers
       level = LOGGER_COMMON_LEVELS_REVERSE.fetch(level) if level.is_a?(Integer)
+      logger.log_statistics[level] = logger.log_statistics[level].to_i + 1
       return if logger.level > LOGGER_COMMON_LEVELS.fetch(level)
 
       depth = options.fetch(:depth, logger.log_depth)

data/lib/rdf/vocab/writer.rb

@@ -1,5 +1,6 @@
 require 'rdf'
 require 'rdf/vocabulary'
+require 'cgi'
 
 module RDF
   ##
@@ -84,7 +85,7 @@ module RDF
             on: ["--extra URIEncodedJSON"],
             description: "URI Encoded JSON representation of extra data"
           ) do |arg|
-            ::JSON.parse(::URI.decode(arg)).inject({}) do |m1, (term, defs)|
+            ::JSON.parse(::CGI.unescape(arg)).inject({}) do |m1, (term, defs)|
               d1 = defs.inject({}) {|m, (k,v)| m.merge(k.to_sym => v)}
               m1.merge(term.to_sym => d1)
             end
@@ -262,7 +263,7 @@ module RDF
 
       def serialize_value(value, key, indent: "")
         if value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(key.to_s)
-          "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')}).freeze"
+          "#{value.to_s.inspect}.freeze"
         elsif value.is_a?(RDF::URI)
           "#{value.pname.inspect}.freeze"
         elsif value.is_a?(RDF::Vocabulary::Term)

data/lib/rdf/vocabulary.rb

@@ -85,10 +85,15 @@ module RDF
       end
 
       ##
-      # A hash of all vocabularies by prefix showing relevant URI and associated vocabulary Class Name
+      # A hash of all vocabularies by prefix showing relevant URI and
+      # associated vocabulary Class Name
+      #
       # @return [Hash{Symbol => Hash{Symbol => String}}]
       def vocab_map
-        VOCABS
+        # Create an initial duplicate of RDF::VOCABS. We want to
+        # ensure the hash itself is modifiable but the values are
+        # frozen.
+        @vocab_map ||= RDF::VOCABS.transform_values(&:freeze)
       end
 
       ##
@@ -100,6 +105,36 @@ module RDF
         RDF.const_get(sym.to_sym)
       end
 
+      ##
+      # Register a vocabulary for internal prefix lookups. Parameters
+      # of interest include `:uri`, `:class_name`, `:source`, and `:skip`.
+      #
+      # @param prefix [Symbol] the prefix to use
+      # @param vocab  [String, Class] either the URI or the vocab class
+      # @param params [Hash{Symbol => String}] Relevant parameters
+      # @return [Hash] The parameter hash, but frozen
+      def register(prefix, vocab, **params)
+        # check the input
+        raise ArgumentError, "#{prefix} must be symbol-able" unless
+          [String, Symbol].any? { |c| prefix.is_a? c }
+
+        # note an explicit uri: param overrides
+        case vocab
+        when String then params[:uri] ||= vocab
+        when Class
+          raise ArgumentError, 'vocab must be an RDF::(Strict)Vocabulary' unless
+            vocab.ancestors.include? RDF::Vocabulary
+          params[:class] = vocab
+          params[:uri] ||= vocab.to_uri.to_s
+        end
+
+        # fill in the class name
+        params[:class_name] ||= prefix.to_s.upcase
+
+        # now freeze and assign
+        vocab_map[prefix.to_s.to_sym] = params.freeze
+      end
+
       ##
       # Limits iteration over vocabularies to just those selected
       #
@@ -347,7 +382,8 @@ module RDF
         if prefix == "rdf"
           RDF[suffix]
         elsif vocab_detail = RDF::Vocabulary.vocab_map[prefix.to_sym]
-          vocab = RDF::Vocabulary.from_sym(vocab_detail[:class_name])
+          vocab = vocab_detail[:class] ||
+            RDF::Vocabulary.from_sym(vocab_detail[:class_name])
           suffix.to_s.empty? ? vocab.to_uri : vocab[suffix]
         else
           (RDF::Vocabulary.find_term(pname) rescue nil) || RDF::URI(pname, validate: true)
@@ -695,7 +731,7 @@ module RDF
     # @param  [#to_s] property
     # @return [URI]
     def [](property)
-      Term.intern([to_s, property.to_s].join(''), vocab: self.class, attributes: {})
+      Term.intern([to_s, property.to_s].join(''), vocab: self, attributes: {})
     end
 
     ##

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.7
 platform: ruby
 authors:
 - Arto Bendiken
 - Ben Lavender
 - Gregg Kellogg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-30 00:00:00.000000000 Z
+date: 2020-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -288,7 +288,7 @@ metadata:
   homepage_uri: https://ruby-rdf.github.io/rdf
   mailing_list_uri: https://lists.w3.org/Archives/Public/public-rdf-ruby/
   source_code_uri: https://github.com/ruby-rdf/rdf
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -303,8 +303,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.
 test_files: []