rdf-reasoner 0.4.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 377e84cbd7ab81ee861446c9918634bc97bcfe25
-  data.tar.gz: b03ed57e310bc107a48923e391cef30344e64776
+SHA256:
+  metadata.gz: 911fc7c40f3afc055e166946ff41a65d061cd08aa8b028401f85357b61b62617
+  data.tar.gz: 9702cd3e837fcc9abba925f154a40257a6d49cd8b28db990c6bd57147324049e
 SHA512:
-  metadata.gz: 4d0aeeec319bf740256541783eee1514fea11ae98d3a3ae26863fb85357e79e3630b18f0ce3adc5faac42663b9b0c9d742bec1ff1b268f7c8152691125018cc4
-  data.tar.gz: 6b8d37050cb611c36e70ea612542fdcf2b36375023bc5072f111f9a12387f9379b7131c7e06fb90243cd619f63a28826683fe5949cbb8e6dea6618df652a4639
+  metadata.gz: 827da1634fe249c21598824019f785d3efdbb8a94afad1dcf7d3c8852d87a41ec2a3ee59ced83d2705c33a480be719065caf0dc115104e290e0f28d44bec0088
+  data.tar.gz: 9d5010b729d25351bfec0efba6fd90c0789080a7a56fac8f829c3f56fc80fad712291acbd8c9a5eb728451c0c36077e8abe23ef7cd39e17d308934bcf9dcf5c2

data/README.md

@@ -8,6 +8,7 @@ Reasons over RDFS/OWL vocabularies and schema.org to generate statements which a
 * Entail `rdfs:subPropertyOf` generating an array of terms which are ancestors of the subject.
 * Entail `rdfs:domain` and `rdfs:range` adding `rdf:type` assertions on the subject or object.
 * Inverse `rdfs:subClassOf` entailment, to find descendant classes of the subject term.
+* Inverse `rdfs:subPropertyOf` entailment, to find descendant properties of the subject term.
 * Entail `owl:equivalentClass` generating an array of terms equivalent to the subject.
 * Entail `owl:equivalentProperty` generating an array of terms equivalent to the subject.
 * `domainCompatible?` determines if a particular resource is compatible with the domain definition of a given predicate, based on the intersection of entailed subclasses with the property domain.
@@ -51,7 +52,7 @@ Domain and Range entailment include specific rules for schema.org vocabularies.
 
     RDF::Reasoner.apply(:rdfs)
     graph = RDF::Graph.load("etc/doap.ttl")
-    subj = RDF::URI("http://rubygems.org/gems/rdf-reasoner")
+    subj = RDF::URI("https://rubygems.org/gems/rdf-reasoner")
     RDF::Vocab::DOAP.name.domain_compatible?(subj, graph) # => true
 
 ### Determine if a resource is compatible with the ranges of a property
@@ -103,16 +104,16 @@ The `rdf` command-line interface is extended with `entail` and `lint` commands.
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.1.1)
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
 
 ## Mailing List
 
-* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
 ## Authors
 
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
 
 ## Contributing
 
@@ -132,17 +133,17 @@ The `rdf` command-line interface is extended with `entail` and `lint` commands.
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
-
-[Ruby]:             http://ruby-lang.org/
-[RDF]:              http://www.w3.org/RDF/
-[YARD]:             http://yardoc.org/
-[YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
-[SPARQL]:           http://en.wikipedia.org/wiki/SPARQL
-[SPARQL Query]:     http://www.w3.org/TR/2013/REC-sparql11-query-20130321/
-[SPARQL Entailment]:http://www.w3.org/TR/sparql11-entailment/
-[RDF 1.1]:          http://www.w3.org/TR/rdf11-concepts
-[RDF.rb]:           http://www.rubydoc.info/github/ruby-rdf/rdf/
-[RDF Schema]:       http://www.w3.org/TR/rdf-schema/
+see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+[Ruby]:             https://ruby-lang.org/
+[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
+[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/
+[RDF 1.1]:          https://www.w3.org/TR/rdf11-concepts
+[RDF.rb]:           https://www.rubydoc.info/github/ruby-rdf/rdf/
+[RDF Schema]:       https://www.w3.org/TR/rdf-schema/
 [Rack]:             https://rack.github.io/

data/UNLICENSE

@@ -21,4 +21,4 @@ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
-For more information, please refer to <http://unlicense.org/>
+For more information, please refer to <https://unlicense.org/>

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.6.0

data/lib/rdf/reasoner.rb

@@ -7,7 +7,7 @@ module RDF
   # RDFS/OWL reasonsing for RDF.rb.
   #
   # @see http://www.w3.org/TR/2013/REC-sparql11-entailment-20130321/
-  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  # @author [Gregg Kellogg](https://greggkellogg.net/)
   module Reasoner
     require 'rdf/reasoner/format'
     autoload :OWL,     'rdf/reasoner/owl'

data/lib/rdf/reasoner/extensions.rb

@@ -2,7 +2,7 @@
 require 'rdf'
 
 module RDF
-  class Vocabulary::Term
+  class URI
     class << self
       @@entailments = {}
 
@@ -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,64 @@ 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
+
+  class Node
+    class << self
+      @@entailments = {}
+
+      ##
+      # Add an entailment method. The method accepts no arguments, and returns or yields an array of values associated with the particular entailment method
+      # @param [Symbol] method
+      # @param [Proc] proc
+      def add_entailment(method, proc)
+        @@entailments[method] = proc
+      end
+    end
+
+    ##
+    # Perform an entailment on this term.
+    #
+    # @param [Symbol] method A registered entailment method
+    # @yield term
+    # @yieldparam [Term] term
+    # @return [Array<Term>]
+    def entail(method, &block)
+      self.send(@@entailments.fetch(method), &block)
+    end
+
+    ##
+    # Determine if the domain of a property term is consistent with the specified resource in `queryable`.
+    #
+    # @param [RDF::Resource] resource
+    # @param [RDF::Queryable] queryable
+    # @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)
+      %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
+    end
+
+    ##
+    # Determine if the range of a property term is consistent with the specified resource in `queryable`.
+    #
+    # Specific entailment regimes should insert themselves before this to apply the appropriate semantic condition
+    #
+    # @param [RDF::Resource] resource
+    # @param [RDF::Queryable] queryable
+    # @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)
+      %w(owl rdfs schema).map {|r| "range_compatible_#{r}?".to_sym}.all? do |meth|
+        !self.respond_to?(meth) || self.send(meth, resource, queryable, **options)
       end
     end
   end
@@ -178,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
@@ -187,6 +242,7 @@ module RDF
         if term && term.class?
           # Warn against using a deprecated term
           superseded = term.attributes[:'schema:supersededBy']
+          superseded = superseded.pname if superseded.respond_to?(:pname)
           (messages[:class] ||= {})[pname] = ["Term is superseded by #{superseded}"] if superseded
         else
           (messages[:class] ||= {})[pname] = ["No class definition found"] unless vocab.nil? || [RDF::RDFV, RDF::RDFS].include?(vocab)
@@ -211,6 +267,7 @@ module RDF
         if term && term.property?
           # Warn against using a deprecated term
           superseded = term.attributes[:'schema:supersededBy']
+          superseded = superseded.pname if superseded.respond_to?(:pname)
           (messages[:property] ||= {})[pname] = ["Term is superseded by #{superseded}"] if superseded
         else
           ((messages[:property] ||= {})[pname] ||= []) << "No property definition found" unless vocab.nil?
@@ -218,14 +275,14 @@ 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.
           compact
 
         unless term.domain_compatible?(stmt.subject, self, types: resource_types[stmt.subject])
-          ((messages[:property] ||= {})[pname] ||= []) << if term.respond_to?(:domain)
+          ((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(',')})"
@@ -233,14 +290,14 @@ 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.
           compact if stmt.object.resource?
 
         unless term.range_compatible?(stmt.object, self, types: resource_types[stmt.object])
-          ((messages[:property] ||= {})[pname] ||= []) << if term.respond_to?(:range)
+          ((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(',')})"
@@ -259,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/format.rb

@@ -5,7 +5,7 @@ module RDF::Reasoner
   # @example Obtaining an LD Patch format class
   #     RDF::Format.for(:reasoner)           #=> RDF::Reasoner::Format
   #
-  # @see http://www.w3.org/TR/ldpatch/
+  # @see https://www.w3.org/TR/ldpatch/
   class Format < RDF::Format
 
     ##

data/lib/rdf/reasoner/owl.rb

@@ -4,7 +4,7 @@ module RDF::Reasoner
   ##
   # Rules for generating OWL entailment triples
   #
-  # Extends `RDF::Vocabulary::Term` and `RDF::Statement` with specific entailment capabilities
+  # Extends `RDF::URI` and `RDF::Statement` with specific entailment capabilities
   module OWL
     ##
     # @return [RDF::Util::Cache]
@@ -26,8 +26,8 @@ module RDF::Reasoner
     # @private
     def _entail_equivalentClass
       case self
-      when RDF::Vocabulary::Term
-        unless class? && respond_to?(:equivalentClass)
+      when RDF::URI, RDF::Node
+        unless class?
           yield self if block_given?
           return Array(self)
         end
@@ -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
@@ -66,8 +66,8 @@ module RDF::Reasoner
     # @private
     def _entail_equivalentProperty
       case self
-      when RDF::Vocabulary::Term
-        unless property? && respond_to?(:equivalentProperty)
+      when RDF::URI, RDF::Node
+        unless property?
           yield self if block_given?
           return Array(self)
         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?
@@ -98,38 +98,14 @@ module RDF::Reasoner
       end
     end
 
-    ##
-    # EquivalentClass of this term, also populates reverse equivalents.
-    #
-    # When first called, this initializes a cache of reverse terms to terms where the the reverse term is listed as an equivalent of the original term.
-    #
-    # It returns the list of terms which are equivalent to this term however defined.
-    # @return [Array<RDF::Vocabulary::Term>]
-    def equivalentClass
-      raise RDF::Reasoner::Error, "#{self} Can't entail equivalentClass" unless class?
-      Array(self.attributes[:"owl:equivalentClass"]).map {|t| RDF::Vocabulary.expand_pname(t)}
-    end
-
-    ##
-    # EquivalentProperty of this term, also populates reverse equivalents.
-    #
-    # When first called, this initializes a cache of reverse terms to terms where the the reverse term is listed as an equivalent of the original term.
-    #
-    # It returns the list of terms which are equivalent to this term however defined.
-    # @return [Array<RDF::Vocabulary::Term>]
-    def equivalentProperty
-      raise RDF::Reasoner::Error, "#{self} Can't entail equivalentProperty" unless property?
-      Array(self.attributes[:"owl:equivalentProperty"]).map {|t| RDF::Vocabulary.expand_pname(t)}
-    end
-    
     def self.included(mod)
       mod.add_entailment :equivalentClass, :_entail_equivalentClass
       mod.add_entailment :equivalentProperty, :_entail_equivalentProperty
     end
   end
 
-  # Extend Term with these methods
-  ::RDF::Vocabulary::Term.send(:include, OWL)
+  # Extend URI with these methods
+  ::RDF::URI.send(:include, OWL)
 
   # Extend Statement with these methods
   ::RDF::Statement.send(:include, OWL)

data/lib/rdf/reasoner/rdfs.rb

@@ -4,7 +4,7 @@ module RDF::Reasoner
   ##
   # Rules for generating RDFS entailment triples
   #
-  # Extends `RDF::Vocabulary::Term` and `RDF::Statement` with specific entailment capabilities
+  # Extends `RDF::URI` and `RDF::Statement` with specific entailment capabilities
   module RDFS
     ##
     # @return [RDF::Util::Cache]
@@ -34,14 +34,29 @@ module RDF::Reasoner
       @@subPropertyOf_cache ||= RDF::Util::Cache.new(-1)
     end
 
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def subProperty_cache
+      @@subProperty_cache ||= RDF::Util::Cache.new(-1)
+    end
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def descendant_property_cache
+      @@descendant_property_cache ||= RDF::Util::Cache.new(-1)
+    end
+
     ##
     # For a Term: yield or return inferred subClassOf 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: if predicate is `rdf:types`, yield or return inferred statements having a subClassOf relationship to the type of this statement
+    # @todo Should be able to entail owl:Restriction, which is a BNode. This should be allowed, and also add BNode values of that node, recursively, similar to SPARQL concise_bounded_description.uu
     # @private
     def _entail_subClassOf
       case self
-      when RDF::Vocabulary::Term
-        unless class? && respond_to?(:subClassOf)
+      when RDF::URI, RDF::Node
+        unless class?
           yield self if block_given?
           return Array(self)
         end
@@ -58,7 +73,8 @@ module RDF::Reasoner
         if self.predicate == RDF.type
           if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
             term._entail_subClassOf do |t|
-              statements << RDF::Statement(self.to_h.merge(object: t, inferred: true))
+              next if t.node? # Don't entail BNodes
+              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}}}")
@@ -75,7 +91,7 @@ module RDF::Reasoner
     # @private
     def _entail_subClass
       case self
-      when RDF::Vocabulary::Term
+      when RDF::URI, RDF::Node
         unless class?
           yield self if block_given?
           return Array(self)
@@ -110,8 +126,8 @@ module RDF::Reasoner
     # @private
     def _entail_subPropertyOf
       case self
-      when RDF::Vocabulary::Term
-        unless property? && respond_to?(:subPropertyOf)
+      when RDF::URI, RDF::Node
+        unless property?
           yield self if block_given?
           return Array(self)
         end
@@ -127,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
@@ -137,8 +153,53 @@ module RDF::Reasoner
       end
     end
 
+    ##
+    # For a Term: yield or return inferred subProperty relationships
+    # by recursively applying to named subproperties to get a complete
+    # set of properties in the descendant chain of this property
+    #
+    # For a Statement: this is a no-op, as it's not useful in this context
+    # @private
+
+    def _entail_subProperty
+      case self
+      when RDF::URI, RDF::Node
+        unless property?
+          yield self if block_given?
+          return Array(self)
+        end
+
+        terms = descendant_property_cache[self] ||= (
+          Array(self.subProperty).map do |c|
+            c._entail_subProperty rescue c
+          end.flatten + Array(self)).compact
+
+        terms.each {|t| yield t } if block_given?
+        terms
+      else []
+      end
+    end
+
+    ##
+    # Get the immediate subproperties of this property.
+    #
+    # This iterates over terms defined in the vocabulary of this term,
+    # as well as the vocabularies imported by this vocabulary.
+    # @return [Array<RDF::Vocabulary::Term>]
+    def subProperty
+      raise RDF::Reasoner::Error,
+        "#{self} Can't entail subProperty" unless property?
+      vocabs = [self.vocab] + self.vocab.imported_from
+      subProperty_cache[self] ||= vocabs.map do |v|
+        Array(v.properties).select do |p|
+          p.property? && Array(p.subPropertyOf).include?(self)
+        end
+      end.flatten.compact
+    end
+
     ##
     # For a Statement: yield or return inferred statements having an rdf:type of the domain of the statement predicate
+    # @todo Should be able to entail owl:unionOf, which is a BNode. This should be allowed, and also add BNode values of that node, recursively, similar to SPARQL concise_bounded_description.uu
     # @private
     def _entail_domain
       case self
@@ -146,7 +207,8 @@ module RDF::Reasoner
         statements = []
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.domain.each do |t|
-            statements << RDF::Statement(self.to_h.merge(predicate: RDF.type, object: t, inferred: true))
+            next if t.node? # Don't entail BNodes
+            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}}}")
@@ -158,6 +220,7 @@ module RDF::Reasoner
 
     ##
     # For a Statement: if object is a resource, yield or return inferred statements having an rdf:type of the range of the statement predicate
+    # @todo Should be able to entail owl:unionOf, which is a BNode. This should be allowed, and also add BNode values of that node, recursively, similar to SPARQL concise_bounded_description.uu
     # @private
     def _entail_range
       case self
@@ -165,7 +228,8 @@ module RDF::Reasoner
         statements = []
         if object.resource? && term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.range.each do |t|
-            statements << RDF::Statement(self.to_h.merge(subject: self.object, predicate: RDF.type, object: t, inferred: true))
+            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))
           end
         end
         #$stderr.puts("range(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}")
@@ -185,25 +249,21 @@ 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?
-      if respond_to?(:domain)
-        domains = Array(self.domain) - [RDF::OWL.Thing, RDF::RDFS.Resource]
+      domains = Array(self.domain).reject(&:node?) - [RDF::OWL.Thing, RDF::RDFS.Resource]
 
-        # Fully entailed types of the resource
-        types = options.fetch(:types) do
-          queryable.query(subject: resource, predicate: RDF.type).
-            map {|s| (t = (RDF::Vocabulary.find_term(s.object)) rescue nil) && t.entail(:subClassOf)}.
-            flatten.
-            uniq.
-            compact
-        end unless domains.empty?
+      # Fully entailed types of the resource
+      types = options.fetch(:types) do
+        queryable.query({subject: resource, predicate: RDF.type}).
+          map {|s| (t = (RDF::Vocabulary.find_term(s.object)) rescue nil) && t.entail(:subClassOf)}.
+          flatten.
+          uniq.
+          compact
+      end unless domains.empty?
 
-        # Every domain must match some entailed type
-        Array(types).empty? || domains.all? {|d| types.include?(d)}
-      else
-        true
-      end
+      # Every domain must match some entailed type
+      Array(types).empty? || domains.all? {|d| types.include?(d)}
     end
 
     ##
@@ -216,9 +276,9 @@ 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 respond_to?(:range) && !(ranges = Array(self.range) - [RDF::OWL.Thing, RDF::RDFS.Resource]).empty?
+      if !(ranges = Array(self.range).reject(&:node?) - [RDF::OWL.Thing, RDF::RDFS.Resource]).empty?
         if resource.literal?
           ranges.all? do |range|
             if [RDF::RDFS.Literal, RDF.XMLLiteral, RDF.HTML].include?(range)
@@ -277,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.
@@ -301,13 +361,14 @@ module RDF::Reasoner
       mod.add_entailment :subClassOf, :_entail_subClassOf
       mod.add_entailment :subClass, :_entail_subClass
       mod.add_entailment :subPropertyOf, :_entail_subPropertyOf
+      mod.add_entailment :subProperty, :_entail_subProperty
       mod.add_entailment :domain, :_entail_domain
       mod.add_entailment :range, :_entail_range
     end
   end
 
-  # Extend Term with these methods
-  ::RDF::Vocabulary::Term.send(:include, RDFS)
+  # Extend URI with these methods
+  ::RDF::URI.send(:include, RDFS)
 
   # Extend Statement with these methods
   ::RDF::Statement.send(:include, RDFS)
@@ -317,4 +378,4 @@ module RDF::Reasoner
 
   # Extend Mutable with these methods
   ::RDF::Mutable.send(:include, RDFS)
-end
+end

data/lib/rdf/reasoner/schema.rb

@@ -7,7 +7,7 @@ module RDF::Reasoner
   ##
   # Rules for generating RDFS entailment triples
   #
-  # Extends `RDF::Vocabulary::Term` with specific entailment capabilities
+  # Extends `RDF::URI` with specific entailment capabilities
   module Schema
 
     ##
@@ -22,12 +22,12 @@ 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]
 
       # 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)}
@@ -35,7 +35,7 @@ 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?
+          !queryable.query({predicate: self, object: resource}).empty?
     end
 
     ##
@@ -52,9 +52,9 @@ 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 respond_to?(:rangeIncludes) && !(ranges = Array(self.rangeIncludes) - [RDF::OWL.Thing]).empty?
+      if !(ranges = Array(self.rangeIncludes) - [RDF::OWL.Thing]).empty?
         if resource.literal?
           ranges.any? do |range|
             case range
@@ -123,12 +123,12 @@ module RDF::Reasoner
           true # schema:URL matches URI resources
         elsif ranges == [RDF::Vocab::SCHEMA.Text] && resource.uri?
           # Allowed if resource is untyped
-          entailed_types(resource, queryable, options).empty?
+          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)}
@@ -138,7 +138,7 @@ module RDF::Reasoner
 
           # 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|
+            queryable.query({subject: resource, predicate: self}).any? do |stmt|
               acc = self.range_compatible_schema?(stmt.object, queryable)
               acc
             end ||
@@ -174,9 +174,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.
@@ -185,6 +185,6 @@ module RDF::Reasoner
     end
   end
 
-  # Extend the Term with this methods
-  ::RDF::Vocabulary::Term.send(:include, Schema)
+  # Extend URI with this methods
+  ::RDF::URI.send(:include, Schema)
 end

metadata

@@ -1,135 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  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-13 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: rdf-vocab
   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-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: 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: json-ld
+  name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.1'
-    - - "<"
+    - - "~>"
       - !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.1'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: rdf-turtle
+  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: :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: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
@@ -150,28 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.9'
 - !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: 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
@@ -192,7 +156,7 @@ files:
 - lib/rdf/reasoner/rdfs.rb
 - lib/rdf/reasoner/schema.rb
 - lib/rdf/reasoner/version.rb
-homepage: http://github.com/gkellogg/rdf-reasoner
+homepage: https://github.com/ruby-rdf/rdf-reasoner
 licenses:
 - Unlicense
 metadata: {}
@@ -204,15 +168,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: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb