rdf-reasoner 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1980413b4fbf92e655601081fbc493d9a5dcb77
-  data.tar.gz: 545ce25a9e024691ee7b8d7e0166921bfa0f876a
+  metadata.gz: 82811d1af73f62458a8c0ae0b719ff6a0ea14a3f
+  data.tar.gz: 37ba1a731d2a5435e9fb61d0a2caa7b008b58d51
 SHA512:
-  metadata.gz: e4e95ad17224135fee1f801455eaa802a277efb82227f9d4837f3eccdeeb6b5a3c7c5a4f9686ca6dbed50afd3ea67dd625d30150b2299ff15ac56d45fef4f883
-  data.tar.gz: 19fb975b67c1e0aaff517e98f9513c42b6ca618272d8d862fbcc44b104ad62f33fc2442ae9d835ac70dc724bc24ba6d9ccd55ddc061e1d0e56798a781477ddd5
+  metadata.gz: 93b537c3d167f0cdd99d19163b40caa33a2a611e9b6a5f3550ef29d211472215cfaa5fabce00dbde74a3865ffd8a82f8c00394899e9a551ef9c5c3fadda46aba
+  data.tar.gz: facc4fbf521fb828f83488a13dd713b051576350fc959c4fd4493aeb954c4f96c294a0a1f6c4ce17a6489adf75b223d4ec6cd2947dbf7203ccb2bb4d66f53e93

data/README.md

@@ -40,7 +40,7 @@ Domain and Range entailment include specific rules for schema.org vocabularies.
     require 'rdf/reasoner'
 
     RDF::Reasoner.apply(:rdfs)
-    term = RDF::FOAF.Person
+    term = RDF::Vocab::FOAF.Person
     term.entail(:subClass) # => [foaf:Person, mo:SoloMusicArtist]
 
 ### Determine if a resource is compatible with the domains of a property
@@ -81,6 +81,22 @@ Domain and Range entailment include specific rules for schema.org vocabularies.
     graph = RDF::Graph.load("etc/doap.ttl")
     graph.enum_statement.entail.count # >= graph.enum_statement.count
 
+### Lint an expanded graph
+
+    require 'rdf/reasoner'
+    require 'rdf/turtle'
+
+    RDF::Reasoner.apply(:rdfs, :owl)
+    graph = RDF::Graph.load("etc/doap.ttl")
+    graph.entail!
+    messages = graph.lint
+    messages.each do |kind, term_messages|
+      term_messages.each do |term, messages|
+        options[:output].puts "#{kind}  #{term}"
+        messages.each {|m| options[:output].puts "  #{m}"}
+      end
+    end
+
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 1.9.2)

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/rdf/reasoner.rb

@@ -41,6 +41,13 @@ module RDF
     end
     module_function :apply
 
+    ##
+    # Add all entailment regimes
+    def apply_all
+      apply(*%w(rdfs owl schema))
+    end
+    module_function :apply_all
+
     ##
     # A reasoner error
     class Error < RuntimeError; end

data/lib/rdf/reasoner/extensions.rb

@@ -101,7 +101,9 @@ module RDF
     # 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)
+    #   @param [Array<Symbol>] *rules
+    #     Registered entailment method(s).
+    #     
     #   @yield statement
     #   @yieldparam [RDF::Statement] statement
     #   @return [void]
@@ -111,7 +113,7 @@ module RDF
     #   @return [Enumerator]
     def entail(*rules, &block)
       if block_given?
-        rules = @@entailments.keys if rules.empty?
+        rules = %w(subClassOf subPropertyOf domain range).map(&:to_sym) if rules.empty?
 
         self.each do |statement|
           rules.each {|rule| statement.entail(rule, &block)}
@@ -141,7 +143,7 @@ module RDF
 
     # Return a new mutable, composed of original and entailed statements
     #
-    # @param [Array<Symbol>] *rules Registered entailment method(s)
+    # @param [Array<Symbol>] rules Registered entailment method(s)
     # @return [RDF::Mutable]
     # @see [RDF::Enumerable#entail]
     def entail(*rules, &block)
@@ -150,11 +152,11 @@ module RDF
 
     # Add entailed statements to the mutable
     #
-    # @param [Array<Symbol>] *rules Registered entailment method(s)
+    # @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?
+      rules = %w(subClassOf subPropertyOf domain range).map(&:to_sym) if rules.empty?
       statements = []
 
       self.each do |statement|
@@ -164,8 +166,99 @@ module RDF
           end
         end
       end
-      self.insert *statements
+      self.insert(*statements)
       self
     end
   end
+
+  module Queryable
+    # Lint a queryable, presuming that it has already had RDFS entailment expansion.
+    # @return [Hash{Symbol => Hash{Symbol => Array<String>}}] messages found for classes and properties by term
+    def lint
+      messages = {}
+
+      # Check for defined classes in known vocabularies
+      self.query(:predicate => RDF.type) do |stmt|
+        vocab = RDF::Vocabulary.find(stmt.object)
+        term = (RDF::Vocabulary.find_term(stmt.object) rescue nil) if vocab
+        pname = term ? term.pname : stmt.object.pname
+        
+        # Must be a defined term, not in RDF or RDFS vocabularies
+        if term && term.class?
+          # Warn against using a deprecated term
+          superseded = term.attributes['schema:supersededBy']
+          (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)
+        end
+      end
+
+      # Check for defined predicates in known vocabularies and domain/range
+      resource_types = {}
+      self.each_statement do |stmt|
+        vocab = RDF::Vocabulary.find(stmt.predicate)
+        term = (RDF::Vocabulary.find_term(stmt.predicate) rescue nil) if vocab
+        pname = term ? term.pname : stmt.predicate.pname
+
+        # Must be a defined property
+        if term && term.property?
+          # Warn against using a deprecated term
+          superseded = term.attributes['schema:supersededBy']
+          (messages[:property] ||= {})[pname] = ["Term is superseded by #{superseded}"] if superseded
+        else
+          ((messages[:property] ||= {})[pname] ||= []) << "No property definition found" unless vocab.nil?
+          next
+        end
+
+        # See if type of the subject is in the domain of this predicate
+        resource_types[stmt.subject] ||= self.query(subject: stmt.subject, predicate: RDF.type).
+        map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
+          flatten.
+          uniq.
+          compact
+
+        unless term.domain_compatible?(stmt.subject, self, :types => resource_types[stmt.subject])
+          ((messages[:property] ||= {})[pname] ||= []) << if term.respond_to?(:domain)
+           "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(',')})"
+          end
+        end
+
+        # Make sure that if ranges are defined, the object has an appropriate type
+        resource_types[stmt.object] ||= self.query(subject: stmt.object, predicate: RDF.type).
+          map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
+          flatten.
+          uniq.
+          compact if stmt.object.resource?
+
+        unless term.range_compatible?(stmt.object, self, :types => resource_types[stmt.object])
+          ((messages[:property] ||= {})[pname] ||= []) << if term.respond_to?(:range)
+           "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(',')})"
+          end
+        end
+      end
+
+      messages[:class].each {|k, v| messages[:class][k] = v.uniq} if messages[:class]
+      messages[:property].each {|k, v| messages[:property][k] = v.uniq} if messages[:property]
+      messages
+    end
+
+  private
+
+    # Show resource in diagnostic output
+    def show_resource(resource)
+      if resource.node?
+        resource.to_ntriples + '(' +
+          self.query(subject: resource, predicate: RDF.type).
+            map {|s| s.object.uri? ? s.object.pname : s.object.to_ntriples}
+            .join(',') +
+          ')'
+      else
+        resource.to_ntriples
+      end
+    end
+  end
 end

data/lib/rdf/reasoner/rdfs.rb

@@ -61,6 +61,7 @@ module RDF::Reasoner
               statements << RDF::Statement.new(self.to_hash.merge(object: t))
             end
           end
+          #$stderr.puts("subClassf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         end
         statements.each {|s| yield s} if block_given?
         statements
@@ -128,6 +129,7 @@ module RDF::Reasoner
           term._entail_subPropertyOf do |t|
             statements << RDF::Statement.new(self.to_hash.merge(predicate: t))
           end
+          #$stderr.puts("subPropertyOf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         end
         statements.each {|s| yield s} if block_given?
         statements
@@ -147,6 +149,7 @@ module RDF::Reasoner
             statements << RDF::Statement.new(self.to_hash.merge(predicate: RDF.type, object: t))
           end
         end
+        #$stderr.puts("domain(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         statements.each {|s| yield s} if block_given?
         statements
       else []
@@ -165,6 +168,7 @@ module RDF::Reasoner
             statements << RDF::Statement.new(self.to_hash.merge(subject: self.object, predicate: RDF.type, object: t))
           end
         end
+        #$stderr.puts("range(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}")
         statements.each {|s| yield s} if block_given?
         statements
       else []

data/lib/rdf/reasoner/schema.rb

@@ -40,7 +40,7 @@ module RDF::Reasoner
 
       # Resource may still be acceptable if types include schema:Role, and any any other resource references `resource` using this property
       resource_acceptable ||
-        types.include?(RDF::SCHEMA.Role) &&
+        types.include?(RDF::Vocab::SCHEMA.Role) &&
           !queryable.query(predicate: self, object: resource).empty?
     end
 
@@ -65,11 +65,11 @@ module RDF::Reasoner
           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) ||
+            when RDF::Vocab::SCHEMA.Text   then resource.plain? || resource.datatype == RDF::Vocab::SCHEMA.Text
+            when RDF::Vocab::SCHEMA.Boolean
+              [RDF::Vocab::SCHEMA.Boolean, RDF::XSD.boolean].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Boolean.new(resource.value).valid?
-            when RDF::SCHEMA.Date
+            when RDF::Vocab::SCHEMA.Date
               # Schema.org date based on ISO 8601, mapped to appropriate XSD types for validation
               case resource
               when RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime, RDF::Literal::Duration
@@ -77,35 +77,35 @@ module RDF::Reasoner
               else
                 ISO_8601.match(resource.value)
               end
-            when RDF::SCHEMA.DateTime
-              resource.datatype == RDF::SCHEMA.DateTime ||
+            when RDF::Vocab::SCHEMA.DateTime
+              resource.datatype == RDF::Vocab::SCHEMA.DateTime ||
               resource.is_a?(RDF::Literal::DateTime) ||
               resource.plain? && RDF::Literal::DateTime.new(resource.value).valid?
-            when RDF::SCHEMA.Duration
+            when RDF::Vocab::SCHEMA.Duration
               value = resource.value
               value = "P#{value}" unless value.start_with?("P")
-              resource.datatype == RDF::SCHEMA.Duration ||
+              resource.datatype == RDF::Vocab::SCHEMA.Duration ||
               resource.is_a?(RDF::Literal::Duration) ||
               resource.plain? && RDF::Literal::Duration.new(value).valid?
-            when RDF::SCHEMA.Time
-              resource.datatype == RDF::SCHEMA.Time ||
+            when RDF::Vocab::SCHEMA.Time
+              resource.datatype == RDF::Vocab::SCHEMA.Time ||
               resource.is_a?(RDF::Literal::Time) ||
               resource.plain? && RDF::Literal::Time.new(resource.value).valid?
-            when RDF::SCHEMA.Number
+            when RDF::Vocab::SCHEMA.Number
               resource.is_a?(RDF::Literal::Numeric) ||
-              [RDF::SCHEMA.Number, RDF::SCHEMA.Float, RDF::SCHEMA.Integer].include?(resource.datatype) ||
+              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float, RDF::Vocab::SCHEMA.Integer].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Integer.new(resource.value).valid? ||
               resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-            when RDF::SCHEMA.Float
+            when RDF::Vocab::SCHEMA.Float
               resource.is_a?(RDF::Literal::Double) ||
-              [RDF::SCHEMA.Number, RDF::SCHEMA.Float].include?(resource.datatype) ||
+              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-            when RDF::SCHEMA.Integer
+            when RDF::Vocab::SCHEMA.Integer
               resource.is_a?(RDF::Literal::Integer) ||
-              [RDF::SCHEMA.Number, RDF::SCHEMA.Integer].include?(resource.datatype) ||
+              [RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Integer].include?(resource.datatype) ||
               resource.plain? && RDF::Literal::Integer.new(resource.value).valid?
-            when RDF::SCHEMA.URL
-              resource.datatype == RDF::SCHEMA.URL ||
+            when RDF::Vocab::SCHEMA.URL
+              resource.datatype == RDF::Vocab::SCHEMA.URL ||
               resource.datatype == RDF::XSD.anyURI ||
               resource.plain? && RDF::Literal::AnyURI.new(resource.value).valid?
             else
@@ -123,11 +123,11 @@ module RDF::Reasoner
               end
             end
           end
-        elsif %w(True False).map {|v| RDF::SCHEMA[v]}.include?(resource) && ranges.include?(RDF::SCHEMA.Boolean)
+        elsif %w(True False).map {|v| RDF::Vocab::SCHEMA[v]}.include?(resource) && ranges.include?(RDF::Vocab::SCHEMA.Boolean)
           true # Special case for schema boolean resources
-        elsif ranges.include?(RDF::SCHEMA.URL) && resource.uri?
+        elsif ranges.include?(RDF::Vocab::SCHEMA.URL) && resource.uri?
           true # schema:URL matches URI resources
-        elsif ranges.include?(RDF::SCHEMA.Text) && resource.uri?
+        elsif ranges.include?(RDF::Vocab::SCHEMA.Text) && resource.uri?
           # Allowed if resource is untyped
           # Fully entailed types of the resource
           types = options.fetch(:types) do
@@ -157,7 +157,7 @@ module RDF::Reasoner
           resource_acceptable ||
 
           # Resource also acceptable if it is a Role, and the Role object contains the same predicate having a compatible object
-          types.include?(RDF::SCHEMA.Role) &&
+          types.include?(RDF::Vocab::SCHEMA.Role) &&
             queryable.query(subject: resource, predicate: self).any? do |stmt|
               acc = self.range_compatible_schema?(stmt.object, queryable)
               acc
@@ -178,9 +178,9 @@ module RDF::Reasoner
     def literal_range?(ranges)
       ranges.all? do |range|
         case range
-        when RDF::RDFS.Literal, RDF::SCHEMA.Text, RDF::SCHEMA.Boolean, RDF::SCHEMA.Date,
-             RDF::SCHEMA.DateTime, RDF::SCHEMA.Time, RDF::SCHEMA.URL,
-             RDF::SCHEMA.Number, RDF::SCHEMA.Float, RDF::SCHEMA.Integer
+        when RDF::RDFS.Literal, RDF::Vocab::SCHEMA.Text, RDF::Vocab::SCHEMA.Boolean, RDF::Vocab::SCHEMA.Date,
+             RDF::Vocab::SCHEMA.DateTime, RDF::Vocab::SCHEMA.Time, RDF::Vocab::SCHEMA.URL,
+             RDF::Vocab::SCHEMA.Number, RDF::Vocab::SCHEMA.Float, RDF::Vocab::SCHEMA.Integer
           true
         else
           # If this is an XSD range, look for appropriate literal

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-reasoner
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-27 00:00:00.000000000 Z
+date: 2015-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -167,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: RDFS/OWL Reasoner for RDF.rb