rdf-reasoner 0.1.0 → 0.2.0

data/README.md

@@ -6,7 +6,10 @@ Reasons over RDFS/OWL vocabularies and schema.org to generate statements which a
 
 * Entail `rdfs:subClassOf` generating an array of terms which are ancestors of the subject.
 * 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.
+* 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.
 * `rangeCompatible?` determines if a particular resource is compatible with the range definition of a given predicate, based on the intersection of entailed subclasses or literal types with the property domain.
 
@@ -17,6 +20,67 @@ 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.
 
+## Examples
+### Determine super-classes of a class
+
+    require 'rdf/reasoner'
+
+    RDF::Reasoner.apply(:rdfs)
+    term = RDF::Vocabulary.find_term("http://xmlns.com/foaf/0.1/Person")
+    term.entail(:subClassOf)
+      # => [
+        foaf:Agent,
+        http://www.w3.org/2000/10/swap/pim/contact#Person,
+        geo:SpatialThing,
+        foaf:Person
+      ]
+
+### Determine sub-classes of a class
+
+    require 'rdf/reasoner'
+
+    RDF::Reasoner.apply(:rdfs)
+    term = RDF::FOAF.Person
+    term.entail(:subClass) # => [foaf:Person, mo:SoloMusicArtist]
+
+### Determine if a resource is compatible with the domains of a property
+
+    require 'rdf/reasoner'
+    require 'rdf/turtle'
+
+    RDF::Reasoner.apply(:rdfs)
+    graph = RDF::Graph.load("etc/doap.ttl")
+    subj = RDF::URI("http://rubygems.org/gems/rdf-reasoner")
+    RDF::DOAP.name.domain_compatible?(subj, graph) # => true
+
+### Determine if a resource is compatible with the ranges of a property
+
+    require 'rdf/reasoner'
+    require 'rdf/turtle'
+
+    RDF::Reasoner.apply(:rdfs)
+    graph = RDF::Graph.load("etc/doap.ttl")
+    obj = RDF::Literal(Date.new)
+    RDF::DOAP.created.range_compatible?(obj, graph) # => true
+
+### Perform equivalentClass entailment on a graph
+
+    require 'rdf/reasoner'
+    require 'rdf/turtle'
+
+    RDF::Reasoner.apply(::owl)
+    graph = RDF::Graph.load("etc/doap.ttl")
+    graph.entail!(:equivalentClass)
+
+### Yield all entailed statements for all entailment methods
+
+    require 'rdf/reasoner'
+    require 'rdf/turtle'
+
+    RDF::Reasoner.apply(:rdfs, :owl)
+    graph = RDF::Graph.load("etc/doap.ttl")
+    graph.enum_statement.entail.count # >= graph.enum_statement.count
+
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 1.9.2)

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/rdf/reasoner.rb

@@ -18,7 +18,7 @@ module RDF
     #
     # @param [Array<:owl, :rdfs, :schema>] regime
     def apply(*regime)
-      regime.each {|r| require "rdf/reasoner/#{r.downcase}"}
+      regime.each {|r| require "rdf/reasoner/#{r.to_s.downcase}"}
     end
     module_function :apply
 

data/lib/rdf/reasoner/extensions.rb

@@ -1,55 +1,171 @@
 # Extensions to RDF core classes to support reasoning
 require 'rdf'
 
-class RDF::Vocabulary::Term
-  class << self
-    @@entailments = {}
+module RDF
+  class Vocabulary::Term
+    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
 
     ##
-    # Add an entailment method. The method accepts no arguments, and returns an array of values associated with the particular entailment method
-    # @param [Symbol] method
-    # @param [Proc] proc
-    def add_entailment(method, proc)
-      @@entailments[method] = proc
+    # 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
 
-  ##
-  # Perform an entailment on this term. Entailments defined within this module are `:subClassOf`, `:subPropertyOf`, and `:subClass`.
-  #
-  # @param [Symbol] method A registered entailment method
-  # @return [Array<Term>]
-  def entail(method)
-    self.send @@entailments.fetch(method)
+  class Statement
+    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
   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)
+  module Enumerable
+    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 entailments on this enumerable in a single pass, yielding entailed statements.
+    #
+    # For best results, either run rules separately expanding the enumberated graph, or run repeatedly until no new statements are added to the enumerable containing both original and entailed statements. As `:subClassOf` and `:subPropertyOf` entailments are implicitly recursive, this may not be necessary except for extreme cases.
+    #
+    # @overload entail
+    #   @param [Array<Symbol>] *rules Registered entailment method(s)
+    #   @yield statement
+    #   @yieldparam [RDF::Statement] statement
+    #   @return [void]
+    #
+    # @overload entail
+    #   @param [Array<Symbol>] *rules Registered entailment method(s)
+    #   @return [Enumerator]
+    def entail(*rules, &block)
+      if block_given?
+        rules = @@entailments.keys if rules.empty?
+
+        self.each do |statement|
+          rules.each {|rule| statement.entail(rule, &block)}
+        end
+      else
+        # Otherwise, return an Enumerator with the entailed statements
+        this = self
+        RDF::Queryable::Enumerator.new do |yielder|
+          this.entail(*rules) {|y| yielder << y}
+        end
+      end
     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)
+  module Mutable
+    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
+
+    # Return a new mutable, composed of original and entailed statements
+    #
+    # @param [Array<Symbol>] *rules Registered entailment method(s)
+    # @return [RDF::Mutable]
+    # @see [RDF::Enumerable#entail]
+    def entail(*rules, &block)
+      self.dup.entail!(*rules)
+    end
+
+    # Add entailed statements to the mutable
+    #
+    # @param [Array<Symbol>] *rules Registered entailment method(s)
+    # @return [RDF::Mutable]
+    # @see [RDF::Enumerable#entail]
+    def entail!(*rules, &block)
+      rules = @@entailments.keys if rules.empty?
+      statements = []
+
+      self.each do |statement|
+        rules.each do |rule|
+          statement.entail(rule) do |st|
+            statements << st
+          end
+        end
+      end
+      self.insert *statements
+      self
     end
   end
-end
+end

data/lib/rdf/reasoner/owl.rb

@@ -4,344 +4,139 @@ module RDF::Reasoner
   ##
   # Rules for generating OWL entailment triples
   #
-  # Create instances for each owl:Class, owl:ObjectProperty, owl:DatatypeProperty, owl:DataType and owl:Restriction. This allows querying for querying specific entailed relationships of each instance.
-  class OWL
-    # Base class for OWL classes
-    class Base
-      # resource attribute, the IRI or BNode subject of the class
-      # #!attribute [r] resource
-      # @return [RDF::Resource]
-      attr_reader :resource
-
-      # RDF::Enumerable containing entity definition
-      #
-      # #!attribute [r] enumerable
-      # @return [RDF::Enumerable]
-      attr_reader :enumerable
-
-      class << self
-        # Class reader for all defined entities
-        # @!attribute [r] all
-        # @return [Array<Property>]
-        attr_reader :all
-      end
-
-      # Find instance based on this resource
-      # @param [RDF::Resource] resource
-      # @return [Base]
-      def self.find(resource)
-        all.detect {|r| r.resource == resource}
-      end
-
-      ##
-      # Create a new entity based on resource within enumerable
-      #
-      # @param [RDF::Resource] resource
-      # @param [RDF::Enumerable] enumerable
-      def initialize(resource, enumerable)
-        @resource, @enumerable = resource, enumerable
-        (Base.all ||= []) << self
-      end
-
-      # Human label of this class
-      # @return [String]
-      def label
-        @label || @resource.split(/\/\#/).last
-      end
-
-      # Infered ranges of the {Restriction} or {Property}
-      # FIXME: This does not account for intersection/union
-      # @return [Array<OwlClass,DataType>]
-      def ranges
-        values = @on_class || @all_values_from || @some_values_from || @on_data_range || @range
-        return [] unless values
-        values.map do |v|
-          v.one_of || v.union_of || ([v] + v.descendant_classes)
-        end.flatten
-      end
-
-      # Is this entity the same as `cls`, or is it a union containing `cls`?
-      # @param [OwlClass] cls
-      # @return [TrueClass, FalseClass]
-      def class_of?(cls)
-        cls == self or union_of.include?(cls)
-      end
-
-      # Override for actual descendant classes
-      # @return [Array]
-      def descendant_classes; []; end
-
-      # Is this a named entity (i.e., not some OWL construction)
-      # @return [TrueClass, FalseClass]
-      def named?
-        @resource.iri?
-      end
-
-      ##
-      # Accessors for entity fields
-      #
-      # @overload all_values_from
-      #   @return [Array<Base>] reflects owl:allValuesFrom
-      # @overload _cardinality
-      #   @return [Integer]
-      #     reflects owl:cardinality and owl:qualifiedCardinality.
-      #     @see {Restriction#cardinality}
-      #  @overload equivalent_property
-      #     @return [Array<Property>] reflects owl:equivalentProperty
-      # ...
-      def method_missing(meth, *args)
-        def _access(preds, how)
-          @access ||= {}
-          # Memoize result
-          @access[meth] ||= begin
-            values = []
-            preds.each do |pred|
-              enumerable.query(:subject => resource, :predicate => pred) do |statement|
-                values << statement.object
-              end
-            end
-            case how
-            when true
-              # Value is simply true
-              true
-            when :ary
-              # Translate IRIs into instances of Base
-              values.map {|v| Base.find(v) || v}
-            when :list
-              # Access as list and translate IRIs into instances of Base
-              RDF::List(values.first, enumerable).to_a.map {|v| Base.find(v) || v}
-            when :obj, :int
-              # Take first element of array, and optionally translate to integer
-              how == :int ? values.first.to_i : values.first
-            end
-          end
-        end
-
-        case :meth
-        when :all_values_from then _access([RDF::OWL::allValuesFrom], :ary)
-        when :_cardinality then _access([RDF::OWL::cardinality, RDF::OWL::qualifiedCardinality], :int)
-        when :domain then _access([RDF::RDFS::domain], :ary)
-        when :equivalent_property then _access([RDF::OWL::equivalentProperty], :ary)
-        when :has_self then _access([RDF::OWL::hasSelf], true)
-        when :has_value then _access([RDF::OWL::hasValue], :ary)
-        when :intersection_of then _access([RDF::OWL::hasSelf], true)
-        when :inverse_of then _access([RDF::OWL::inverseOf], :obj)
-        when :max_cardinality then _access([RDF::OWL::maxCardinality, RDF::OWL::maxQualifiedCardinality], :int)
-        when :min_cardinality then _access([RDF::OWL::minCardinality, RDF::OWL::minQualifiedCardinality], :int)
-        when :one_of then _access([RDF::OWL::oneOf], :list)
-        when :on_class then _access([RDF::OWL::onClass], :obj)
-        when :on_datarange then _access([RDF::OWL::onDatatype], :obj)
-        when :on_property then _access([RDF::OWL::onProperty], :obj)
-        when :range then _access([RDF::RDFS::range], :ary)
-        when :some_values_from then _access([RDF::OWL::someValuesFrom], :ary)
-        when :sub_class_of then _access([RDF::RDFS::subClassOf], :ary)
-        when :sub_property_of then _access([RDF::RDFS::subPropertyOf], :ary)
-        when :union_of then _access([RDF::OWL::unionOf], :list)
-        when :with_restrictions then _access([RDF::OWL::withRestrictions], :list)
-        else
-          super
-        end
-      end
-    end
-
-    # Entries for owl objects which are Object or Datatype Properties
-    class Property < Base
-      class << self
-        # Class reader for all defined properties
-        # @!attribute [r] all
-        # @return [Array<Property>]
-        attr_reader :all
-      end
-
-      ##
-      # Create a new property based on resource within enumerable
-      #
-      # @param [RDF::Resource] resource
-      # @param [RDF::Enumerable] enumerable
-      def initialize(resource, enumerable)
-        super
-        (Property.all ||= []) << self
-      end
-
-      # Infered domains of this property
-      # FIXME: does not account for intersection/union, which is uncomon in domains
-      # @return [Array<OwlClass>]
-      def domains
-        self.domain.map do |v|
-          v.one_of || v.union_of || ([v] + v.descendant_classes)
-        end.flatten.uniq
-      end
-
-
-      # Does this property have a domain including cls?
-      # The JSON is defined to always represent domain as an array
-      # FIXME: this doesn't deal with intersection
-      # @param [OwlClass] cls
-      # @return [TrueClass, FalseClass]
-      def domain_of?(cls)
-        domain.any? {|dom| dom.class_of?(cls)}
-      end
+  # Extends `RDF::Vocabulary::Term` and `RDF::Statement` with specific entailment capabilities
+  module OWL
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def equivalentClass_cache
+      @@subPropertyOf_cache ||= {}
     end
-
-
-    # OWL Restrictions are similar to classes. They impose a restriction on
-    # values of some property, such as cardinality
-    class Restriction < Base
-      # For restrictions, return any defined cardinality
-      # as an array of \[min, max\] where either max may be `nil`.
-      # Min will always be an integer.
-      # @return [Array<(Integer, Integer)>]
-      def cardinality
-        [(@cardinality || @min_cardinality || 0), (@cardinality || @max_cardinality)]
-      end
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def equivalentProperty_cache
+      @@equivalentProperty_cache ||= {}
     end
 
-    # Entries for owl objects wich are classes
-    class OwlClass < Base
-      class << self
-        # Class accessor for all defined classes
-        # @!attribute [r] all
-        # @return [Array<OwlClass>]
-        attr_reader :all
-      end
 
-      ##
-      # Create a new class based on resource within enumerable
-      #
-      # @param [RDF::Resource] resource
-      # @param [RDF::Enumerable] enumerable
-      def initialize(resource, enumerable)
-        super
-        (OwlClass.all ||= []) << self
-      end
-
-      # Return super classes as an S-Expression
-      # @return [Array<OwlClass>]
-      def super_classes
-        @super_class_cache ||= begin
-          # Note in super-class, that this is a direct sub-class
-          sup = self.sub_class_of
+    ##
+    # For a Term: yield or return inferred equivalentClass relationships
+    # For a Statement: if predicate is `rdf:types`, yield or return inferred statements having a equivalentClass relationship to the type of this statement
+    # @private
+    def _entail_equivalentClass
+      case self
+      when RDF::Vocabulary::Term
+        unless class? && respond_to?(:equivalentClass)
+          yield self if block_given?
+          return Array(self)
+        end
 
-          anded_classes = sup.map do |cls|
-            if cls.is_a?(OwlClass) and cls.named?
-              cls
-            elsif cls.unionOf
-              ored_classes = cls.union_of.select {|c2| c2.is_a?(OwlClass)}.compact
-              case ored_classes.length
-              when 0 then nil
-              when 1 then ored_classes.first
-              else        (%w(|) + ored_classes).freeze
-              end
+        # Initialize @equivalentClass_cache by iterating over all defined property terms having an `owl:equivalentClass` attribute and adding the source class as an equivalent of the destination class
+        if equivalentClass_cache.empty?
+          RDF::Vocabulary.each do |v|
+            v.each do |term|
+              term.equivalentClass.each do |equiv|
+                (equivalentClass_cache[equiv] ||= []) << term
+              end if term.class?
             end
-          end.compact
-
-          case anded_classes.length
-          when 0 then [].freeze
-          when 1 then anded_classes.first
-          else        (%w(&) + anded_classes).freeze
           end
         end
-      end
-
-      # Return all direct sub-classes
-      # This counts on each class having had superClasses calculated to
-      # inject the sub-class relation
-      # @return [Array<OwlClass>]
-      def sub_classes
-        @sub_classes_cache ||= OwlClass.all.select do |c|
-          c.sub_class_of.any? {|cl| cl.class_of?(self)}
-        end
-      end
-
-      # Return all descendant classes
-      # @return [Array<OwlClass>]
-      def descendant_classes
-        @descendant_classes ||= begin
-          (sub_classes + sub_classes.map {|cls| cls.descendant_classes}.flatten).compact.freeze
-        end
-      end
-
-      # Return a list of all property restrictions on this class and super-classes
-      # @return [Array<Restriction>]
-      def property_restrictions
-        @property_restrictions_cache ||= begin
-          restrictions = evaluate_sexp(self.super_classes) {|c| c.property_restrictions}.dup
-          restrictions = [restrictions].compact unless restrictions.is_a?(Array)
-          # Add restrictions defined on this class
-          self.sub_class_of.select {|r| r.is_a?(Restriction)}.each do |restriction|
-            prop = restriction.on_property
-            # Remove any existing restriction on the same property
-            restrictions.reject! {|r| r.on_property == prop}
-            #puts "#{resource}: add local restriction: #{restriction.on_property.resource}"
-            restrictions << restriction
+        terms = (self.equivalentClass + Array(equivalentClass_cache[self])).uniq
+        terms.each {|t| yield t} if block_given?
+        terms
+      when RDF::Statement
+        statements = []
+        if self.predicate == RDF.type
+          if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
+            term._entail_equivalentClass do |t|
+              statements << RDF::Statement.new(self.to_hash.merge(object: t))
+            end
           end
-
-          restrictions.freeze
         end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
       end
+    end
 
-      # Return a list of all properties on this class and super-classes
-      # @return [Array<Property>]
-      def properties
-        @properties_cache ||= begin
-          # Inherited properties
-          props = evaluate_sexp(super_classes) {|c| c.properties}
+    ##
+    # For a Term: yield or return return inferred equivalentProperty relationships
+    # For a Statement: yield or return inferred statements having a equivalentProperty relationship to predicate of this statement
+    # @private
+    def _entail_equivalentProperty
+      case self
+      when RDF::Vocabulary::Term
+        unless property? && respond_to?(:equivalentProperty)
+          yield self if block_given?
+          return Array(self)
+        end
 
-          # Add properties directly referencing this class
-          direct_props = Property.all.select do |prop|
-            prop.domain_of?(self) and
-            !props.include?(prop)
+        # Initialize equivalentProperty_cache by iterating over all defined property terms having an `owl:equivalentProperty` attribute and adding the source class as an equivalent of the destination class
+        if equivalentProperty_cache.empty?
+          RDF::Vocabulary.each do |v|
+            v.each do |term|
+              term.equivalentProperty.each do |equiv|
+                (equivalentProperty_cache[equiv] ||= []) << term
+              end if term.property?
+            end
           end
-
-          (props + direct_props).sort.freeze
         end
-      end
-
-      private
-      # Evaluate a subclass S-Expression
-      def evaluate_sexp(classes)
-        case classes
-        when OWL then yield classes
-        when Array
-          case classes.first
-          when '|' # Union of classes
-            cls = yield(classes[1]).dup
-            classes[2..-1].each {|cls2| cls = cls | yield(cls2)}
-            cls
-          when '&' # Intersection of classes
-            cls = yield(classes[1]).dup
-            classes[2..-1].each {|cls2| cls = cls & yield(cls2)}
-            cls
-          else
-            $logger.error "Unexpected operator in S-Exp for #{@resource}: #{classes.inspect}" unless classes.empty?
-            classes.dup
+        terms = (self.equivalentProperty + Array(equivalentProperty_cache[self])).uniq
+        terms.each {|t| yield t} if block_given?
+        terms
+      when RDF::Statement
+        statements = []
+        if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
+          term._entail_equivalentProperty do |t|
+            statements << RDF::Statement.new(self.to_hash.merge(predicate: t))
           end
-        else
-          $logger.error "Unexpected value in S-Exp for #{@resource}: #{classes.inspect}" if classes
-          nil
         end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
       end
     end
 
-    # Entries for XSD and RDF datatypes
-    class DataType < Base
-      attr_accessor :rdf_literal_class
-      
-      def initialize(object)
-        super
-        @rdf_literal_class = RDF::Literal
-      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
 
-      def validate(value)
-        if (rdf_literal_class.new(value).valid? rescue false)
-          case
-          when one_of
-            "#{value.inspect} must be one of #{one_of.inspect}" unless one_of.include?(value)
-          end
-        else
-          "#{value.inspect} is not a valid #{label}(#{resource})"
-        end
-      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 Statement with these methods
+  ::RDF::Statement.send(:include, OWL)
+
+  # Extend Enumerable with these methods
+  ::RDF::Enumerable.send(:include, OWL)
+
+  # Extend Mutable with these methods
+  ::RDF::Mutable.send(:include, OWL)
 end

data/lib/rdf/reasoner/rdfs.rb

@@ -4,7 +4,7 @@ module RDF::Reasoner
   ##
   # Rules for generating RDFS entailment triples
   #
-  # Extends `RDF::Vocabulary::Term` with specific entailment capabilities
+  # Extends `RDF::Vocabulary::Term` and `RDF::Statement` with specific entailment capabilities
   module RDFS
     ##
     # @return [RDF::Util::Cache]
@@ -35,22 +35,59 @@ module RDF::Reasoner
     end
 
     ##
-    # 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 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
     # @private
     def _entail_subClassOf
-      return Array(self) unless class? && respond_to?(:subClassOf)
-      subClassOf_cache[self] ||= begin
-        (Array(self.subClassOf).map {|c| c._entail_subClassOf rescue c}.flatten + Array(self)).compact
+      case self
+      when RDF::Vocabulary::Term
+        unless class? && respond_to?(:subClassOf)
+          yield self if block_given?
+          return Array(self)
+        end
+        terms = subClassOf_cache[self] ||= (
+          Array(self.subClassOf).
+            map {|c| c._entail_subClassOf rescue c}.
+            flatten +
+          Array(self)
+        ).compact
+        terms.each {|t| yield t} if block_given?
+        terms
+      when RDF::Statement
+        statements = []
+        if self.predicate == RDF.type
+          if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
+            term._entail_subClassOf do |t|
+              statements << RDF::Statement.new(self.to_hash.merge(object: t))
+            end
+          end
+        end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
       end
     end
 
     ##
-    # Return inferred subClass relationships by recursively applying to named sub classes to get a complete set of classes in the descendant chain of this class
+    # For a Term: yield or return inferred subClass relationships by recursively applying to named sub classes to get a complete set of classes in the descendant chain of this class
+    # For a Statement: this is a no-op, as it's not useful in this context
     # @private
     def _entail_subClass
-      return Array(self) unless class?
-      descendant_cache[self] ||= begin
-        (Array(self.subClass).map {|c| c._entail_subClass rescue c}.flatten + Array(self)).compact
+      case self
+      when RDF::Vocabulary::Term
+        unless class?
+          yield self if block_given?
+          return Array(self)
+        end
+        terms = descendant_cache[self] ||= (
+          Array(self.subClass).
+            map {|c| c._entail_subClass rescue c}.
+            flatten +
+          Array(self)
+        ).compact
+        terms.each {|t| yield t} if block_given?
+        terms
+      else []
       end
     end
 
@@ -58,7 +95,6 @@ module RDF::Reasoner
     # Get the immediate subclasses of this class.
     #
     # 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 subClass
       raise RDF::Reasoner::Error, "#{self} Can't entail subClass" unless class?
@@ -68,12 +104,70 @@ module RDF::Reasoner
     end
 
     ##
-    # 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 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
     # @private
     def _entail_subPropertyOf
-      return Array(self) unless property? && respond_to?(:subPropertyOf)
-      subPropertyOf_cache[self] ||= begin
-        (Array(self.subPropertyOf).map {|c| c._entail_subPropertyOf rescue c}.flatten + Array(self)).compact
+      case self
+      when RDF::Vocabulary::Term
+        unless property? && respond_to?(:subPropertyOf)
+          yield self if block_given?
+          return Array(self)
+        end
+        terms = subPropertyOf_cache[self] ||= (
+          Array(self.subPropertyOf).
+            map {|c| c._entail_subPropertyOf rescue c}.
+            flatten +
+          Array(self)
+        ).compact
+        terms.each {|t| yield t} if block_given?
+        terms
+      when RDF::Statement
+        statements = []
+        if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
+          term._entail_subPropertyOf do |t|
+            statements << RDF::Statement.new(self.to_hash.merge(predicate: t))
+          end
+        end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
+      end
+    end
+
+    ##
+    # For a Statement: yield or return inferred statements having an rdf:type of the domain of the statement predicate
+    # @private
+    def _entail_domain
+      case self
+      when RDF::Statement
+        statements = []
+        if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
+          term.domain.each do |t|
+            statements << RDF::Statement.new(self.to_hash.merge(predicate: RDF.type, object: t))
+          end
+        end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
+      end
+    end
+
+    ##
+    # For a Statement: if object is a resource, yield or return inferred statements having an rdf:type of the range of the statement predicate
+    # @private
+    def _entail_range
+      case self
+      when RDF::Statement
+        statements = []
+        if object.resource? && term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
+          term.range.each do |t|
+            statements << RDF::Statement.new(self.to_hash.merge(subject: self.object, predicate: RDF.type, object: t))
+          end
+        end
+        statements.each {|s| yield s} if block_given?
+        statements
+      else []
       end
     end
 
@@ -95,7 +189,7 @@ module RDF::Reasoner
         # 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)) && t.entail(:subClassOf)}.
+            map {|s| (t = (RDF::Vocabulary.find_term(s.object)) rescue nil) && t.entail(:subClassOf)}.
             flatten.
             uniq.
             compact
@@ -138,7 +232,7 @@ module RDF::Reasoner
           # 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)) && t.entail(:subClassOf)}.
+              map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
               flatten.
               uniq.
               compact
@@ -161,9 +255,20 @@ module RDF::Reasoner
       mod.add_entailment :subClassOf, :_entail_subClassOf
       mod.add_entailment :subClass, :_entail_subClass
       mod.add_entailment :subPropertyOf, :_entail_subPropertyOf
+      mod.add_entailment :domain, :_entail_domain
+      mod.add_entailment :range, :_entail_range
     end
   end
 
-  # Extend the Term with this methods
+  # Extend Term with these methods
   ::RDF::Vocabulary::Term.send(:include, RDFS)
+
+  # Extend Statement with these methods
+  ::RDF::Statement.send(:include, RDFS)
+
+  # Extend Enumerable with these methods
+  ::RDF::Enumerable.send(:include, RDFS)
+
+  # Extend Mutable with these methods
+  ::RDF::Mutable.send(:include, RDFS)
 end

data/lib/rdf/reasoner/schema.rb

@@ -47,7 +47,7 @@ module RDF::Reasoner
       # 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)) && t.entail(:subClassOf)}.
+          map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
           flatten.
           uniq.
           compact
@@ -147,7 +147,7 @@ module RDF::Reasoner
           # 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)) && t.entail(:subClassOf)}.
+              map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
               flatten.
               uniq.
               compact

metadata

@@ -1,117 +1,132 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
+  prerelease: 
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-27 00:00:00.000000000 Z
+date: 2014-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.1.4.2
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: linkeddata
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.8'
 description: Reasons over RDFS/OWL vocabularies to generate statements which are entailed
@@ -127,35 +142,36 @@ files:
 - README.md
 - UNLICENSE
 - VERSION
-- lib/rdf/reasoner.rb
 - lib/rdf/reasoner/extensions.rb
 - lib/rdf/reasoner/owl.rb
 - lib/rdf/reasoner/rdfs.rb
 - lib/rdf/reasoner/schema.rb
 - lib/rdf/reasoner/version.rb
+- lib/rdf/reasoner.rb
 homepage: http://github.com/gkellogg/rdf-reasoner
 licenses:
 - Public Domain
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: RDFS/OWL Reasoner for RDF.rb
 test_files: []
 has_rdoc: false

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: f6a98adc5516082d31f711b399c152f140a02bb5
-  data.tar.gz: 39fa2fc036816834e1bdf676ed4d7ad0898cce28
-SHA512:
-  metadata.gz: 729ae98dd83b486197f0eb73d9465116dd40aa16d385b05c94c1228fa6ed0f882aeb85f84b0b492a0c1ba5931d231147cc36cce2a9c2c166d5af547971324ea3
-  data.tar.gz: 3c0a07eefe32d2e5e4afd983546e667028c48c050fde90cbd67ddaf9ea46ad6bc64ef143ea73db2078840eafbb27b4bd7ca5b6f7ff566ad5852705e605f71e79