rdf-reasoner 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b64147d73a5e38f5925417e9f090176cc01dfa1
+  data.tar.gz: cd4660566c88ac7074beec70172b92a6fd220706
+SHA512:
+  metadata.gz: a8eb0b42cbfae2278cf3fe2c3b15aa9c6a985b600e9ab8b79f4b7feb3c6adcd7e89da0df91a6d5717a41d01aa650672c3f6e243f16028f206ac5bb49ec54e6dc
+  data.tar.gz: 35f93debd3072386883f6cdda9761a8aac60158f008ddd058c07420dae06f8d5f2883b5dde1bbab1b72204ef0a58c30afc238e124dba305aed12cf1be88b01ef

data/AUTHORS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@greggkellogg.net>

data/README.md

@@ -0,0 +1,59 @@
+# rdf-reasoner
+
+Reasons over RDFS/OWL vocabularies and schema.org to generate statements which are entailed based on base RDFS/OWL rules along with vocabulary information. It can also be used to ask specific questions, such as if a given object is consistent with the vocabulary ruleset. This can be used to implement [SPARQL Entailment][] Regimes and [RDF Schema][] entailment.
+
+## Features
+
+* 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.
+* Inverse `rdfs:subClassOf` entailment, to find descendant classes of the subject term.
+* `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.
+
+Domain and Range entailment include specific rules for schema.org vocabularies.
+
+## Dependencies
+
+* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.1)
+
+## Mailing List
+
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Authors
+
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+
+## Contributing
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+  Before committing, run `git diff --check` to make sure of this.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec`, `VERSION` or `AUTHORS` files. If you need to
+  change them, do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the corresponding
+  list in the the `README`. Alphabetical order applies.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
+## 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://rdf.rubyforge.org/
+[RDF Schema]:       http://www.w3.org/TR/rdf-schema/
+[Rack]:             http://rack.rubyforge.org/

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+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/>

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/rdf/reasoner.rb

@@ -0,0 +1,29 @@
+require 'rdf'
+require 'rdf/reasoner/extensions'
+
+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/)
+  module Reasoner
+    autoload :OWL,     'rdf/reasoner/owl'
+    autoload :RDFS,    'rdf/reasoner/rdfs'
+    autoload :SCHEMA,  'rdf/reasoner/schema'
+    autoload :VERSION, 'rdf/reasoner/version'
+
+    ##
+    # Add entailment support for the specified regime
+    #
+    # @param [Array<:owl, :rdfs, :schema>] regime
+    def apply(*regime)
+      regime.each {|r| require "rdf/reasoner/#{r.downcase}"}
+    end
+    module_function :apply
+
+    ##
+    # A reasoner error
+    class Error < RuntimeError; end
+  end
+end

data/lib/rdf/reasoner/extensions.rb

@@ -0,0 +1,55 @@
+# Extensions to RDF core classes to support reasoning
+require 'rdf'
+
+class RDF::Vocabulary::Term
+  class << self
+    @@entailments = {}
+
+    ##
+    # 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
+    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)
+  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

data/lib/rdf/reasoner/owl.rb

@@ -0,0 +1,347 @@
+# coding: utf-8
+
+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
+    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
+    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
+
+          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
+            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
+          end
+
+          restrictions.freeze
+        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}
+
+          # Add properties directly referencing this class
+          direct_props = Property.all.select do |prop|
+            prop.domain_of?(self) and
+            !props.include?(prop)
+          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
+          end
+        else
+          $logger.error "Unexpected value in S-Exp for #{@resource}: #{classes.inspect}" if classes
+          nil
+        end
+      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
+
+      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
+    end
+  end
+end

data/lib/rdf/reasoner/rdfs.rb

@@ -0,0 +1,160 @@
+# coding: utf-8
+
+module RDF::Reasoner
+  ##
+  # Rules for generating RDFS entailment triples
+  #
+  # Extends `RDF::Vocabulary::Term` with specific entailment capabilities
+  module RDFS
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def subClassOf_cache
+      @@subClassOf_cache ||= RDF::Util::Cache.new(-1)
+    end
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def subClass_cache
+      @@subClass_cache_cache ||= RDF::Util::Cache.new(-1)
+    end
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def descendant_cache
+      @@descendant_cache ||= RDF::Util::Cache.new(-1)
+    end
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def subPropertyOf_cache
+      @@subPropertyOf_cache ||= RDF::Util::Cache.new(-1)
+    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
+    # @private
+    def _entail_subClassOf
+      raise RDF::Reasoner::Error, "#{self} Can't entail subClassOf" unless class?
+      subClassOf_cache[self] ||= begin
+        (Array(self.subClassOf).map {|c| c._entail_subClassOf rescue c}.flatten + Array(self)).compact
+      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
+    # @private
+    def _entail_subClass
+      raise RDF::Reasoner::Error, "#{self} Can't entail subClass" unless class?
+      descendant_cache[self] ||= begin
+        (Array(self.subClass).map {|c| c._entail_subClass rescue c}.flatten + Array(self)).compact
+      end
+    end
+
+    ##
+    # Get the immediate subclasses of this class
+    # @return [Array<RDF::Vocabulary::Term>]
+    def subClass
+      raise RDF::Reasoner::Error, "#{self} Can't entail subClass" unless class?
+      subClass_cache[self] ||= ::RDF::Vocabulary.map do |v|
+        Array(v.properties).select {|p| p.class? && Array(p.subClassOf).include?(self)}
+      end.flatten.compact
+    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
+    # @private
+    def _entail_subPropertyOf
+      raise RDF::Reasoner::Error, "#{self} Can't entail subPropertyOf" unless property?
+      subPropertyOf_cache[self] ||= begin
+        (Array(self.subPropertyOf).map {|c| c._entail_subPropertyOf rescue c}.flatten + Array(self)).compact
+      end
+    end
+
+    ##
+    # RDFS requires that if the property has a domain, and the resource has a type that some type matches every domain.
+    #
+    # Note that this is different than standard entailment, which simply asserts that the resource has every type in the domain, but this is more useful to check if published data is consistent with the vocabulary definition.
+    #
+    # @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_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]
+
+        # 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)}.
+            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
+    end
+
+    ##
+    # RDFS requires that if the property has a range, and the resource has a type that some type matches every range. If the resource is a datatyped Literal, and the range includes a datatype, the resource must be consistent with that.
+    #
+    # Note that this is different than standard entailment, which simply asserts that the resource has every type in the range, but this is more useful to check if published data is consistent with the vocabulary definition.
+    #
+    # @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_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]).empty?
+        if resource.literal?
+          ranges.all? do |range|
+            case range
+            when RDF::RDFS.Literal, RDF.XMLLiteral, RDF.HTML  then true
+            else
+              if range.start_with?(RDF::XSD)
+                resource.datatype == range ||
+                resource.simple? && RDF::Literal::Boolean.new(resource.value).valid?
+              else
+                false
+              end
+            end
+          end
+        else
+          # 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)}.
+              flatten.
+              uniq.
+              compact
+          end
+          # Every range must match some entailed type
+          Array(types).empty? || ranges.all? {|d| types.include?(d)}
+        end
+      else
+        true
+      end
+    end
+    
+    def self.included(mod)
+      mod.add_entailment :subClassOf, :_entail_subClassOf
+      mod.add_entailment :subClass, :_entail_subClass
+      mod.add_entailment :subPropertyOf, :_entail_subPropertyOf
+    end
+  end
+
+  # Extend the Term with this methods
+  ::RDF::Vocabulary::Term.send(:include, RDFS)
+end

data/lib/rdf/reasoner/schema.rb

@@ -0,0 +1,149 @@
+# coding: utf-8
+
+# Also requires RDFS reasoner
+require 'rdf/reasoner/rdfs'
+
+module RDF::Reasoner
+  ##
+  # Rules for generating RDFS entailment triples
+  #
+  # Extends `RDF::Vocabulary::Term` with specific entailment capabilities
+  module SCHEMA
+    # domain_includes accessor
+    # @return [Array<RDF::Vocabulary::Term>]
+    def domain_includes
+      Array(@attributes["schema:domainIncludes"]).map {|v| RDF::Vocabulary.expand_pname(v)}
+    end
+    alias_method :domainIncludes, :domain_includes
+
+    # range_includes accessor
+    # @return [Array<RDF::Vocabulary::Term>]
+    def range_includes
+      Array(@attributes["schema:rangeIncludes"]).map {|v| RDF::Vocabulary.expand_pname(v)}
+    end
+    alias_method :rangeIncludes, :range_includes
+
+    ##
+    # Schema.org requires that if the property has a domain, and the resource has a type that some type matches some domain.
+    #
+    # Note that this is different than standard entailment, which simply asserts that the resource has every type in the domain, but this is more useful to check if published data is consistent with the vocabulary definition.
+    #
+    # @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_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 = options.fetch(:types) do
+        queryable.query(:subject => resource, :predicate => RDF.type).
+          map {|s| (t = RDF::Vocabulary.find_term(s.object)) && t.entail(:subClassOf)}.
+          flatten.
+          uniq.
+          compact
+      end unless domains.empty?
+
+      # Every domain must match some entailed type
+      Array(types).empty? || domains.any? {|d| types.include?(d)}
+    end
+
+    ##
+    # Schema.org requires that if the property has a range, and the resource has a type that some type matches some range. If the resource is a datatyped Literal, and the range includes a datatype, the resource must be consistent with that.
+    #
+    # Also, a plain literal (or schema:Text) is always compatible with an object range.
+    #
+    # @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_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 resource.literal?
+          ranges.any? do |range|
+            case range
+            when RDF::RDFS.Literal  then true
+            when RDF::SCHEMA.Text   then resource.plain? || resource.datatype == RDF::SCHEMA.Text
+            when RDF::SCHEMA.Boolean
+              [RDF::SCHEMA.Boolean, RDF::XSD.boolean].include?(resource.datatype) ||
+              resource.simple? && RDF::Literal::Boolean.new(resource.value).valid?
+            when RDF::SCHEMA.Date
+              resource.datatype == RDF::SCHEMA.Date ||
+              resource.is_a?(RDF::Literal::Date) ||
+              resource.simple? && RDF::Literal::Date.new(resource.value).valid?
+            when RDF::SCHEMA.DateTime
+              resource.datatype == RDF::SCHEMA.DateTime ||
+              resource.is_a?(RDF::Literal::DateTime) ||
+              resource.simple? && RDF::Literal::DateTime.new(resource.value).valid?
+            when RDF::SCHEMA.Duration
+              value = resource.value
+              value = "P#{value}" unless value.start_with?("P")
+              resource.datatype == RDF::SCHEMA.Duration ||
+              resource.is_a?(RDF::Literal::Duration) ||
+              resource.simple? && RDF::Literal::Duration.new(value).valid?
+            when RDF::SCHEMA.Time
+              resource.datatype == RDF::SCHEMA.Time ||
+              resource.is_a?(RDF::Literal::Time) ||
+              resource.simple? && RDF::Literal::Time.new(resource.value).valid?
+            when RDF::SCHEMA.Number
+              resource.is_a?(RDF::Literal::Numeric) ||
+              [RDF::SCHEMA.Number, RDF::SCHEMA.Float, RDF::SCHEMA.Integer].include?(resource.datatype) ||
+              resource.simple? && RDF::Literal::Integer.new(resource.value).valid? ||
+              resource.simple? && RDF::Literal::Double.new(resource.value).valid?
+            when RDF::SCHEMA.Float
+              resource.is_a?(RDF::Literal::Double) ||
+              [RDF::SCHEMA.Number, RDF::SCHEMA.Float].include?(resource.datatype) ||
+              resource.simple? && RDF::Literal::Double.new(resource.value).valid?
+            when RDF::SCHEMA.Integer
+              resource.is_a?(RDF::Literal::Integer) ||
+              [RDF::SCHEMA.Number, RDF::SCHEMA.Integer].include?(resource.datatype) ||
+              resource.simple? && RDF::Literal::Integer.new(resource.value).valid?
+            when RDF::SCHEMA.URL
+              resource.datatype == RDF::SCHEMA.URL ||
+              resource.datatype == RDF::XSD.anyURI ||
+              resource.simple? && RDF::Literal::AnyURI.new(resource.value).valid?
+            else
+              # If this is an XSD range, look for appropriate literal
+              if range.start_with?(RDF::XSD.to_s)
+                if resource.datatype == RDF::URI(range)
+                  true
+                else
+                  # Valid if cast as datatype
+                  resource.simple? && RDF::Literal(resource.value, :datatype => RDF::URI(range)).valid?
+                end
+              else
+                # Otherwise, presume that the range refers to a typed resource
+                false
+              end
+            end
+          end
+        elsif %w(True False).map {|v| RDF::SCHEMA[v]}.include?(resource) && ranges.include?(RDF::SCHEMA.Boolean)
+          true # Special case for schema boolean resources
+        else
+          # 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)}.
+              flatten.
+              uniq.
+              compact
+          end
+          # Every range must match some entailed type
+          Array(types).empty? || ranges.any? {|d| types.include?(d)}
+        end
+      else
+        true
+      end
+    end
+  
+    def self.included(mod)
+    end
+  end
+
+  # Extend the Term with this methods
+  ::RDF::Vocabulary::Term.send(:include, SCHEMA)
+end

data/lib/rdf/reasoner/version.rb

@@ -0,0 +1,18 @@
+module RDF::Reasoner::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: rdf-reasoner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.4
+- !ruby/object:Gem::Dependency
+  name: rdf-xsd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: linkeddata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+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
+  ruleset. This can be used to implement SPARQL Entailment Regimes.
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- 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
+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
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: RDFS/OWL Reasoner for RDF.rb
+test_files: []
+has_rdoc: false