RubyGems - rdf-reasoner - Versions diffs - 0.6.0 → 0.7.2 - Mend

rdf-reasoner 0.6.0 → 0.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/README.md +22 -3
data/VERSION +1 -1
data/lib/rdf/reasoner.rb +2 -3
data/lib/rdf/reasoner/extensions.rb +16 -12
data/lib/rdf/reasoner/rdfs.rb +17 -17
data/lib/rdf/reasoner/schema.rb +87 -31
metadata +26 -14

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911fc7c40f3afc055e166946ff41a65d061cd08aa8b028401f85357b61b62617
-  data.tar.gz: 9702cd3e837fcc9abba925f154a40257a6d49cd8b28db990c6bd57147324049e
+  metadata.gz: 2be8747b77876661ece10045bf8901660671a4e92e37d53041db868dc592cdbb
+  data.tar.gz: f55a4d01ead9c7eb35514f4a1da398dc066d564c845106446646457f2681f374
 SHA512:
-  metadata.gz: 827da1634fe249c21598824019f785d3efdbb8a94afad1dcf7d3c8852d87a41ec2a3ee59ced83d2705c33a480be719065caf0dc115104e290e0f28d44bec0088
-  data.tar.gz: 9d5010b729d25351bfec0efba6fd90c0789080a7a56fac8f829c3f56fc80fad712291acbd8c9a5eb728451c0c36077e8abe23ef7cd39e17d308934bcf9dcf5c2
+  metadata.gz: 176996189a9669ab29a608f449b579bbd118ec4edb700bf8da22de288f98847f054044bb862382d212995015f727c582702301f4de9f7ba6a1a85b3216d7cf6b
+  data.tar.gz: be88047f121cd19dae21d04c5050b60373e7fffe7f8c97b6b9616083146200de246645d9c886065cad82a2f39c9be5132f37975934fc1416973f8fa9d84b3669

data/README.md CHANGED Viewed

@@ -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
@@ -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 CHANGED Viewed

	@@ -1 +1 @@
1	- 0.6.0
1	+ 0.7.2

data/lib/rdf/reasoner.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -34,9 +34,9 @@ module RDF
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def domain_compatible?(resource, queryable, **options)
+    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
@@ -50,9 +50,9 @@ module RDF
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def range_compatible?(resource, queryable, **options)
+    def range_compatible?(resource, queryable, options = {})
       %w(owl rdfs schema).map {|r| "range_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
   end
@@ -89,7 +89,7 @@ module RDF
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def domain_compatible?(resource, queryable, **options)
+    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)
       end
@@ -105,9 +105,9 @@ module RDF
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def range_compatible?(resource, queryable, **options)
+    def range_compatible?(resource, queryable, options = {})
       %w(owl rdfs schema).map {|r| "range_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
   end
@@ -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
@@ -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 CHANGED Viewed

@@ -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
@@ -249,7 +249,7 @@ module RDF::Reasoner
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def domain_compatible_rdfs?(resource, queryable, **options)
+    def domain_compatible_rdfs?(resource, queryable, options = {})
       raise RDF::Reasoner::Error, "#{self} can't get domains" unless property?
       domains = Array(self.domain).reject(&:node?) - [RDF::OWL.Thing, RDF::RDFS.Resource]
@@ -276,7 +276,7 @@ module RDF::Reasoner
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def range_compatible_rdfs?(resource, queryable, **options)
+    def range_compatible_rdfs?(resource, queryable, options = {})
       raise RDF::Reasoner::Error, "#{self} can't get ranges" unless property?
       if !(ranges = Array(self.range).reject(&:node?) - [RDF::OWL.Thing, RDF::RDFS.Resource]).empty?
         if resource.literal?
@@ -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 CHANGED Viewed

@@ -22,9 +22,11 @@ module RDF::Reasoner
     # @param [Hash{Symbol => Object}] options
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def domain_compatible_schema?(resource, queryable, **options)
+    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
     ##
@@ -52,18 +54,25 @@ module RDF::Reasoner
     # @param [Hash{Symbol => Object}] options ({})
     # @option options [Array<RDF::Vocabulary::Term>] :types
     #   Fully entailed types of resource, if not provided, they are queried
-    def range_compatible_schema?(resource, queryable, **options)
+    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

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Gregg Kellogg
-autorequire:
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-13 00:00:00.000000000 Z
+date: 2021-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -17,6 +17,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,8 +27,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         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:
     - - "~>"
@@ -39,13 +45,13 @@ dependencies:
       - !ruby/object:Gem::Version
         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.1'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -53,12 +59,15 @@ dependencies:
       - !ruby/object:Gem::Version
         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.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -66,6 +75,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.10
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
@@ -114,28 +126,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
@@ -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
@@ -175,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key:
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb
 test_files: []