rdf-reasoner 0.5.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 651a1431487e77d50420f0c33506df9d756e7eab48790589bdfacdc404b88fea
-  data.tar.gz: 66c536de0f20de0fe2f50be36e8a712d24efd4e1ea7674b4bff234d91a827272
+  metadata.gz: 9089d2c2502a1b5bbb19919650e0cf29d447487c219c4f5ebd362b9146204e09
+  data.tar.gz: 9f0ffb2e5ec7b15bbd1a6773bcd7abf0dc3f2f2f55f61b9128affd5ed3ab9fa7
 SHA512:
-  metadata.gz: 551d92044542d411803d75619a6f0d38d5cae5ae4331f7b11109006518a5db6c1fe8f7589d343e915b2e8187997a20fb68917771ebf5eba9297d0cc721e76be3
-  data.tar.gz: 47ee7417fdf42130820419558718332ad77748386cec3d8ef4513e5e711b299fd4bdabe5500a12eb1effdc55acb19ba5a9bce41e3e4ef63ec2510ace662c9a0b
+  metadata.gz: 9d7ca4b250631e17f869e0c4161765c0af68cace0df7631a292cb9a3da7613140e6176b03d0c6a7692ad0a397e4448779d3f1dba6449d94f9f1ecfdb0a96dac2
+  data.tar.gz: 3b0320de434a264a235423b4e5c5b06b2430861f26931f7c1cdee4dcb78ad9396ecede761fd316219a71e99039f54fd3ac194e3cfe4744be50290064bcaa4308

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.
 
@@ -22,6 +31,14 @@ Domain and Range entailment include specific rules for schema.org vocabularies.
 * If `resource` is of type `schema:Role`, it is range acceptable if it has the same property with an acceptable value.
 * If `resource` is of type `rdf:List` (must be previously entailed), it is range acceptable if all members of the list are otherwise range acceptable on the same property.
 
+### Limiting vocabularies used for reasoning
+
+As loading vocabularies can dominate processing time, the `RDF::Vocabulary.limit_vocabs` method can be used to set a specific set of vocabularies over which to reason. For example:
+
+    RDF::Vocabulary.limit_vocabs(:rdf, :rdf, :schema)
+
+will limit the vocabularies which are returned from `RDF::Vocabulary.each`, which is used for reasoning and other operations over vocabularies and terms.
+    
 ## Examples
 ### Determine super-classes of a class
 
@@ -104,8 +121,8 @@ The `rdf` command-line interface is extended with `entail` and `lint` commands.
 
 ## Dependencies
 
-* [Ruby](https://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.0)
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
 
 ## Mailing List
 
@@ -128,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
 
@@ -139,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.5.3
+0.7.1

data/lib/rdf/reasoner.rb

@@ -1,12 +1,11 @@
 require 'rdf'
 require 'rdf/reasoner/extensions'
-require 'rdf/vocab'
 
 module RDF
   ##
   # RDFS/OWL reasonsing for RDF.rb.
   #
-  # @see http://www.w3.org/TR/2013/REC-sparql11-entailment-20130321/
+  # @see https://www.w3.org/TR/2013/REC-sparql11-entailment-20130321/
   # @author [Gregg Kellogg](https://greggkellogg.net/)
   module Reasoner
     require 'rdf/reasoner/format'
@@ -15,7 +14,7 @@ module RDF
     autoload :Schema,  'rdf/reasoner/schema'
     autoload :VERSION, 'rdf/reasoner/version'
 
-    # See http://www.pelagodesign.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/
+    # See https://www.pelagodesign.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/
     #
     # 
     ISO_8601 =  %r(^

data/lib/rdf/reasoner/extensions.rb

@@ -91,7 +91,7 @@ module RDF
     #   Fully entailed types of resource, if not provided, they are queried
     def domain_compatible?(resource, queryable, options = {})
       %w(owl rdfs schema).map {|r| "domain_compatible_#{r}?".to_sym}.all? do |meth|
-        !self.respond_to?(meth) || self.send(meth, resource, queryable, options)
+        !self.respond_to?(meth) || self.send(meth, resource, queryable, **options)
       end
     end
 
@@ -233,7 +233,7 @@ module RDF
       messages = {}
 
       # Check for defined classes in known vocabularies
-      self.query(predicate: RDF.type) do |stmt|
+      self.query({predicate: RDF.type}) do |stmt|
         vocab = RDF::Vocabulary.find(stmt.object)
         term = (RDF::Vocabulary.find_term(stmt.object) rescue nil) if vocab
         pname = term ? term.pname : stmt.object.pname
@@ -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
@@ -264,9 +264,9 @@ module RDF
         end
 
         # Must be a defined property
-        if term && term.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
@@ -275,7 +275,7 @@ module RDF
         end
 
         # See if type of the subject is in the domain of this predicate
-        resource_types[stmt.subject] ||= self.query(subject: stmt.subject, predicate: RDF.type).
+        resource_types[stmt.subject] ||= self.query({subject: stmt.subject, predicate: RDF.type}).
         map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
           flatten.
           uniq.
@@ -290,7 +290,7 @@ module RDF
         end
 
         # Make sure that if ranges are defined, the object has an appropriate type
-        resource_types[stmt.object] ||= self.query(subject: stmt.object, predicate: RDF.type).
+        resource_types[stmt.object] ||= self.query({subject: stmt.object, predicate: RDF.type}).
           map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
           flatten.
           uniq.
@@ -316,7 +316,7 @@ module RDF
     def show_resource(resource)
       if resource.node?
         resource.to_ntriples + '(' +
-          self.query(subject: resource, predicate: RDF.type).
+          self.query({subject: resource, predicate: RDF.type}).
             map {|s| s.object.uri? ? s.object.pname : s.object.to_ntriples}
             .join(',') +
           ')'

data/lib/rdf/reasoner/owl.rb

@@ -50,7 +50,7 @@ module RDF::Reasoner
         if self.predicate == RDF.type
           if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
             term._entail_equivalentClass do |t|
-              statements << RDF::Statement(self.to_h.merge(object: t, inferred: true))
+              statements << RDF::Statement(**self.to_h.merge(object: t, inferred: true))
             end
           end
         end
@@ -89,7 +89,7 @@ module RDF::Reasoner
         statements = []
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term._entail_equivalentProperty do |t|
-            statements << RDF::Statement(self.to_h.merge(predicate: t, inferred: true))
+            statements << RDF::Statement(**self.to_h.merge(predicate: t, inferred: true))
           end
         end
         statements.each {|s| yield s} if block_given?

data/lib/rdf/reasoner/rdfs.rb

@@ -74,7 +74,7 @@ module RDF::Reasoner
           if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
             term._entail_subClassOf do |t|
               next if t.node? # Don't entail BNodes
-              statements << RDF::Statement(self.to_h.merge(object: t, inferred: true))
+              statements << RDF::Statement(**self.to_h.merge(object: t, inferred: true))
             end
           end
           #$stderr.puts("subClassf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
@@ -122,7 +122,7 @@ module RDF::Reasoner
 
     ##
     # For a Term: yield or return inferred subPropertyOf relationships by recursively applying to named super classes to get a complete set of classes in the ancestor chain of this class
-    # For a Statement: yield or return inferred statements having a subPropertyOf relationship to predicate of this statement
+    # For a Statement: yield or return inferred statements having a subPropertyOf relationship to predicate of this statements
     # @private
     def _entail_subPropertyOf
       case self
@@ -143,7 +143,7 @@ module RDF::Reasoner
         statements = []
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term._entail_subPropertyOf do |t|
-            statements << RDF::Statement(self.to_h.merge(predicate: t, inferred: true))
+            statements << RDF::Statement(**self.to_h.merge(predicate: t, inferred: true))
           end
           #$stderr.puts("subPropertyOf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         end
@@ -208,7 +208,7 @@ module RDF::Reasoner
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.domain.each do |t|
             next if t.node? # Don't entail BNodes
-            statements << RDF::Statement(self.to_h.merge(predicate: RDF.type, object: t, inferred: true))
+            statements << RDF::Statement(**self.to_h.merge(predicate: RDF.type, object: t, inferred: true))
           end
         end
         #$stderr.puts("domain(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
@@ -229,7 +229,7 @@ module RDF::Reasoner
         if object.resource? && term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.range.each do |t|
             next if t.node? # Don't entail BNodes
-            statements << RDF::Statement(self.to_h.merge(subject: self.object, predicate: RDF.type, object: t, inferred: true))
+            statements << RDF::Statement(**self.to_h.merge(subject: self.object, predicate: RDF.type, object: t, inferred: true))
           end
         end
         #$stderr.puts("range(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}")
@@ -255,7 +255,7 @@ module RDF::Reasoner
 
       # Fully entailed types of the resource
       types = options.fetch(:types) do
-        queryable.query(subject: resource, predicate: RDF.type).
+        queryable.query({subject: resource, predicate: RDF.type}).
           map {|s| (t = (RDF::Vocabulary.find_term(s.object)) rescue nil) && t.entail(:subClassOf)}.
           flatten.
           uniq.
@@ -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
@@ -337,7 +337,7 @@ module RDF::Reasoner
         else
           # Fully entailed types of the resource
           types = options.fetch(:types) do
-            queryable.query(subject: resource, predicate: RDF.type).
+            queryable.query({subject: resource, predicate: RDF.type}).
               map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
               flatten.
               uniq.

data/lib/rdf/reasoner/schema.rb

@@ -24,18 +24,20 @@ 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?
+      types = entailed_types(resource, queryable, **options) unless domains.empty?
 
       # Every domain must match some entailed type
       resource_acceptable = Array(types).empty? || domains.any? {|d| types.include?(d)}
 
       # 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,18 +147,28 @@ 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?
+          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)
           false # If resource isn't literal, this is a range violation
         else
           # Fully entailed types of the resource
-          types = entailed_types(resource, queryable, options)
+          types = entailed_types(resource, queryable, **options)
 
           # Every range must match some entailed type
           resource_acceptable = Array(types).empty? || ranges.any? {|d| types.include?(d)}
@@ -137,8 +177,8 @@ 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) &&
-            queryable.query(subject: resource, predicate: self).any? do |stmt|
+          (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
             end ||
@@ -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
@@ -174,9 +230,9 @@ module RDF::Reasoner
 
     private
     # Fully entailed types
-    def entailed_types(resource, queryable, options = {})
+    def entailed_types(resource, queryable, **options)
       options.fetch(:types) do
-        queryable.query(subject: resource, predicate: RDF.type).
+        queryable.query({subject: resource, predicate: RDF.type}).
           map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
           flatten.
           uniq.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.7.1
 platform: ruby
 authors:
 - Gregg Kellogg
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-12 00:00:00.000000000 Z
+date: 2021-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,84 +16,96 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.12
 - !ruby/object:Gem::Dependency
-  name: rdf-vocab
+  name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: rdf-xsd
+  name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
+        version: '3.1'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: rdf-spec
+  name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
@@ -114,28 +126,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.19
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.19
+        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
@@ -160,7 +172,7 @@ homepage: https://github.com/ruby-rdf/rdf-reasoner
 licenses:
 - Unlicense
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -168,15 +180,15 @@ 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: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb
 test_files: []