rdf-reasoner 0.4.3 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7dd2fb50e0757e5bc8c4d3e93ac9eb401422c891
-  data.tar.gz: b1adb845ea5cfe53345ca292ba9313685c3a1ba6
+SHA256:
+  metadata.gz: 651a1431487e77d50420f0c33506df9d756e7eab48790589bdfacdc404b88fea
+  data.tar.gz: 66c536de0f20de0fe2f50be36e8a712d24efd4e1ea7674b4bff234d91a827272
 SHA512:
-  metadata.gz: adc382c500d6659b6c2ebf2fb97eb93f883d5b70d02cbcf1ca6ec27b317c05af69db33fe74de344d81113d0333d629bc452c087e824b27516ddfd00a9230b793
-  data.tar.gz: 0d8cb95fffe01665cbb02f60b723c322d9d732810f564278fe418dae440b541eb56c7fb6f823d81fd8f6b78a9b25f3b354775c49161d341eb684d3151c4bbf2d
+  metadata.gz: 551d92044542d411803d75619a6f0d38d5cae5ae4331f7b11109006518a5db6c1fe8f7589d343e915b2e8187997a20fb68917771ebf5eba9297d0cc721e76be3
+  data.tar.gz: 47ee7417fdf42130820419558718332ad77748386cec3d8ef4513e5e711b299fd4bdabe5500a12eb1effdc55acb19ba5a9bce41e3e4ef63ec2510ace662c9a0b

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.2.2)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.0)
 
 ## 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.3
+0.5.3

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,62 @@
 require 'rdf'
 
 module RDF
-  class Vocabulary::Term
+  class URI
+    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
+
+  class Node
     class << self
       @@entailments = {}
 
@@ -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?
@@ -225,7 +282,7 @@ module RDF
           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(',')})"
@@ -240,7 +297,7 @@ module RDF
           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(',')})"

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
 
     ##
@@ -23,7 +23,7 @@ module RDF::Reasoner
             start, stmt_cnt = Time.now, RDF::CLI.repository.count
             RDF::CLI.repository.entail!
             secs, new_cnt = (Time.new - start), (RDF::CLI.repository.count - stmt_cnt)
-            opts[:logger].info "\nEntailed #{new_cnt} new statements in #{secs} seconds."
+            opts[:logger].info "Entailed #{new_cnt} new statements in #{secs} seconds."
           end
         },
         lint: {
@@ -38,7 +38,7 @@ module RDF::Reasoner
             opts[:messages].merge!(RDF::CLI.repository.lint)
             opts[:output].puts "Linter responded with #{opts[:messages].empty? ? 'no' : ''} messages."
             secs = Time.new - start
-            opts[:logger].info "\nLinted in #{secs} seconds."
+            opts[:logger].info "Linted in #{secs} seconds."
           end
         }
       }

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
@@ -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
@@ -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,6 +73,7 @@ module RDF::Reasoner
         if self.predicate == RDF.type
           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))
             end
           end
@@ -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
@@ -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,6 +207,7 @@ module RDF::Reasoner
         statements = []
         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))
           end
         end
@@ -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,6 +228,7 @@ module RDF::Reasoner
         statements = []
         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))
           end
         end
@@ -187,23 +251,19 @@ module RDF::Reasoner
     #   Fully entailed types of resource, if not provided, they are queried
     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
 
     ##
@@ -218,7 +278,7 @@ module RDF::Reasoner
     #   Fully entailed types of resource, if not provided, they are queried
     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)
@@ -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
 
     ##
@@ -54,7 +54,7 @@ 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 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
@@ -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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.3
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-21 00:00:00.000000000 Z
+date: 2019-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,90 +16,84 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.2.8
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.2.8
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: json-ld
+  name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rdf-turtle
+  name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
@@ -120,28 +114,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.19
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.19
 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
@@ -162,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: {}
@@ -181,8 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb