shex 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fdc22fc0cbd72f02a6a807fb42af927c8b775a50
-  data.tar.gz: 28cf889e643e7132959045b03142efd0a20397f7
+SHA256:
+  metadata.gz: d590c5b6411af716a57b781db5d2957701c197f1ee0a35ade6934b9012f8a4ea
+  data.tar.gz: f8ebee1f895654763ce8bc69b400aef5aaf5f57e36ccddbdb3326cbb0da5c863
 SHA512:
-  metadata.gz: e54c857b51c4ac594df2809b97e358bb2bd2fe4e83a1ad7ec91da1022ef9b2293f71de5cb2d88f1b3a529dd053bda53d65961ab9bab20f07f756c22947fe26a3
-  data.tar.gz: '058b65943bf484559158f249abbbdce55ce725759ac9312a06f8e56ed86eb3170e5a3a941388f38260e982cec18d02b592e89cafe96e2c1df133e97b7e908736'
+  metadata.gz: afb67c8fcb7c69393d60e70a8035e7066e5a4fcb4009a64232d82cc3b724758bd2cdcc42774e49765a32d2b15b87b9dd5a74ae593b840f969022ba9def8ae89c
+  data.tar.gz: d8c30c1ae94fcbd59cdb17f8190daf2cda101471e5076d76b81f80645fe8b26d72eca48c385ee0e73c5772f15415511b16883527c9401aa010b2a72f299976c6

data/README.md

@@ -8,6 +8,7 @@ This is a pure-Ruby library for working with the [Shape Expressions Language][Sh
 [![Build Status](https://travis-ci.org/ruby-rdf/shex.png?branch=master)](http://travis-ci.org/ruby-rdf/shex)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/shex/badge.svg)](https://coveralls.io/r/ruby-rdf/shex)
 [![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)
+[![DOI](https://zenodo.org/badge/74419330.svg)](https://zenodo.org/badge/latestdoi/74419330)
 
 ## Features
 
@@ -192,8 +193,8 @@ The result of parsing either ShExC or ShExJ is the creation of a set of executab
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (~> 2.2)
+* [Ruby](http://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.1)
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.6.0

data/lib/shex.rb

@@ -33,13 +33,13 @@ module ShEx
   # @raise  (see ShEx::Parser#parse)
   def self.parse(expression, format: 'shexc', **options)
     case format.to_s
-    when 'shexc' then Parser.new(expression, options).parse
+    when 'shexc' then Parser.new(expression, **options).parse
     when 'shexj'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_shexj(JSON.parse(expression), options)
+      Algebra.from_shexj(JSON.parse(expression), **options)
     when 'sxp'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_sxp(expression, options)
+      Algebra.from_sxp(expression, **options)
     else raise "Unknown expression format: #{format.inspect}"
     end
   end
@@ -56,8 +56,8 @@ module ShEx
   # @return (see ShEx::Parser#parse)
   # @raise  (see ShEx::Parser#parse)
   def self.open(filename, format: 'shexc', **options, &block)
-    RDF::Util::File.open_file(filename, options) do |file|
-      self.parse(file, options.merge(format: format))
+    RDF::Util::File.open_file(filename, **options) do |file|
+      self.parse(file, format: format, **options)
     end
   end
 
@@ -73,10 +73,10 @@ module ShEx
   # @return (see ShEx::Algebra::Schema#execute)
   # @raise (see ShEx::Algebra::Schema#execute)
   def self.execute(expression, queryable, map, format: 'shexc', **options)
-    shex = self.parse(expression, options.merge(format: format))
+    shex = self.parse(expression, format: format, **options)
     queryable = queryable || RDF::Graph.new
 
-    shex.execute(queryable, map, options)
+    shex.execute(queryable, map, **options)
   end
 
   ##
@@ -91,10 +91,10 @@ module ShEx
   # @return (see ShEx::Algebra::Schema#satisfies?)
   # @raise (see ShEx::Algebra::Schema#satisfies?)
   def self.satisfies?(expression, queryable, map, format: 'shexc', **options)
-    shex = self.parse(expression, options.merge(format: format))
+    shex = self.parse(expression, format: format, **options)
     queryable = queryable || RDF::Graph.new
 
-    shex.satisfies?(queryable, map, options)
+    shex.satisfies?(queryable, map, **options)
   end
 
   ##
@@ -116,7 +116,7 @@ module ShEx
     # @param  [String, #to_s]          message
     # @param  [Hash{Symbol => Object}] options
     # @option options [Integer]        :code (422)
-    def initialize(message, options = {})
+    def initialize(message, **options)
       @code = options.fetch(:status_code, 422)
       super(message.to_s)
     end

data/lib/shex/algebra.rb

@@ -50,7 +50,7 @@ module ShEx
     # @option options [RDF::URI] :base
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash)
       klass = case operator['type']
       when 'Annotation'         then Annotation
@@ -76,7 +76,7 @@ module ShEx
       else raise ArgumentError, "unknown type #{operator['type'].inspect}"
       end
 
-      klass.from_shexj(operator, options)
+      klass.from_shexj(operator, **options)
     end
   end
 end

data/lib/shex/algebra/and.rb

@@ -19,7 +19,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeAnd'
       raise ArgumentError, "missing shapeExprs in #{operator.inspect}" unless operator.has_key?('shapeExprs')
       super

data/lib/shex/algebra/annotation.rb

@@ -7,7 +7,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Annotation"
       raise ArgumentError, "missing predicate in #{operator.inspect}" unless operator.has_key?('predicate')
       raise ArgumentError, "missing object in #{operator.inspect}" unless operator.has_key?('object')

data/lib/shex/algebra/each_of.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'EachOf'
       raise ArgumentError, "missing expressions in #{operator.inspect}" unless operator.has_key?('expressions')
       super

data/lib/shex/algebra/node_constraint.rb

@@ -9,7 +9,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'NodeConstraint'
       super
     end

data/lib/shex/algebra/not.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeNot'
       raise ArgumentError, "missing shapeExpr in #{operator.inspect}" unless operator.has_key?('shapeExpr')
       super

data/lib/shex/algebra/one_of.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'OneOf'
       raise ArgumentError, "missing expressions in #{operator.inspect}" unless operator.has_key?('expressions')
       super

data/lib/shex/algebra/operator.rb

@@ -26,7 +26,7 @@ module ShEx::Algebra
     # @overload initialize(*operands)
     #   @param  [Array<RDF::Term>] operands
     #
-    # @overload initialize(*operands, options)
+    # @overload initialize(*operands, **options)
     #   @param  [Array<RDF::Term>] operands
     #   @param  [Hash{Symbol => Object}] options
     #     any additional options
@@ -260,7 +260,7 @@ module ShEx::Algebra
     # @option options [RDF::URI] :base
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       options[:context] ||= JSON::LD::Context.parse(ShEx::CONTEXT)
       operands = []
       id = nil
@@ -268,21 +268,21 @@ module ShEx::Algebra
       operator.each do |k, v|
         case k
         when /length|clusive|digits/           then operands << [k.to_sym, RDF::Literal(v)]
-        when 'id'                              then id = iri(v, options)
+        when 'id'                              then id = iri(v, **options)
         when 'flags'                           then ; # consumed in pattern below
         when 'min', 'max'                      then operands << [k.to_sym, (v == -1 ? '*' : v)]
         when 'inverse', 'closed'               then operands << k.to_sym
         when 'nodeKind'                        then operands << v.to_sym
-        when 'object'                          then operands << value(v, options)
+        when 'object'                          then operands << value(v, **options)
         when 'languageTag'                     then operands << v
         when 'pattern'
           # Include flags as well
           operands << [:pattern, RDF::Literal(v), operator['flags']].compact
         when 'start'
           if v.is_a?(String)
-            operands << Start.new(iri(v, options))
+            operands << Start.new(iri(v, **options))
           else
-            operands << Start.new(ShEx::Algebra.from_shexj(v, options))
+            operands << Start.new(ShEx::Algebra.from_shexj(v, **options))
           end
         when '@context'                        then
           options[:context] = JSON::LD::Context.parse(v)
@@ -290,47 +290,47 @@ module ShEx::Algebra
         when 'shapes'
           operands << case v
           when Array
-            [:shapes] + v.map {|vv| ShEx::Algebra.from_shexj(vv, options)}
+            [:shapes] + v.map {|vv| ShEx::Algebra.from_shexj(vv, **options)}
           else
             raise "Expected value of shapes #{v.inspect}"
           end
         when 'stem', 'name'
           # Value may be :wildcard for stem
           if [IriStem, IriStemRange, SemAct].include?(self)
-            operands << (v.is_a?(Symbol) ? v : value(v, options))
+            operands << (v.is_a?(Symbol) ? v : value(v, **options))
           else
             operands << v
           end
-        when 'predicate' then operands << [:predicate, iri(v, options)]
+        when 'predicate' then operands << [:predicate, iri(v, **options)]
         when 'extra', 'datatype'
           v = [v] unless v.is_a?(Array)
-          operands << (v.map {|op| iri(op, options)}).unshift(k.to_sym)
+          operands << (v.map {|op| iri(op, **options)}).unshift(k.to_sym)
         when 'exclusions'
           v = [v] unless v.is_a?(Array)
           operands << v.map do |op|
             if op.is_a?(Hash) && op.has_key?('type')
-              ShEx::Algebra.from_shexj(op, options)
+              ShEx::Algebra.from_shexj(op, **options)
             elsif [IriStem, IriStemRange].include?(self)
-              value(op, options)
+              value(op, **options)
             else
               RDF::Literal(op)
             end
           end.unshift(:exclusions)
         when 'semActs', 'startActs', 'annotations'
           v = [v] unless v.is_a?(Array)
-          operands += v.map {|op| ShEx::Algebra.from_shexj(op, options)}
+          operands += v.map {|op| ShEx::Algebra.from_shexj(op, **options)}
         when 'expression', 'expressions', 'shapeExpr', 'shapeExprs', 'valueExpr'
           v = [v] unless v.is_a?(Array)
           operands += v.map do |op|
             # It's a URI reference to a Shape
-            op.is_a?(String) ? iri(op, options) : ShEx::Algebra.from_shexj(op, options) 
+            op.is_a?(String) ? iri(op, **options) : ShEx::Algebra.from_shexj(op, **options) 
           end
         when 'code'
           operands << v
         when 'values'
           v = [v] unless v.is_a?(Array)
           operands += v.map do |op|
-            Value.new(value(op, options))
+            Value.new(value(op, **options))
           end
         end
       end
@@ -476,14 +476,14 @@ module ShEx::Algebra
     # @option options [JSON::LD::Context] :context
     # @return [RDF::Value]
     def iri(value, options = @options)
-      self.class.iri(value, options)
+      self.class.iri(value, **options)
     end
 
     # Create URIs
     # @param  (see #iri)
     # @option (see #iri)
     # @return (see #iri)
-    def self.iri(value, options)
+    def self.iri(value, **options)
       # If we have a base URI, use that when constructing a new URI
       base_uri = options[:base_uri]
 
@@ -492,7 +492,7 @@ module ShEx::Algebra
         # A JSON-LD node reference
         v = options[:context].expand_value(value)
         raise "Expected #{value.inspect} to be a JSON-LD Node Reference" unless JSON::LD::Utils.node_reference?(v)
-        self.iri(v['@id'], options)
+        self.iri(v['@id'], **options)
       when RDF::URI
         if base_uri && value.relative?
           base_uri.join(value)
@@ -530,26 +530,26 @@ module ShEx::Algebra
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [RDF::Value]
     def value(value, options = @options)
-      self.class.value(value, options)
+      self.class.value(value, **options)
     end
 
     # Create Values, with "clever" matching to see if it might be a value, IRI or BNode.
     # @param  (see #value)
     # @option (see #value)
     # @return (see #value)
-    def self.value(value, options)
+    def self.value(value, **options)
       # If we have a base URI, use that when constructing a new URI
       case value
       when Hash
         # Either a value object or a node reference
         if value['uri'] || value['@id']
-          iri(value['uri'] || value['@id'], options)
+          iri(value['uri'] || value['@id'], **options)
         elsif value['value'] || value['@value']
           RDF::Literal(value['value'] || value['@value'], datatype: value['type'] || value['@type'], language: value['language'] || value['@language'])
         else
-          ShEx::Algebra.from_shexj(value, options)
+          ShEx::Algebra.from_shexj(value, **options)
         end
-      else iri(value, options)
+      else iri(value, **options)
       end
     end
 
@@ -681,7 +681,7 @@ module ShEx::Algebra
       #   the first operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, options = {})
+      def initialize(arg1, **options)
         raise ArgumentError, "wrong number of arguments (given 2, expected 1)" unless options.is_a?(Hash)
         super
       end
@@ -703,7 +703,7 @@ module ShEx::Algebra
       #   the second operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, arg2, options = {})
+      def initialize(arg1, arg2, **options)
         raise ArgumentError, "wrong number of arguments (given 3, expected 2)" unless options.is_a?(Hash)
         super
       end

data/lib/shex/algebra/or.rb

@@ -19,7 +19,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeOr'
       raise ArgumentError, "missing shapeExprs in #{operator.inspect}" unless operator.is_a?(Hash) && operator.has_key?('shapeExprs')
       super

data/lib/shex/algebra/schema.rb

@@ -19,7 +19,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Schema"
       super
     end
@@ -51,7 +51,7 @@ module ShEx::Algebra
       @graph, @shapes_entered, results = graph, {}, {}
       @external_schemas = shapeExterns
       @extensions = {}
-      focus = Array(focus).map {|f| value(f, options)}
+      focus = Array(focus).map {|f| value(f, **options)}
 
       logger = options[:logger] || @options[:logger]
       each_descendant do |op|

data/lib/shex/algebra/semact.rb

@@ -7,7 +7,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "SemAct"
       raise ArgumentError, "missing name in #{operator.inspect}" unless operator.has_key?('name')
       code = operator.delete('code')

data/lib/shex/algebra/shape.rb

@@ -23,7 +23,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Shape"
       super
     end

data/lib/shex/algebra/stem.rb

@@ -7,7 +7,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && %w(IriStem LiteralStem LanguageStem).include?(operator['type'])
       raise ArgumentError, "missing stem in #{operator.inspect}" unless operator.has_key?('stem')
       super

data/lib/shex/algebra/stem_range.rb

@@ -7,7 +7,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && %w(IriStemRange LiteralStemRange LanguageStemRange).include?(operator['type'])
       raise ArgumentError, "missing stem in #{operator.inspect}" unless operator.has_key?('stem')
 
@@ -21,11 +21,11 @@ module ShEx::Algebra
         # Remove "Range" from type
         case operator['type']
         when 'IriStemRange'
-          IriStem.from_shexj(operator.merge('type' => 'IriStem'), options)
+          IriStem.from_shexj(operator.merge('type' => 'IriStem'), **options)
         when 'LiteralStemRange'
-          LiteralStem.from_shexj(operator.merge('type' => 'LiteralStem'), options)
+          LiteralStem.from_shexj(operator.merge('type' => 'LiteralStem'), **options)
         when 'LanguageStemRange'
-          LanguageStem.from_shexj(operator.merge('type' => 'LanguageStem'), options)
+          LanguageStem.from_shexj(operator.merge('type' => 'LanguageStem'), **options)
         end
       end
     end

data/lib/shex/algebra/triple_constraint.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'TripleConstraint'
       raise ArgumentError unless operator.has_key?('predicate')
       super

data/lib/shex/format.rb

@@ -25,7 +25,7 @@ module ShEx
           description: "Validate repository given shape",
           help: "shex [--shape Resource] [--focus Resource] [--schema-input STRING] [--schema STRING] file",
           parse: true,
-          lambda: -> (argv, options) do
+          lambda: -> (argv, **options) do
             options[:schema_input] ||= case options[:schema]
             when IO, StringIO then options[:schema]
             else RDF::Util::File.open_file(options[:schema]) {|f| f.read}
@@ -44,7 +44,7 @@ module ShEx
               shape = options.delete(:shape)
               map = shape ? {focus => shape} : {}
               begin
-                res = shex.execute(RDF::CLI.repository, map, options.merge(focus: focus))
+                res = shex.execute(RDF::CLI.repository, map, focus: focus, **options)
                 options[:messages][:shex] = {
                   result: ["Satisfied shape."],
                   detail: [SXP::Generator.string(res.to_sxp_bin)]

data/lib/shex/parser.rb

@@ -178,7 +178,7 @@ module ShEx
       expressions << Algebra::Start.new(data[:start]) if data[:start]
       expressions << data[:shapes].unshift(:shapes) if data[:shapes]
 
-      input[:schema] = Algebra::Schema.new(*expressions, options)
+      input[:schema] = Algebra::Schema.new(*expressions, **options)
       self
     end
 
@@ -730,7 +730,7 @@ module ShEx
     # @raise [ShEx::NotSatisfied] if not satisfied
     # @raise [ShEx::ParseError] when a syntax error is detected
     # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
-    def initialize(input = nil, options = {}, &block)
+    def initialize(input = nil, **options, &block)
       @input = case input
       when IO, StringIO then input.read
       else input.to_s.dup
@@ -778,10 +778,13 @@ module ShEx
     # @see http://www.w3.org/TR/sparql11-query/#sparqlAlgebra
     # @see http://axel.deri.ie/sparqltutorial/ESWC2007_SPARQL_Tutorial_unit2b.pdf
     def parse(prod = START)
-      ll1_parse(@input, prod.to_sym, @options.merge(branch: BRANCH,
-                                                    first: FIRST,
-                                                    follow: FOLLOW,
-                                                    whitespace: WS)
+      ll1_parse(@input,
+        prod.to_sym,
+        branch: BRANCH,
+        first: FIRST,
+        follow: FOLLOW,
+        whitespace: WS,
+        **@options
       ) do |context, *data|
         case context
         when :trace
@@ -929,7 +932,7 @@ module ShEx
     end
 
     # Create a literal
-    def literal(value, options = {})
+    def literal(value, **options)
       options = options.dup
       # Internal representation is to not use xsd:string, although it could arguably go the other way.
       options.delete(:datatype) if options[:datatype] == RDF::XSD.string

metadata

@@ -1,225 +1,183 @@
 --- !ruby/object:Gem::Specification
 name: shex
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-14 00:00:00.000000000 Z
+date: 2019-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: json-ld-preloaded
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: ebnf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: sxp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.2'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.20
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.20
 description: Implements ShExC and ShEx JSON.
 email: public-rdf-ruby@w3.org
 executables: []
@@ -275,15 +233,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rdf
-rubygems_version: 2.6.14
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Implementation of Shape Expressions (ShEx) for RDF.rb