schema.rb in rdf-reasoner-0.4.1

- old
+ new

@@ -25,17 +25,11 @@
     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) rescue nil)) && t.entail(:subClassOf)}.
-          flatten.
-          uniq.
-          compact
-      end unless domains.empty?
+      types = entailed_types(resource, queryable, options) unless domains.empty?
 
       # Every domain must match some entailed type
       resource_acceptable = Array(types).empty? || domains.any? {|d| types.include?(d)}
 
       # Resource may still be acceptable if types include schema:Role, and any any other resource references `resource` using this property
@@ -107,11 +101,11 @@
             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
-              # If this is an XSD range, look for appropriate literal
+              # If may be 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
@@ -125,32 +119,18 @@
           end
         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::Vocab::SCHEMA.URL) && resource.uri?
           true # schema:URL matches URI resources
-        elsif ranges.include?(RDF::Vocab::SCHEMA.Text) && resource.uri?
+        elsif ranges == [RDF::Vocab::SCHEMA.Text] && resource.uri?
           # Allowed if resource is untyped
-          # Fully entailed types of the resource
-          types = options.fetch(:types) do
-            queryable.query(:subject => resource, :predicate => RDF.type).
-              map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
-              flatten.
-              uniq.
-              compact
-          end
-          types.empty?
+          entailed_types(resource, queryable, options).empty?
         elsif literal_range?(ranges)
           false # If resource isn't literal, this is a range violation
         else
           # Fully entailed types of the resource
-          types = options.fetch(:types) do
-            queryable.query(:subject => resource, :predicate => RDF.type).
-              map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
-              flatten.
-              uniq.
-              compact
-          end
+          types = entailed_types(resource, queryable, options)
 
           # Every range must match some entailed type
           resource_acceptable = Array(types).empty? || ranges.any? {|d| types.include?(d)}
 
           # Resource may still be acceptable if it has the same property with an acceptable value
@@ -188,9 +168,21 @@
         end
       end
     end
 
     def self.included(mod)
+    end
+
+    private
+    # Fully entailed types
+    def entailed_types(resource, queryable, options = {})
+      options.fetch(:types) do
+        queryable.query(:subject => resource, :predicate => RDF.type).
+          map {|s| (t = (RDF::Vocabulary.find_term(s.object) rescue nil)) && t.entail(:subClassOf)}.
+          flatten.
+          uniq.
+          compact
+      end
     end
   end
 
   # Extend the Term with this methods
   ::RDF::Vocabulary::Term.send(:include, Schema)
\ No newline at end of file