rdf-reasoner 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07635fa242cf39764de458b06e4afe87fbaddf311a37fb67c4e2a1137389ab20
-  data.tar.gz: 654c79cfc3d28e9ac29f890f264552c9c9af13d19aca0361cb79dfca19c38002
+  metadata.gz: 0e75c24da7eb57a1b7c670665192cfd023907a461ab813222231130699562965
+  data.tar.gz: 3d89941dde1e6cf0528ff3b70ea9019551524d85c4f09ec09b97125b36f868d8
 SHA512:
-  metadata.gz: b303be11f5f865989558acb9865c5a5cf55f2a16f464e14ad049b30ff316b87eec2006fa3ad6f13fd081332ae12a11fd1500d6cb66d75acebc59d1b95c351212
-  data.tar.gz: 5406d22674e0fe00252c6b26c60265e1e0dd8340317fae6c8f7cf2b2dd3223152a0fa065f47644878613e076754b6cd76de21b182047f0e272ed161e4f82af28
+  metadata.gz: 791384df059259071ece3543ada759724b64420d21e78ef01479fded2fbaabb7035cff17c4feb2f1e4d9dedffb1961d07db4271c095563b9b4ce7b12724a9cdb
+  data.tar.gz: 9925f559f0a2f77b7128561024bce44c577958a5dc7fb644eb05ca0e7cd2e307bc539b35c19de4e176922b2cda88bf21fec4fe77034de5e3ed596c4fd27c7bf1

data/README.md

@@ -1,4 +1,13 @@
-# rdf-reasoner
+# RDF::Reasoner
+
+A partial RDFS/OWL/schema.org reasoner for [RDF.rb][].
+
+[![Gem Version](https://badge.fury.io/rb/rdf-reasoner.png)](https://badge.fury.io/rb/rdf-reasoner)
+[![Build Status](https://github.com/ruby-rdf/rdf-reasoner/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/rdf-reasoner/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf-reasoner/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/rdf-reasoner?branch=develop)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
+
+## Description
 
 Reasons over RDFS/OWL vocabularies and schema.org to generate statements which are entailed based on base RDFS/OWL rules along with vocabulary information. It can also be used to ask specific questions, such as if a given object is consistent with the vocabulary ruleset. This can be used to implement [SPARQL Entailment][] Regimes and [RDF Schema][] entailment.
 
@@ -112,8 +121,8 @@ The `rdf` command-line interface is extended with `entail` and `lint` commands.
 
 ## Dependencies
 
-* [Ruby](https://ruby-lang.org/) (>= 2.4)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
 
 ## Mailing List
 
@@ -136,7 +145,9 @@ The `rdf` command-line interface is extended with `entail` and `lint` commands.
   list in the the `README`. Alphabetical order applies.
 * 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
 
@@ -147,7 +158,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [RDF]:              https://www.w3.org/RDF/
 [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
 [SPARQL]:           https://en.wikipedia.org/wiki/SPARQL
 [SPARQL Query]:     https://www.w3.org/TR/2013/REC-sparql11-query-20130321/
 [SPARQL Entailment]:https://www.w3.org/TR/sparql11-entailment/

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.8.0

data/lib/rdf/reasoner/extensions.rb

@@ -241,7 +241,7 @@ module RDF
         # Must be a defined term, not in RDF or RDFS vocabularies
         if term && term.class?
           # Warn against using a deprecated term
-          superseded = term.attributes[:'schema:supersededBy']
+          superseded = term.properties[:'http://schema.org/supersededBy']
           superseded = superseded.pname if superseded.respond_to?(:pname)
           (messages[:class] ||= {})[pname] = ["Term is superseded by #{superseded}"] if superseded
         else
@@ -266,7 +266,7 @@ module RDF
         # Must be a defined property
         if term.respond_to?(:property?) && term.property?
           # Warn against using a deprecated term
-          superseded = term.attributes[:'schema:supersededBy']
+          superseded = term.properties[:'http://schema.org/supersededBy']
           superseded = superseded.pname if superseded.respond_to?(:pname)
           (messages[:property] ||= {})[pname] = ["Term is superseded by #{superseded}"] if superseded
         else
@@ -285,7 +285,9 @@ module RDF
           ((messages[:property] ||= {})[pname] ||= []) << if !term.domain.empty?
            "Subject #{show_resource(stmt.subject)} not compatible with domain (#{Array(term.domain).map {|d| d.pname|| d}.join(',')})"
           else
-            "Subject #{show_resource(stmt.subject)} not compatible with domainIncludes (#{term.domainIncludes.map {|d| d.pname|| d}.join(',')})"
+            domains = Array(term.domainIncludes) +
+                      Array(term.properties[:'https://schema.org/domainIncludes'])
+            "Subject #{show_resource(stmt.subject)} not compatible with domainIncludes (#{domains.map {|d| d.pname|| d}.join(',')})"
           end
         end
 
@@ -300,7 +302,9 @@ module RDF
           ((messages[:property] ||= {})[pname] ||= []) << if !term.range.empty?
            "Object #{show_resource(stmt.object)} not compatible with range (#{Array(term.range).map {|d| d.pname|| d}.join(',')})"
           else
-            "Object #{show_resource(stmt.object)} not compatible with rangeIncludes (#{term.rangeIncludes.map {|d| d.pname|| d}.join(',')})"
+            ranges = Array(term.rangeIncludes) +
+                      Array(term.properties[:'https://schema.org/rangeIncludes'])
+            "Object #{show_resource(stmt.object)} not compatible with rangeIncludes (#{ranges.map {|d| d.pname|| d}.join(',')})"
           end
         end
       end

data/lib/rdf/reasoner/rdfs.rb

@@ -290,12 +290,12 @@ module RDF::Reasoner
               # XSD types are valid if the datatype matches, or they are plain and valid according to the grammar of the range
                 resource.datatype == range ||
                 resource.plain? && RDF::Literal.new(resource.value, datatype: range).valid?
-            elsif range.start_with?(RDF::Vocab::OGC)
+            elsif range.start_with?("http://ogp.me/ns/class#")
               case range
-              when RDF::Vocab::OGC.boolean_str
-                [RDF::Vocab::OGC.boolean_str, RDF::XSD.boolean].include?(resource.datatype) ||
+              when RDF::URI("http://ogp.me/ns/class#boolean_str")
+                [RDF::URI("http://ogp.me/ns/class#boolean_str"), RDF::XSD.boolean].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Boolean.new(resource.value).valid?
-              when RDF::Vocab::OGC.date_time_str
+              when RDF::URI("http://ogp.me/ns/class#date_time_str")
                 # Schema.org date based on ISO 8601, mapped to appropriate XSD types for validation
                 case resource
                 when RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime, RDF::Literal::Duration
@@ -303,27 +303,27 @@ module RDF::Reasoner
                 else
                   ISO_8601.match(resource.value)
                 end
-              when RDF::Vocab::OGC.determiner_str
+              when RDF::URI("http://ogp.me/ns/class#determiner_str")
                 # The lexical space: "", "the", "a", "an", and "auto".
                 resource.plain? && (%w(the a an auto) + [""]).include?(resource.value)
-              when RDF::Vocab::OGC.float_str
+              when RDF::URI("http://ogp.me/ns/class#float_str")
                 # A string representation of a 64-bit signed floating point number.  Example lexical values include "1.234", "-1.234", "1.2e3", "-1.2e3", and "7E-10".
-                [RDF::Vocab::OGC.float_str, RDF::Literal::Double, RDF::Literal::Float].include?(resource.datatype) ||
+                [RDF::URI("http://ogp.me/ns/class#float_str"), RDF::Literal::Double, RDF::Literal::Float].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-              when RDF::Vocab::OGC.integer_str
+              when RDF::URI("http://ogp.me/ns/class#integer_str")
                 resource.is_a?(RDF::Literal::Integer) ||
-                [RDF::Vocab::OGC.integer_str].include?(resource.datatype) ||
+                [RDF::URI("http://ogp.me/ns/class#integer_str")].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Integer.new(resource.value).valid?
-              when RDF::Vocab::OGC.mime_type_str
+              when RDF::URI("http://ogp.me/ns/class#mime_type_str")
                 # Valid mime type strings \(e.g., "application/mp3"\).
-                [RDF::Vocab::OGC.mime_type_str].include?(resource.datatype) ||
+                [RDF::URI("http://ogp.me/ns/class#mime_type_str")].include?(resource.datatype) ||
                 resource.plain? && resource.value =~ %r(^[\w\-\+]+/[\w\-\+]+$)
-              when RDF::Vocab::OGC.string
+              when RDF::URI("http://ogp.me/ns/class#string")
                 resource.plain?
-              when RDF::Vocab::OGC.url
+              when RDF::URI("http://ogp.me/ns/class#url")
                 # A string of Unicode characters forming a valid URL having the http or https scheme.
                 u = RDF::URI(resource.value)
-                resource.datatype == RDF::Vocab::OGC.url ||
+                resource.datatype == RDF::URI("http://ogp.me/ns/class#url") ||
                 resource.datatype == RDF::XSD.anyURI ||
                 resource.simple? && u.valid? && u.scheme.to_s =~ /^https?$/
               else

data/lib/rdf/reasoner/schema.rb

@@ -24,7 +24,9 @@ module RDF::Reasoner
     #   Fully entailed types of resource, if not provided, they are queried
     def domain_compatible_schema?(resource, queryable, options = {})
       raise RDF::Reasoner::Error, "#{self} can't get domains" unless property?
-      domains = Array(self.domainIncludes) - [RDF::OWL.Thing]
+      domains = Array(self.domainIncludes) +
+                Array(self.properties[:'https://schema.org/domainIncludes']) -
+                [RDF::OWL.Thing]
 
       # Fully entailed types of the resource
       types = entailed_types(resource, queryable, **options) unless domains.empty?
@@ -34,8 +36,8 @@ module RDF::Reasoner
 
       # Resource may still be acceptable if types include schema:Role, and any any other resource references `resource` using this property
       resource_acceptable ||
-        types.include?(RDF::Vocab::SCHEMA.Role) &&
-          !queryable.query({predicate: self, object: resource}).empty?
+        (types.include?(RDF::URI("http://schema.org/Role")) || types.include?(RDF::URI("https://schema.org/Role"))) &&
+        !queryable.query({predicate: self, object: resource}).empty?
     end
 
     ##
@@ -54,16 +56,23 @@ module RDF::Reasoner
     #   Fully entailed types of resource, if not provided, they are queried
     def range_compatible_schema?(resource, queryable, options = {})
       raise RDF::Reasoner::Error, "#{self} can't get ranges" unless property?
-      if !(ranges = Array(self.rangeIncludes) - [RDF::OWL.Thing]).empty?
+      if !(ranges = Array(self.rangeIncludes) +
+                    Array(self.properties[:'https://schema.org/rangeIncludes']) -
+                    [RDF::OWL.Thing]).empty?
         if resource.literal?
           ranges.any? do |range|
             case range
             when RDF::RDFS.Literal  then true
-            when RDF::Vocab::SCHEMA.Text   then resource.plain? || resource.datatype == RDF::Vocab::SCHEMA.Text
-            when RDF::Vocab::SCHEMA.Boolean
-              [RDF::Vocab::SCHEMA.Boolean, RDF::XSD.boolean].include?(resource.datatype) ||
+            when RDF::URI("http://schema.org/Text"), RDF::URI("https://schema.org/Text")
+              resource.plain? || resource.datatype == RDF::URI("http://schema.org/Text")
+            when RDF::URI("http://schema.org/Boolean"), RDF::URI("https://schema.org/Boolean")
+              [
+                RDF::URI("http://schema.org/Boolean"),
+                RDF::URI("https://schema.org/Boolean"),
+                RDF::XSD.boolean
+              ].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Boolean.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.Date
+            when RDF::URI("http://schema.org/Date"), RDF::URI("https://schema.org/Date")
               # Schema.org date based on ISO 8601, mapped to appropriate XSD types for validation
               case resource
               when RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime, RDF::Literal::Duration
@@ -71,35 +80,56 @@ module RDF::Reasoner
               else
                 ISO_8601.match(resource.value)
               end
-            when RDF::Vocab::SCHEMA.DateTime
-              resource.datatype == RDF::Vocab::SCHEMA.DateTime ||
+            when RDF::URI("http://schema.org/DateTime"), RDF::URI("https://schema.org/DateTime")
+              resource.datatype == RDF::URI("http://schema.org/DateTime") ||
+              resource.datatype == RDF::URI("https://schema.org/DateTime") ||
               resource.is_a?(RDF::Literal::DateTime) ||
               resource.plain? && RDF::Literal::DateTime.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.Duration
+            when RDF::URI("http://schema.org/Duration"), RDF::URI("https://schema.org/Duration")
               value = resource.value
               value = "P#{value}" unless value.start_with?("P")
-              resource.datatype == RDF::Vocab::SCHEMA.Duration ||
+              resource.datatype == RDF::URI("http://schema.org/Duration") ||
+              resource.datatype == RDF::URI("https://schema.org/Duration") ||
               resource.is_a?(RDF::Literal::Duration) ||
               resource.plain? && RDF::Literal::Duration.new(value).valid?
-            when RDF::Vocab::SCHEMA.Time
-              resource.datatype == RDF::Vocab::SCHEMA.Time ||
+            when RDF::URI("http://schema.org/Time"), RDF::URI("https://schema.org/Time")
+              resource.datatype == RDF::URI("http://schema.org/Time") ||
+              resource.datatype == RDF::URI("https://schema.org/Time") ||
               resource.is_a?(RDF::Literal::Time) ||
               resource.plain? && RDF::Literal::Time.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.Number
+            when RDF::URI("http://schema.org/Number"), RDF::URI("https://schema.org/Number")
               resource.is_a?(RDF::Literal::Numeric) ||
-              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float, RDF::Vocab::SCHEMA.Integer].include?(resource.datatype) ||
+              [
+                RDF::URI("http://schema.org/Number"),
+                RDF::URI("http://schema.org/Float"),
+                RDF::URI("http://schema.org/Integer"),
+                RDF::URI("https://schema.org/Number"),
+                RDF::URI("https://schema.org/Float"),
+                RDF::URI("https://schema.org/Integer"),
+              ].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Integer.new(resource.value).valid? ||
               resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.Float
+            when RDF::URI("http://schema.org/Float"), RDF::URI("https://schema.org/Float")
               resource.is_a?(RDF::Literal::Double) ||
-              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float].include?(resource.datatype) ||
+              [
+                RDF::URI("http://schema.org/Number"),
+                RDF::URI("http://schema.org/Float"),
+                RDF::URI("https://schema.org/Number"),
+                RDF::URI("https://schema.org/Float"),
+              ].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.Integer
+            when RDF::URI("http://schema.org/Integer"), RDF::URI("https://schema.org/Integer")
               resource.is_a?(RDF::Literal::Integer) ||
-              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Integer].include?(resource.datatype) ||
+              [
+                RDF::URI("http://schema.org/Number"),
+                RDF::URI("http://schema.org/Integer"),
+                RDF::URI("https://schema.org/Number"),
+                RDF::URI("https://schema.org/Integer"),
+              ].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Integer.new(resource.value).valid?
-            when RDF::Vocab::SCHEMA.URL
-              resource.datatype == RDF::Vocab::SCHEMA.URL ||
+            when RDF::URI("http://schema.org/URL"), RDF::URI("https://schema.org/URL")
+              resource.datatype == RDF::URI("http://schema.org/URL") ||
+              resource.datatype == RDF::URI("https://schema.org/URL") ||
               resource.datatype == RDF::XSD.anyURI ||
               resource.plain? && RDF::Literal::AnyURI.new(resource.value).valid?
             else
@@ -117,11 +147,21 @@ module RDF::Reasoner
               end
             end
           end
-        elsif %w(True False).map {|v| RDF::Vocab::SCHEMA[v]}.include?(resource) && ranges.include?(RDF::Vocab::SCHEMA.Boolean)
+        elsif %w(
+            http://schema.org/True
+            http://schema.org/False
+            https://schema.org/True
+            https://schema.org/False
+          ).include?(resource) &&
+          (ranges.include?(RDF::URI("http://schema.org/Boolean")) || ranges.include?(RDF::URI("https://schema.org/Boolean")))
           true # Special case for schema boolean resources
-        elsif ranges.include?(RDF::Vocab::SCHEMA.URL) && resource.uri?
+        elsif (ranges.include?(RDF::URI("http://schema.org/URL")) || ranges.include?(RDF::URI("https://schema.org/URL"))) &&
+              resource.uri?
           true # schema:URL matches URI resources
-        elsif ranges == [RDF::Vocab::SCHEMA.Text] && resource.uri?
+        elsif ranges == [RDF::URI("http://schema.org/Text")] && resource.uri?
+          # Allowed if resource is untyped
+          entailed_types(resource, queryable, **options).empty?
+        elsif ranges == [RDF::URI("https://schema.org/Text")] && resource.uri?
           # Allowed if resource is untyped
           entailed_types(resource, queryable, **options).empty?
         elsif literal_range?(ranges)
@@ -137,7 +177,7 @@ module RDF::Reasoner
           resource_acceptable ||
 
           # Resource also acceptable if it is a Role, and the Role object contains the same predicate having a compatible object
-          types.include?(RDF::Vocab::SCHEMA.Role) &&
+          (types.include?(RDF::URI("http://schema.org/Role")) || types.include?(RDF::URI("https://schema.org/Role"))) &&
             queryable.query({subject: resource, predicate: self}).any? do |stmt|
               acc = self.range_compatible_schema?(stmt.object, queryable)
               acc
@@ -158,9 +198,25 @@ module RDF::Reasoner
     def literal_range?(ranges)
       ranges.all? do |range|
         case range
-        when RDF::RDFS.Literal, RDF::Vocab::SCHEMA.Text, RDF::Vocab::SCHEMA.Boolean, RDF::Vocab::SCHEMA.Date,
-             RDF::Vocab::SCHEMA.DateTime, RDF::Vocab::SCHEMA.Time, RDF::Vocab::SCHEMA.URL,
-             RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float, RDF::Vocab::SCHEMA.Integer
+        when RDF::RDFS.Literal,
+             RDF::URI("http://schema.org/Text"),
+             RDF::URI("http://schema.org/Boolean"),
+             RDF::URI("http://schema.org/Date"),
+             RDF::URI("http://schema.org/DateTime"),
+             RDF::URI("http://schema.org/Time"),
+             RDF::URI("http://schema.org/URL"),
+             RDF::URI("http://schema.org/Number"),
+             RDF::URI("http://schema.org/Float"),
+             RDF::URI("http://schema.org/Integer"),
+             RDF::URI("https://schema.org/Text"),
+             RDF::URI("https://schema.org/Boolean"),
+             RDF::URI("https://schema.org/Date"),
+             RDF::URI("https://schema.org/DateTime"),
+             RDF::URI("https://schema.org/Time"),
+             RDF::URI("https://schema.org/URL"),
+             RDF::URI("https://schema.org/Number"),
+             RDF::URI("https://schema.org/Float"),
+             RDF::URI("https://schema.org/Integer")
           true
         else
           # If this is an XSD range, look for appropriate literal

data/lib/rdf/reasoner.rb

@@ -1,6 +1,5 @@
 require 'rdf'
 require 'rdf/reasoner/extensions'
-require 'rdf/vocab'
 
 module RDF
   ##

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Gregg Kellogg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-10 00:00:00.000000000 Z
+date: 2021-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,96 +16,84 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rdf-vocab
+  name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rdf-xsd
+  name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :runtime
+        version: '3.2'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rdf-spec
+  name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
@@ -126,28 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     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'
 description: Reasons over RDFS/OWL vocabularies to generate statements which are entailed
   based on base RDFS/OWL rules along with vocabulary information. It can also be used
   to ask specific questions, such as if a given object is consistent with the vocabulary
@@ -172,7 +160,7 @@ homepage: https://github.com/ruby-rdf/rdf-reasoner
 licenses:
 - Unlicense
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -180,15 +168,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.3
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb
 test_files: []