rdf 3.1.3 → 3.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3edf1c89289474f1f14ee840b6cd5903c6443afd7ad8121e3ddfce5bcae30895
-  data.tar.gz: 12497c16ebc49b1bcfaa404609389b8c98cea22233868ff1378a810ede686371
+  metadata.gz: d2becf1b8beb0505402d0b4d2a6f7795cca3657bc579ffac31f3b6037d34e550
+  data.tar.gz: 14b57058dab38a7f7a23df435b83ce8e45c56c51ef718a107e1f1fedb6939a63
 SHA512:
-  metadata.gz: de42189a4269854a6292b4cd0b0de0a07c0a0d0e5b61a40cc9b4f460b66ada2f090fbadb0486e48d183f366ce776ea88ff89f715f61439c8c5ad7857d24047cb
-  data.tar.gz: 20725ce63013fed6385e9e1aade5b808d821de4ef5986cedbf9b87c34cc9f749b132437e2b7e496da12774214b709d6d3accf9b0861c14fa3353452ca5e0cbf5
+  metadata.gz: 685797b5318d90aeba5755a88cc4aa0acc37b69bcc209d579d52910f0940cdf93d2b453cb3b60a0779cfadda80a2bc050afad2d18b276d973b21e6f1e3f79317
+  data.tar.gz: a13b21146dfa64967464026e99d80bff9f6b472f4ef7d8079ee53a7e80d80f8577b4b7deee9b60643697354e6b42d093b4229d21978f93b5c65b4a2fa050270f

data/README.md

@@ -6,9 +6,9 @@ This is a pure-Ruby library for working with [Resource Description Framework
 * <https://ruby-rdf.github.com/rdf>
 
 [![Gem Version](https://badge.fury.io/rb/rdf.png)](https://badge.fury.io/rb/rdf)
-[![Build Status](https://travis-ci.org/ruby-rdf/rdf.png?branch=master)](https://travis-ci.org/ruby-rdf/rdf)
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf/badge.svg)](https://coveralls.io/r/ruby-rdf/rdf)
-[![Join the chat at https://gitter.im/ruby-rdf/rdf](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ruby-rdf/rdf?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Build Status](https://github.com/ruby-rdf/rdf/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf/badge.svg)](https://coveralls.io/github/ruby-rdf/rdf)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
 
 ## Features
 
@@ -39,6 +39,22 @@ resources. Clients may also consider using [RestClient Components][] to enable
 client-side caching of HTTP results using [Rack::Cache][] or other Rack
 middleware.
 
+See {RDF::Util::File} for configuring other mechanisms for retrieving resources.
+
+### Term caching and configuration.
+
+RDF.rb uses a weak-reference cache for storing internalized versions of URIs and Nodes. This is particularly useful for Nodes as two nodes are equivalent only if they're the same node.
+
+By default, each cache can grow to an unlimited size, but this can be configured using {RDF.config}, for general limits, along with URI- or Node-specific limits.
+
+For example, to limit the size of the URI intern cache only:
+
+    RDF.config.uri_cache_size = 10_000
+
+The default for creating new caches without a specific initialization size can be set using:
+
+    RDF.config.cache_size = 100_000
+
 ## Differences between RDF 1.0 and RDF 1.1
 
 This version of RDF.rb is fully compatible with [RDF 1.1][], but it creates some
@@ -246,17 +262,10 @@ By default, the N-Triples reader will reject a document containing a subject res
     end
     # => RDF::ReaderError
 
-Readers support a `rdfstar` option with either `:PG` (Property Graph) or `:SA` (Separate Assertions) modes. In `:PG` mode, statements that are used in the subject or object positions are also implicitly added to the graph:
-
-    graph = RDF::Graph.new do |graph|
-      RDF::NTriples::Reader.new(nt, rdfstar: :PG) {|reader| graph << reader}
-    end
-    graph.count #=> 2
-
-When using the `:SA` mode, only one statement is asserted, although the reified statement is contained within the graph.
+Readers support a boolean valued `rdfstar` option.
 
     graph = RDF::Graph.new do |graph|
-      RDF::NTriples::Reader.new(nt, rdfstar: :SA) {|reader| graph << reader}
+      RDF::NTriples::Reader.new(nt, rdfstar: true) {|reader| graph << reader}
     end
     graph.count #=> 1
 
@@ -438,7 +447,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 +462,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
@@ -475,7 +487,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [RDF::TriX]:        https://ruby-rdf.github.com/rdf-trix
 [RDF::Turtle]:      https://ruby-rdf.github.com/rdf-turtle
 [RDF::Raptor]:      https://ruby-rdf.github.com/rdf-raptor
-[RDF*]:             https://lists.w3.org/Archives/Public/public-rdf-star/
+[RDF*]:             https://w3c.github.io/rdf-star/rdf-star-cg-spec.html
 [LinkedData]:       https://ruby-rdf.github.com/linkeddata
 [JSON::LD]:         https://ruby-rdf.github.com/json-ld
 [RestClient]:       https://rubygems.org/gems/rest-client

data/VERSION

@@ -1 +1 @@
-3.1.3
+3.1.8

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

@@ -2,6 +2,7 @@ require 'stringio'
 require 'bigdecimal'
 require 'date'
 require 'time'
+require "ostruct"
 
 require 'rdf/version'
 require 'rdf/extensions'
@@ -76,6 +77,32 @@ module RDF
   # Utilities
   autoload :Util,        'rdf/util'
 
+  # CLI
+  autoload :CLI,         'rdf/cli'
+
+  ##
+  # Configuration, used open for configuring constants used within the codebase.
+  #
+  # @example set default cache size to be at most 10,000 entries
+  #
+  #   RDF.config.cache_size = 10_000
+  #
+  # @example set cache size for interned URIs to 5,000 entries
+  #
+  #   RDF.config.uri_cache_size = 5_000
+  #
+  # Defaults:
+  #   * `cache_size`: -1
+  #   * `uri_cache_size`: `cache_size`
+  #   * `node_cache_size`: `cache_size`
+  #
+  # @note cache configurations must be set before initial use, when the caches are allocated.
+  # @see RDF::Util::Cache.new
+  # @return [Object]
+  def self.config
+    @config ||= OpenStruct.new(cache_size: -1, uri_cache_size: nil, node_cache_size: nil)
+  end
+
   ##
   # Alias for `RDF::Resource.new`.
   #

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
@@ -162,6 +162,7 @@ module RDF
     # * `lambda` code run to execute command.
     # * `filter` Option values that must match for command to be used
     # * `control` Used to indicate how (if) command is displayed
+    # * `repository` Use this repository, if set
     # * `options` an optional array of `RDF::CLI::Option` describing command-specific options.
     # * `option_use`: A hash of option symbol to option usage, used for overriding the default status of an option for this command.
     # @return [Hash{Symbol => Hash{Symbol => Object}}]
@@ -296,6 +297,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,
@@ -487,6 +494,9 @@ module RDF
             raise ArgumentError, "Incompatible command #{c} used with option #{opt}=#{options[opt]}"
           end
         end
+
+        # The command may specify a repository instance to use
+        options[:repository] ||= COMMANDS[c.to_sym][:repository]
       end
 
       # Hacks for specific options
@@ -495,14 +505,18 @@ 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
+      # Allow repository to be set via option.
+      @repository = options[: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."
@@ -510,7 +524,10 @@ module RDF
 
       # Run each command in sequence
       cmds.each do |command|
-        COMMANDS[command.to_sym][:lambda].call(args, output: output, **options.merge(messages: messages))
+        COMMANDS[command.to_sym][:lambda].call(args,
+          output: output,
+          messages: messages,
+          **options.merge(repository: repository))
       end
 
       # Normalize messages

data/lib/rdf/model/list.rb

@@ -45,18 +45,27 @@ 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
     #
+    # @example use a transaction for block initialization
+    #     l = RDF::List(graph: graph, wrap_transaction: true) do |list|
+    #       list << RDF::Literal(1)
+    #       # list.graph.rollback will rollback all list changes within this block.
+    #     end
+    #     list.count #=> 1
+    #
     # @param  [RDF::Resource]         subject (RDF.nil)
     #   Subject should be an {RDF::Node}, not a {RDF::URI}. A list with an IRI head will not validate, but is commonly used to detect if a list is valid.
     # @param  [RDF::Graph]        graph (RDF::Graph.new)
     # @param  [Array<RDF::Term>]  values
     #   Any values which are not terms are coerced to `RDF::Literal`.
+    # @param [Boolean] wrap_transaction (false)
+    #   Wraps the callback in a transaction, and replaces the graph with that transaction for the duraction of the callback. This has the effect of allowing any list changes to be made atomically, or rolled back.
     # @yield  [list]
     # @yieldparam [RDF::List] list
-    def initialize(subject: nil, graph: nil, values: nil, &block)
+    def initialize(subject: nil, graph: nil, values: nil, wrap_transaction: false, &block)
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
       is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?
@@ -68,8 +77,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
@@ -78,9 +87,25 @@ module RDF
       end
 
       if block_given?
-        case block.arity
-          when 1 then block.call(self)
-          else instance_eval(&block)
+        if wrap_transaction
+          old_graph = @graph
+          begin
+            Transaction.begin(@graph, graph_name: @graph.graph_name, mutable: @graph.mutable?) do |trans|
+              @graph = trans
+              case block.arity
+                when 1 then block.call(self)
+                else instance_eval(&block)
+              end
+              trans.execute if trans.mutated?
+            end
+          ensure
+            @graph = old_graph
+          end
+        else
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
         end
       end
     end
@@ -175,7 +200,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 +218,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 +231,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 +245,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 +275,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 +563,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 +876,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 +888,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 +900,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 +912,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 +989,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/node.rb

@@ -13,18 +13,14 @@ module RDF
     include RDF::Resource
 
     ##
-    # Defines the maximum number of interned Node references that can be held
-    # cached in memory at any one time.
+    # Cache size may be set through {RDF.config} using `node_cache_size`.
     #
     # @note caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the graph from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used within the same document.
-    CACHE_SIZE = -1 # unlimited by default
-
-    ##
     # @return [RDF::Util::Cache]
     # @private
     def self.cache
       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
-      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+      @cache ||= RDF::Util::Cache.new(RDF.config.node_cache_size)
     end
 
     ##

data/lib/rdf/model/uri.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-require 'uri'
+require 'cgi'
 
 module RDF
   ##
@@ -27,11 +27,6 @@ module RDF
   class URI
     include RDF::Resource
 
-    ##
-    # Defines the maximum number of interned URI references that can be held
-    # cached in memory at any one time.
-    CACHE_SIZE = -1 # unlimited by default
-    
     # IRI components
     UCSCHAR = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
       [\\u00A0-\\uD7FF]|[\\uF900-\\uFDCF]|[\\uFDF0-\\uFFEF]|
@@ -117,11 +112,13 @@ module RDF
     ).freeze
 
     ##
+    # Cache size may be set through {RDF.config} using `uri_cache_size`.
+    #
     # @return [RDF::Util::Cache]
     # @private
     def self.cache
       require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
-      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+      @cache ||= RDF::Util::Cache.new(RDF.config.uri_cache_size)
     end
 
     ##
@@ -311,12 +308,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 +853,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 +909,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 +935,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 +1187,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 +1300,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/nquads.rb

@@ -69,9 +69,9 @@ module RDF
 
           begin
             unless blank? || read_comment
-              subject   = read_uriref || read_node || read_rdfstar || fail_subject
+              subject   = read_uriref || read_node || read_embTriple || fail_subject
               predicate = read_uriref(intern: true) || fail_predicate
-              object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+              object    = read_uriref || read_node || read_literal || read_embTriple || 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)

data/lib/rdf/ntriples/reader.rb

@@ -1,4 +1,7 @@
 # -*- encoding: utf-8 -*-
+
+require 'strscan'
+
 module RDF::NTriples
   ##
   # N-Triples parser.
@@ -210,7 +213,7 @@ module RDF::NTriples
       begin
         read_statement
       rescue RDF::ReaderError
-        value = read_uriref || read_node || read_literal || read_rdfstar
+        value = read_uriref || read_node || read_literal || read_embTriple
         log_recover
         value
       end
@@ -226,9 +229,9 @@ module RDF::NTriples
 
         begin
           unless blank? || read_comment
-            subject   = read_uriref || read_node || read_rdfstar || fail_subject
+            subject   = read_uriref || read_node || read_embTriple || fail_subject
             predicate = read_uriref(intern: true) || fail_predicate
-            object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+            object    = read_uriref || read_node || read_literal || read_embTriple || fail_object
 
             if validate? && !read_eos
               log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
@@ -244,11 +247,11 @@ module RDF::NTriples
 
     ##
     # @return [RDF::Statement]
-    def read_rdfstar
+    def read_embTriple
       if @options[:rdfstar] && match(ST_START)
-        subject   = read_uriref || read_node || read_rdfstar || fail_subject
+        subject   = read_uriref || read_node || read_embTriple || fail_subject
         predicate = read_uriref(intern: true) || fail_predicate
-        object    = read_uriref || read_node || read_literal || read_rdfstar || fail_object
+        object    = read_uriref || read_node || read_literal || read_embTriple || fail_object
         if !match(ST_END)
           log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
         end

data/lib/rdf/ntriples/writer.rb

@@ -227,7 +227,7 @@ module RDF::NTriples
     # @param  [RDF::Statement] statement
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [String]
-    def format_rdfstar(statement, **options)
+    def format_embTriple(statement, **options)
       "<<%s %s %s>>" % statement.to_a.map { |value| format_term(value, **options) }
     end
     ##

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.uniq.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/reader.rb

@@ -160,10 +160,10 @@ module RDF
         end,
         RDF::CLI::Option.new(
           symbol: :rdfstar,
-          control: :select,
-          datatype: [:PG, :SA],
-          on: ["--rdf-star MODE"],
-          description: "Parse RDF*, either in Property Graph mode (PG) or Separate Assertions mode (SA).") {|arg| arg.to_sym},
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--rdfstar"],
+          description: "Parse RDF*."),
         RDF::CLI::Option.new(
           symbol: :validate,
           datatype: TrueClass,
@@ -276,10 +276,8 @@ module RDF
     #   the encoding of the input stream
     # @param [Boolean]  intern       (true)
     #   whether to intern all parsed URIs
-    # @param [:PG, :SA] rdfstar      (nil)
+    # @param [Boolean] rdfstar      (false)
     #   support parsing RDF* statement resources.
-    #   If `:PG`, referenced statements are also emitted.
-    #   If `:SA`, referenced statements are not emitted.
     # @param [Hash]     prefixes     (Hash.new)
     #   the prefix mappings to use (not supported by all readers)
     # @param  [Hash{Symbol => Object}] options
@@ -295,7 +293,7 @@ module RDF
                    encoding:      Encoding::UTF_8,
                    intern:        true,
                    prefixes:      Hash.new,
-                   rdfstar:       nil,
+                   rdfstar:       false,
                    validate:      false,
                    **options,
                    &block)
@@ -401,9 +399,6 @@ module RDF
     # Statements are yielded in the order that they are read from the input
     # stream.
     #
-    # If the `rdfstar` option is `:PG` and triples include
-    # embedded statements, they are also enumerated.
-    #
     # @overload each_statement
     #   @yield  [statement]
     #     each statement
@@ -423,7 +418,6 @@ module RDF
           loop do
             st = read_statement
             block.call(st)
-            each_pg_statement(st, &block) if options[:rdfstar] == :PG
           end
         rescue EOFError
           rewind rescue nil
@@ -441,9 +435,6 @@ module RDF
     # Triples are yielded in the order that they are read from the input
     # stream.
     #
-    # If the `rdfstar` option is `:PG` and triples include
-    # embedded statements, they are also enumerated.
-    #
     # @overload each_triple
     #   @yield  [subject, predicate, object]
     #     each triple
@@ -464,10 +455,6 @@ module RDF
           loop do
             triple = read_triple
             block.call(*triple)
-            if options[:rdfstar] == :PG
-              block.call(*triple[0].to_a) if triple[0].is_a?(Statement)
-              block.call(*triple[2].to_a) if triple[2].is_a?(Statement)
-            end
           end
         rescue EOFError
           rewind rescue nil

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/cache.rb

@@ -17,6 +17,9 @@ module RDF; module Util
   # @see   http://en.wikipedia.org/wiki/Weak_reference
   # @since 0.2.0
   class Cache
+    # The configured cache capacity.
+    attr_reader :capacity
+
     ##
     # @private
     def self.new(*args)
@@ -36,8 +39,8 @@ module RDF; module Util
 
     ##
     # @param  [Integer] capacity
-    def initialize(capacity = -1)
-      @capacity = capacity
+    def initialize(capacity = nil)
+      @capacity = capacity || RDF.config.cache_size
       @cache  ||= {}
       @index  ||= {}
     end
@@ -106,7 +109,7 @@ module RDF; module Util
     class WeakRefCache < Cache
       ##
       # @param  [Integer] capacity
-      def initialize(capacity = -1)
+      def initialize(capacity = nil)
         require 'weakref' unless defined?(::WeakRef)
         super
       end

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

@@ -731,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
 
     ##

data/lib/rdf/writer.rb

@@ -516,7 +516,7 @@ module RDF
         when RDF::Literal   then format_literal(term, **options)
         when RDF::URI       then format_uri(term, **options)
         when RDF::Node      then format_node(term, **options)
-        when RDF::Statement then format_rdfstar(term, **options)
+        when RDF::Statement then format_embTriple(term, **options)
         else nil
       end
     end
@@ -574,7 +574,7 @@ module RDF
     # @return [String]
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
-    def format_rdfstar(value, **options)
+    def format_embTriple(value, **options)
       raise NotImplementedError.new("#{self.class}#format_statement") # override in subclasses
     end
 

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.1.3
+  version: 3.1.8
 platform: ruby
 authors:
 - Arto Bendiken
 - Ben Lavender
 - Gregg Kellogg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-16 00:00:00.000000000 Z
+date: 2020-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -164,42 +164,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.20
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.20
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: faraday_middleware
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '1.0'
 description: RDF.rb is a pure-Ruby library for working with Resource Description Framework
   (RDF) data.
 email: public-rdf-ruby@w3.org
@@ -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.2.3
+signing_key:
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.
 test_files: []