activerdf_rules 0.0.1 → 0.0.2

data/CHANGELOG.txt

@@ -0,0 +1,2 @@
+0.0.1 - Initial version of the project.  Pretty much everything is functional,
+but not necessarily perfect.

data/Manifest.txt

@@ -1,13 +1,20 @@
+CHANGELOG.txt
 History.txt
 Manifest.txt
 README.txt
 Rakefile
-setup.rb
+TODO.txt
 examples/person_example.rb
 lib/activerdf_rules.rb
 lib/activerdf_rules/rule_base.rb
-lib/activerdf_rules/rule_engine_mixin.rb
 lib/activerdf_rules/rule_engine.rb
+lib/activerdf_rules/rule_engine_mixin.rb
 lib/activerdf_rules/version.rb
-test/test_helper.rb
+test/activerdf_rules/owl_rule_base_test.rb
+test/activerdf_rules/rdfs_ext_rule_base_test.rb
+test/activerdf_rules/rdfs_rule_base_test.rb
+test/activerdf_rules/rule_base_test.rb
+test/activerdf_rules/rule_engine_mixin_test.rb
+test/activerdf_rules/rule_engine_test.rb
 test/activerdf_rules_test.rb
+test/test_helper.rb

data/README.txt

@@ -2,22 +2,17 @@
 ActiveRDF Rules is a rule base and forward chaining production system for
 ActiveRDF.  It can be used to process rules programatically at will, or using a
 mix-in class you can have it process rules every time a triple is added to the
-data store.  The rules are defined using a DSL, and stored in memory.  It comes
+data store.  The rules are stored in memory, and can be defined using a DSL.  It comes
 with a couple of prebuilt rule bases for RDF Schema and OWL reasoning.
 
 =What it is not?
 * It is not high performance.
 * The rules are stored in memory, so don't add a lot of them.
-* It supports *some* basic RDF Schema and OWL reasoning through the built-in
+* It supports RDF Schema and *some* basic OWL reasoning through the built-in
   rule bases, but they are *basic*.  Feel free to not use them and just define
   your own.
 * It does not support restrictions.  I'm probably going to add restriction
-  rules at some point, but I haven't thought through it all just yet.  Also, I'm
-  not sure how to handle some cases.  Right now, for instance, if a property has
-  a domain specified, then it will conclude that any object that has that
-  property must be of the type specified as the domain, as opposed to restricting
-  only that type to be able to have that property.  That's the way I was told to
-  do it!
+  rules at some point, but I haven't thought through it all just yet.
 * It is not stable.  I mean it's stable; I have tested it pretty thoroghly as
   far as its current features go, but I reserve the right to change the
   implementation, interface, and anything else. I might even change the name of

data/TODO.txt

@@ -0,0 +1 @@
+Add the RDF Semantics Extensional rules

data/lib/activerdf_rules/rule_base.rb

@@ -3,7 +3,7 @@
 # base.
 # 
 # Example:
-#  rb = RuleBase.new do
+#  rb = RuleBase.new 'DSL RuleBase' do
 #    rule 'Rule1' do
 #      condition :x, :y, :z
 #      
@@ -21,7 +21,7 @@
 # the +rules+ array manually
 # 
 # Example:
-#  rb = RuleBase.new 'DSLRuleBase'
+#  rb = RuleBase.new 'Manual RuleBase'
 #  r = RuleBase::Rule.new 'Rule 1'
 #  r.condition :x, :y, :z
 #  r.conclusion :z, :y, :x
@@ -85,7 +85,7 @@ class RuleBase
   # the conditions are satisfied, then the conclusion is introduced into the
   # database substituting for any variables that may appear in the conclusion.
   # 
-  # Variables are simply a ruby symbols and they can be used within both the
+  # Variables are simply ruby symbols and they can be used within both the
   # conditions and the conclusion with the following caveat: any variable that
   # appears in the conclusion must also appear in at least one condition.
   # 
@@ -154,19 +154,24 @@ class RuleBase
       
       change = false
       q.execute.each do |row|
-        triple = @conclusion.collect {|t|
-          instantiate(t, row, lookup)
-        }
-        old = ConnectionPool.write_adapter.size
-        $activerdflog.debug("concluding #{triple.inspect}")
-        ConnectionPool.write_adapter.add(*triple)
-        # TODO HACK This should be changed
-        # What I should be able to do is something like below, but the below is
-        # broken for redland, and the above condition query is broken in
-        # rdflite (because of ambiguous column names).  For now this works.
-        # Query.new.ask.where(*triple).execute
-        if old < ConnectionPool.write_adapter.size
-          change = true
+        triple = nil
+        begin
+          triple = @conclusion.collect {|t|
+            instantiate(t, row, lookup)
+          }
+          old = ConnectionPool.write_adapter.size
+          $activerdflog.debug("concluding #{triple.inspect}")
+          ConnectionPool.write_adapter.add(*triple)
+          # TODO HACK This should be changed
+          # What I should be able to do is something like below, but the below is
+          # broken for redland, and the above condition query is broken in
+          # rdflite (because of ambiguous column names).  For now this works.
+          # Query.new.ask.where(*triple).execute
+          if old < ConnectionPool.write_adapter.size
+            change = true
+          end
+        rescue => e
+          $activerdflog.debug("could not add #{triple.inspect} because of #{e}")
         end
       end
       change

data/lib/activerdf_rules/rule_engine.rb

@@ -1,44 +1,40 @@
-# A RuleEngine will use a RuleBase to add new data to an ActiveRDF data store
-# by processing the rules.
-# TODO
+# A RuleEngine will use a collection of RuleBases to add new data to an
+# ActiveRDF data store by processing the rules.
 class RuleEngine
-  attr_accessor :rule_base
+  attr_reader :rule_bases
   
   # A RuleBase can be specified using the hash key :rule_base.
   # 
   # Example:
   #  RuleEngine.new :rule_base => RuleEngine::RDFSRuleBase
   def initialize(values = {})
-    @rule_base = values[:rule_base]
+    @rule_bases = []
+    @rule_bases << values[:rule_base] if values[:rule_base]
   end
   
+  # Creates a new RuleBase, adds it to the array of rule bases, and passes the
+  # block to the RuleBase constructor.  This allows use of the RuleBase DSL.
   def define_rules(&b)
     rb = RuleBase.new(&b)
-    self.rule_base = rb
-  end
-  
-  def rule_base=(rb)
-    if @rule_base.nil?
-      @rule_base = rb.dup
-    else
-      if rb.nil?
-        @rule_base = nil
-      else
-        @rule_base.rules.push(*rb.rules)
-      end
-    end
+    self.rule_bases << rb
   end
   
+  # Loops through all of the rule bases and processes each rule in each rule
+  # base.  Returns true if any of the rules have added information to the
+  # database.
   def process_rules
     $activerdflog.debug("processing '#{@rule_base}'")
     change = false
-    @rule_base.rules.each do |r|
-      change |= r.process
+    @rule_bases.each do |rb|
+      rb.rules.each do |r|
+        change |= r.process
+      end
     end
     change
   end
   
-  RDFSRuleBase = RuleBase.new 'RDFSRuleBase' do
+  # A rule base including rules for RDFS reasoning.
+  RDFSRuleBase = RuleBase.new('RDFSRuleBase') {
     type = Namespace.lookup(:rdf, 'type')
     rdfclass = Namespace.lookup(:rdfs, 'Class')
     subClassOf = Namespace.lookup(:rdfs, 'subClassOf')
@@ -46,64 +42,188 @@ class RuleEngine
     subPropertyOf = Namespace.lookup(:rdfs, 'subPropertyOf')
     range = Namespace.lookup(:rdfs, 'range')
     domain = Namespace.lookup(:rdfs, 'domain')
+    resource = Namespace.lookup(:rdfs, 'Resource')
+    container = Namespace.lookup(:rdfs, 'ContainerMembershipProperty')
+    member = Namespace.lookup(:rdfs, 'member')
+    datatype = Namespace.lookup(:rdfs, 'Datatype')
+    literal = Namespace.lookup(:rdfs, 'Literal')
     
-    # The following reasoning rules where taken from
-    # http://www-ksl.stanford.edu/software/jtp/doc/owl-reasoning.html
+    # The following reasoning rules were taken from the RDF Semantics document
+    # http://www.w3.org/TR/rdf-mt/#RDFRules
+    # http://www.w3.org/TR/rdf-mt/#RDFSRules
     
-    # Type inheritance through rdfs:subclassOf
-    rule do
-      condition :Morris, type, :Cat
-      condition :Cat, subClassOf, :Mammal
+    rule "rdf1" do
+      condition :s, :p, :o
       
-      conclusion :Morris, type, :Mammal
+      conclusion :p, type, property
     end
     
-    # Reflexivity of rdfs:subPropertyOf and rdfs:subclassOf
-    rule do
+    rule 'rdfs2' do
+      condition :teaches, domain, :Teacher
+      condition :Bob, :teaches, :Scooter
+      
+      conclusion :Bob, type, :Teacher
+    end
+    
+    rule 'rdfs3' do
+      condition :teaches, range, :Student
+      condition :Bob, :teaches, :Scooter
+      
+      conclusion :Scooter, type, :Student
+    end
+    
+    rule 'rdfs4a' do
+      condition :s, :p, :o
+      
+      conclusion :s, type, resource
+    end
+    
+    rule 'rdfs4b' do
+      condition :s, :p, :o
+      
+      conclusion :o, type, resource
+    end
+    
+    rule 'rdfs5' do
+      condition :parent, subPropertyOf, :ancestor
+      condition :ancestor, subPropertyOf, :relative
+      
+      conclusion :parent, subPropertyOf, :relative
+    end
+    
+    rule 'rdfs6' do
       condition :p, type, property
       
       conclusion :p, subPropertyOf, :p
     end
     
-    rule do
-      condition :p, type, rdfclass
+    rule 'rdfs7' do
+      condition :parent, subPropertyOf, :ancestor
+      condition :Paul, :parent, :Lester
       
-      conclusion :p, subClassOf, :p
+      conclusion :Paul, :ancestor, :Lester
     end
     
-    # Type inference through rdfs:range and rdfs:domain constraints
-    rule do
-      condition :teaches, domain, :Teacher
-      condition :Bob, :teaches, :Scooter
+    rule 'rdfs8' do
+      condition :c, type, rdfclass
       
-      conclusion :Bob, type, :Teacher
+      conclusion :c, subClassOf, resource
     end
     
-    rule do
-      condition :teaches, range, :Student
-      condition :Bob, :teaches, :Scooter
+    rule 'rdfs9' do
+      condition :Morris, type, :Cat
+      condition :Cat, subClassOf, :Mammal
       
-      conclusion :Scooter, type, :Student
+      conclusion :Morris, type, :Mammal
     end
     
-    # Transitivity of rdfs:subClassOf and rdfs:subPropertyOf
-    rule do
+    rule 'rdfs10' do
+      condition :p, type, rdfclass
+      
+      conclusion :p, subClassOf, :p
+    end
+    
+    rule 'rdfs11' do
       condition :Dog, subClassOf, :Mammal
       condition :Mammal, subClassOf, :Animal
       
       conclusion :Dog, subClassOf, :Animal
     end
     
-    rule do
-      condition :parent, subPropertyOf, :ancestor
-      condition :ancestor, subPropertyOf, :relative
+    rule 'rdfs12' do
+      condition :p, type, container
       
-      conclusion :parent, subPropertyOf, :relative
+      conclusion :p, subClassOf, member
     end
-  end.freeze
-  RDFSRuleBase.rules.freeze
+    
+    rule 'rdfs13' do
+      condition :p, type, datatype
+      
+      conclusion :p, subClassOf, literal
+    end
+  }
+  
+  # A rule base including rules for "stronger extensional semantic conditions"
+  # according to the RDF Semantics document.
+  RDFSExtRuleBase = RuleBase.new('RDFSExtRuleBase') {
+    domain = Namespace.lookup(:rdfs, 'domain')
+    subClassOf = Namespace.lookup(:rdfs, 'subClassOf')
+    range = Namespace.lookup(:rdfs, 'range')
+    subPropertyOf = Namespace.lookup(:rdfs, 'subPropertyOf')
+    type = Namespace.lookup(:rdf, 'type')
+    resource = Namespace.lookup(:rdfs, 'Resource')
+    property = Namespace.lookup(:rdf, 'Property')
+    rdfsclass = Namespace.lookup(:rdfs, 'Class')
+    
+    # The following reasoning rules were taken from the RDF Semantics document
+    # http://www.w3.org/TR/rdf-mt/#RDFSExtRules
+    
+    rule 'ext1' do
+      condition :uuu, domain, :vvv
+      condition :vvv, subClassOf, :zzz
+      
+      conclusion :uuu, domain, :zzz
+    end
+    
+    rule 'ext2' do
+      condition :uuu, range, :vvv
+      condition :vvv, subClassOf, :zzz
+      
+      conclusion :uuu, range, :zzz
+    end
+    
+    rule 'ext3' do
+      condition :uuu, domain, :vvv
+      condition :www, subPropertyOf, :uuu
+      
+      conclusion :www, domain, :vvv
+    end
+    
+    rule 'ext4' do
+      condition :uuu, range, :vvv
+      condition :www, subPropertyOf, :uuu
+      
+      conclusion :www, range, :vvv
+    end
+    
+    rule 'ext5' do
+      condition type, subPropertyOf, :www
+      condition :www, domain, :vvv
+      
+      conclusion resource, subClassOf, :vvv
+    end
+    
+    rule 'ext6' do
+      condition subClassOf, subPropertyOf, :www
+      condition :www, domain, :vvv
+      
+      conclusion rdfsclass, subClassOf, :vvv
+    end
+    
+    rule 'ext7' do
+      condition subPropertyOf, subPropertyOf, :www
+      condition :www, domain, :vvv
+      
+      conclusion property, subClassOf, :vvv
+    end
+    
+    rule 'ext8' do
+      condition subClassOf, subPropertyOf, :www
+      condition :www, range, :vvv
+      
+      conclusion rdfsclass, subClassOf, :vvv
+    end
+    
+    rule 'ext9' do
+      condition subPropertyOf, subPropertyOf, :www
+      condition :www, range, :vvv
+      
+      conclusion property, subClassOf, :vvv
+    end
+  }
   
-  OWLRuleBase = RuleBase.new 'OWLRuleBase' do
+  # A preliminary (alpha) rule base for OWL reasoning.
+  OWLRuleBase = RuleBase.new('OWLRuleBase') {
     type = Namespace.lookup(:rdf, 'type')
     transProp = Namespace.lookup(:owl, 'TransitiveProperty')
     symProp = Namespace.lookup(:owl, 'SymmetricProperty')
@@ -262,6 +382,14 @@ class RuleEngine
     # owl:TransitiveProperty, then Q is also an owl:TransitiveProperty.
     
     # TODO All of the elements of an owl:AllDifferent are owl:differentFrom each other.
-  end.freeze
+  }
+  
+  RDFSRuleBase.freeze
+  RDFSRuleBase.rules.freeze
+  
+  RDFSExtRuleBase.freeze
+  RDFSExtRuleBase.rules.freeze
+  
+  OWLRuleBase.freeze
   OWLRuleBase.rules.freeze
 end

data/lib/activerdf_rules/rule_engine_mixin.rb

@@ -1,5 +1,7 @@
 # This module may be included in any writeable ActiveRDF adapter in order to
-# have automatic rule processing every time a triple is added to the database.
+# have automatic rule processing every time a triple is added to the database,
+# and it will continue to process the rules until none of the rules will add
+# new information to the database.
 # 
 # Example:
 #  class << adapter
@@ -11,15 +13,17 @@
 # mixed in.  If you do not specify a RuleEngine, then automatic rule processing
 # will NOT take place.
 # 
-# There are two included RuleBases one for RDF Schema, and one for OWL.
+# There are three included RuleBases two for RDF Schema, and one for OWL.
 module RuleEngineMixin
-  def self.included(base)
+  def self.included(base)#:nodoc:
     base.class_eval do
       attr_accessor :rule_engine
       attr_accessor :disable_rules
       alias _add add
       
-      #TODO
+      # Adding a triple to the database will trigger rule processing and it
+      # will continue to process rules until none of the rules will add new
+      # information to the database.
       def add(*a)
         r = _add(*a)
         unless @disable_rules || @rule_engine.nil?

data/lib/activerdf_rules/version.rb

@@ -2,7 +2,7 @@ module ActiveRDFRules #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end