activerdf_rules 0.0.1

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+setup.rb
+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/version.rb
+test/test_helper.rb
+test/activerdf_rules_test.rb

data/README.txt

@@ -0,0 +1,33 @@
+=What it is?
+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
+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
+  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!
+* 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
+  the project.  If you're that concerned, then fork the code, and keep a copy for
+  yourself.  However, I will do my best to make sure that the implementation and
+  interface evolve in a way that it breaks as little existing code as possible.
+
+=What next?
+Take a look at the documentation.  Especially look at the person_example.rb
+file.  It contains a pretty heavily annotated example.  If you have (or will)
+install this as a gem, then look for that in the gem directory
+(/usr/lib/ruby/gems/1.8/gems/activerdf-rules-X.X/examples) or some such
+nonsense.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'activerdf_rules', 'version')
+
+AUTHOR = "pjstadig"  # can also be an array of Authors
+EMAIL = "paul@stadig.name"
+DESCRIPTION = "A rulebase and forward chaining production system for activerdf databases"
+GEM_NAME = "activerdf_rules" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "activerdf-rules" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem ) # can use: gem, tar, zip
+
+
+NAME = "activerdf_rules"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (ActiveRDFRules::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "activerdf_rules documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end

data/examples/person_example.rb

@@ -0,0 +1,67 @@
+#=== Initial Setup Code
+require 'rubygems'
+require 'active_rdf'
+require 'activerdf_rules'
+
+adapter = ConnectionPool.add_data_source :type => :redland
+Namespace.register(:test, 'http://test.com/')
+adapter.add(Namespace.lookup(:test, 'Person'), Namespace.lookup(:rdf, 'type'), Namespace.lookup(:rdfs, 'Class'))
+adapter.add(Namespace.lookup(:test, 'eye'), Namespace.lookup(:rdf, 'type'), Namespace.lookup(:rdf, 'Property'))
+adapter.add(Namespace.lookup(:test, 'eye'), Namespace.lookup(:rdfs, 'domain'), Namespace.lookup(:test, 'Person'))
+adapter.add(Namespace.lookup(:test, 'eye'), Namespace.lookup(:rdfs, 'range'), Namespace.lookup(:test, 'Color'))
+ObjectManager.construct_classes
+
+#=== Here is the real example
+# First we add couple of resources to the database.
+paul = TEST::Person.new Namespace.expand(:test, 'Paul')
+paul.save
+
+blue = Namespace.lookup(:test, 'blue')
+blue.save
+
+# Now we set paul's eye property to blue.
+paul.eye = blue
+
+# The next line should simple read '[RDFS::Resource]'.
+p blue.type
+
+# Now we'll see how you can use the rule engine to manually process rules.
+re = RuleEngine.new :rule_base => RuleEngine::RDFSRuleBase
+
+# Calling process_rules once will try every rule once.
+re.process_rules
+
+# Calling process_rules in a loop will process all of the rules until nothing
+# more can be concluded.  This works because process_rules returns true if it
+# added new information.
+while re.process_rules; end
+
+# Now we can see that blue's type will include TEST::Color because one of the
+# RDFS rules fired.
+p blue.type
+
+#=== Example two
+# Say you wanted to have the rule engine automatically process all of the rules
+# every time a new triple is added to the database.  There are two ways of
+# doing this:  first, you can re-open the class and include the mix-in
+# 
+# class RedlandAdapter
+#   include RuleEngineMixin
+# end
+# 
+# Second, you can just add the mix-in to an objects meta-class like below, if
+# for example you don't want every instance of the adapter to have rule
+# processing.
+class << adapter
+  include RuleEngineMixin
+end
+adapter.rule_engine = RuleEngine.new :rule_base => RuleEngine::RDFSRuleBase
+red = Namespace.lookup(:test, 'red')
+red.save
+
+p red.type
+paul.eye = red
+
+# Now by just adding the triple to the database, we automatically have our
+# rules fire.
+p red.type

data/lib/activerdf_rules/rule_base.rb

@@ -0,0 +1,195 @@
+# An instance of the RuleBase class contains a set of rules for processing with
+# the RuleEngine.  It has a built in DSL that can be used to create a rule
+# base.
+# 
+# Example:
+#  rb = RuleBase.new do
+#    rule 'Rule1' do
+#      condition :x, :y, :z
+#      
+#      conclusion :z, :y, :x
+#    end
+#    
+#    rule 'Rule2' do
+#      condition :x, :y, :z
+#      
+#      conclusion :y, :x, :z
+#    end
+#  end
+# 
+# Additionally, you can create an instance of RuleBase and just add rules to
+# the +rules+ array manually
+# 
+# Example:
+#  rb = RuleBase.new 'DSLRuleBase'
+#  r = RuleBase::Rule.new 'Rule 1'
+#  r.condition :x, :y, :z
+#  r.conclusion :z, :y, :x
+#  rb.rules << r
+# 
+# As you can see from these examples you can create variables in your rules by
+# using symbols.
+# 
+# There is no point in adding more than one rule that has the same conditions
+# and conclusion (i.e. they do the same thing), because it will just mean that
+# the RuleEngine will process an extra rule with no extra benefit.
+# 
+# Currently, RuleBase does not verify that you are adding unique rules.
+# However, it does verify that the conclusion and all of the conditions are
+# triples.  It also verifies that the subject and predicate of the conclusion
+# and every condition are either variables or resources.  Additionally, it only
+# allows you to set one conclusion.  If any of these conditions is not met,
+# then it will throw an exception.
+# 
+# When using the class as a DSL it will also check each rule as it is added to
+# ensure that all of the variables that appear in the conclusion also appear in
+# at least one condition.  If this condition is not met it will throw an
+# exception.  When adding rules manually to the +rules+ array it will not
+# perform this check.  However, later on when the RuleEngine converts the rule
+# to a query ActiveRDF will throw an exception if this condition is not met.
+class RuleBase
+  attr_accessor :name, :rules
+  
+  # Any block that is passed in will be instance_eval'ed, which will allow you
+  # to use the built in DSL.
+  def initialize(name = nil, &b)
+    @name = name || 'NoName'
+    @rules = []
+    instance_eval(&b) if b
+  end
+  
+  # Used in the DSL method to add a rule to this rule base.
+  def rule(name = nil, &b)
+    r = Rule.new name || "Rule #{@rules.size + 1}"
+    r.instance_eval(&b)
+    r.validate
+    @rules << r
+    $activerdflog.debug("Adding '#{r}' to '#{self}'")
+  end
+  
+  # Makes a deep copy of the rule base, including the +rules+ array.
+  def dup
+    rb = super
+    rb.rules = self.rules.dup
+    rb
+  end
+  
+  # Returns the name of the rule base
+  def to_s
+    @name
+  end
+  
+  # A rule for adding information to an ActiveRDF store.  A rule consists of a
+  # set of conditions and a single conclusion.  Each condition consists of a
+  # triple (with variables) that is matched against the database.  When all of
+  # 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
+  # conditions and the conclusion with the following caveat: any variable that
+  # appears in the conclusion must also appear in at least one condition.
+  # 
+  # Example:
+  #  r = RuleBase::Rule.new
+  #  r.condition :x, :y, :z
+  #  r.conclusion :z, :y, :x
+  class Rule
+    attr_reader :name, :conditions
+    
+    def initialize(name)
+      @name = name
+      @conditions = []
+      @conclusion = nil
+    end
+    
+    # Adds a condition to the rule where s, p, and o are the subject,
+    # predicate, and object (respectively).
+    def condition(s, p, o)
+      raise "Condition subject #{s} must be a Symbol or an RDFS::Resource" unless [Symbol, RDFS::Resource].include?(s.class)
+      raise "Condition subject #{p} must be a Symbol or an RDFS::Resource" unless [Symbol, RDFS::Resource].include?(p.class)
+      c = [s, p, o]
+      @conditions << c
+      $activerdflog.debug("Adding condition #{c.inspect} to '#{self}'")
+    end
+    
+    # Sets the conclusion of the rule where s, p, and o are the subject,
+    # predicate, and object (respectively).
+    def conclusion(s, p, o)
+      raise "Conclusion already set" unless @conclusion.nil?
+      raise "Conclusion subject #{s} must be a Symbol or an RDFS::Resource" unless [Symbol, RDFS::Resource].include?(s.class)
+      raise "Conclusion subject #{p} must be a Symbol or an RDFS::Resource" unless [Symbol, RDFS::Resource].include?(p.class)
+      c = [s, p, o]
+      @conclusion = c
+      $activerdflog.debug("Setting conclusion #{c.inspect} for '#{self}'")
+    end
+    
+    # Checks that every variable in the conclusion also appears in at least on
+    # condition.  If this condition is not satisfied, then an exception is
+    # thrown.
+    def validate
+      # for each conclusion variable verify that it appears in one of the conditions
+      @conclusion.each do |x|
+        if x.is_a?(Symbol)
+          catch(:done) do
+            @conditions.each do |c|
+              throw :done if c.include?(x)
+            end
+            raise "Unbound variable :#{x} in conclusion"
+          end
+        end
+      end
+    end
+    
+    # Processes this rule by converting it to a query, if the query is
+    # successful, then the conclusion is introduced into the data store after
+    # substituting for any variables.
+    def process
+      $activerdflog.debug("processing '#{self}'")
+      q = Query.new
+      lookup = @conclusion.select{|c| c.is_a?(Symbol)}.uniq
+      q.select(*lookup)
+      @conditions.each do |c|
+        q.where(*c)
+      end
+      
+      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
+        end
+      end
+      change
+    end
+    
+    # Returns either the value for +var+ by using +lookup+, the value of +row+,
+    # if the query resulted in a single value, or the value of +var+ since in
+    # this case it must be either an +RDFS::Resource+ or a literal.
+    def instantiate(var, row, lookup)
+      if var.is_a?(Symbol)
+        if lookup.size == 1 && !row.is_a?(Array)
+          row
+        else
+          row[lookup.index(var)]
+        end
+      else
+        var
+      end
+    end
+    
+    # Returns the name of this rule
+    def to_s
+      @name
+    end
+  end
+end

data/lib/activerdf_rules/rule_engine.rb

@@ -0,0 +1,267 @@
+# A RuleEngine will use a RuleBase to add new data to an ActiveRDF data store
+# by processing the rules.
+# TODO
+class RuleEngine
+  attr_accessor :rule_base
+  
+  # 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]
+  end
+  
+  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
+  end
+  
+  def process_rules
+    $activerdflog.debug("processing '#{@rule_base}'")
+    change = false
+    @rule_base.rules.each do |r|
+      change |= r.process
+    end
+    change
+  end
+  
+  RDFSRuleBase = RuleBase.new 'RDFSRuleBase' do
+    type = Namespace.lookup(:rdf, 'type')
+    rdfclass = Namespace.lookup(:rdfs, 'Class')
+    subClassOf = Namespace.lookup(:rdfs, 'subClassOf')
+    property = Namespace.lookup(:rdf, 'Property')
+    subPropertyOf = Namespace.lookup(:rdfs, 'subPropertyOf')
+    range = Namespace.lookup(:rdfs, 'range')
+    domain = Namespace.lookup(:rdfs, 'domain')
+    
+    # The following reasoning rules where taken from
+    # http://www-ksl.stanford.edu/software/jtp/doc/owl-reasoning.html
+    
+    # Type inheritance through rdfs:subclassOf
+    rule do
+      condition :Morris, type, :Cat
+      condition :Cat, subClassOf, :Mammal
+      
+      conclusion :Morris, type, :Mammal
+    end
+    
+    # Reflexivity of rdfs:subPropertyOf and rdfs:subclassOf
+    rule do
+      condition :p, type, property
+      
+      conclusion :p, subPropertyOf, :p
+    end
+    
+    rule do
+      condition :p, type, rdfclass
+      
+      conclusion :p, subClassOf, :p
+    end
+    
+    # Type inference through rdfs:range and rdfs:domain constraints
+    rule do
+      condition :teaches, domain, :Teacher
+      condition :Bob, :teaches, :Scooter
+      
+      conclusion :Bob, type, :Teacher
+    end
+    
+    rule do
+      condition :teaches, range, :Student
+      condition :Bob, :teaches, :Scooter
+      
+      conclusion :Scooter, type, :Student
+    end
+    
+    # Transitivity of rdfs:subClassOf and rdfs:subPropertyOf
+    rule do
+      condition :Dog, subClassOf, :Mammal
+      condition :Mammal, subClassOf, :Animal
+      
+      conclusion :Dog, subClassOf, :Animal
+    end
+    
+    rule do
+      condition :parent, subPropertyOf, :ancestor
+      condition :ancestor, subPropertyOf, :relative
+      
+      conclusion :parent, subPropertyOf, :relative
+    end
+  end.freeze
+  RDFSRuleBase.rules.freeze
+  
+  OWLRuleBase = RuleBase.new 'OWLRuleBase' do
+    type = Namespace.lookup(:rdf, 'type')
+    transProp = Namespace.lookup(:owl, 'TransitiveProperty')
+    symProp = Namespace.lookup(:owl, 'SymmetricProperty')
+    inverseOf = Namespace.lookup(:owl, 'inverseOf')
+    disjointWith = Namespace.lookup(:owl, 'disjointWith')
+    subClassOf = Namespace.lookup(:rdfs, 'subClassOf')
+    sameAs = Namespace.lookup(:owl, 'sameAs')
+    rdfclass = Namespace.lookup(:rdfs, 'Class')
+    equivClass = Namespace.lookup(:owl, 'equivalentClass')
+    complementOf = Namespace.lookup(:owl, 'complementOf')
+    funcProp = Namespace.lookup(:owl, 'FunctionalProperty')
+    invFuncProp = Namespace.lookup(:owl, 'InverseFunctionalProperty')
+    onProperty = Namespace.lookup(:owl, 'onProperty')
+    hasValue = Namespace.lookup(:owl, 'hasValue')
+    allValuesFrom = Namespace.lookup(:owl, 'allValuesFrom')
+    someValuesFrom = Namespace.lookup(:owl, 'someValuesFrom')
+    
+    # The following reasoning rules where taken from
+    # http://www-ksl.stanford.edu/software/jtp/doc/owl-reasoning.html
+    
+    # Enforcing transitivity of owl:TransitiveProperty.
+    rule do
+      condition :ancestor, type, transProp
+      condition :Sue, :ancestor, :Mary
+      condition :Mary, :ancestor, :Anne
+
+      conclusion :Sue, :ancestor, :Anne
+    end
+
+    # Semantics of owl:SymmetricProperty is enforced.
+    rule do
+      condition :relative, type, symProp
+      condition :Sue, :relative, :Mary
+
+      conclusion :Mary, :relative, :Sue
+    end
+    
+    # Reasoning with owl:inverseOf.
+    rule do
+      condition :parentOf, inverseOf, :hasParent
+      condition :Goldie, :parentOf, :Kate
+
+      conclusion :Kate, :hasParent, :Goldie
+    end
+
+    # Inheritance of disjointness constraints.
+    rule do
+      condition :Plant, disjointWith, :Animal
+      condition :Mammal, subClassOf, :Animal
+
+      conclusion :Plant, disjointWith, :Mammal
+    end
+
+    # When an owl:sameAs relationship is asserted or inferred between two
+    # entities that are known to be classes, an owl:equivalentClass
+    # relationship is inferred between the classes. Similarly, when an
+    # owl:sameAs relationship is asserted or inferred between two entities that
+    # are known to be properties, an owl:equivalentProperty relationship is
+    # inferred between the classes.
+    rule do
+      condition :Human, sameAs, :Person
+      condition :Human, type, rdfclass
+      condition :Person, type, rdfclass
+
+      conclusion :Human, equivClass, :Person
+    end
+
+    # All the subclasses of a given class are disjoint with the class's
+    # complement.
+    rule do
+      condition :Animal, complementOf, :NonAnimals
+      condition :Mammal, subClassOf, :Animal
+
+      conclusion :Mammal, disjointWith, :NonAnimals
+    end
+
+    # A complicated bit of reasoning about owl:complementOf captured by
+    # following KIF axiom.
+    rule do
+      condition :c1, complementOf, :c2
+      condition :c3, subClassOf, :c1
+      condition :c4, subClassOf, :c2
+      condition :c4, complementOf, :c5
+      
+      conclusion :c3, subClassOf, :c5
+    end
+
+    # Inferring owl:sameAs relationships via owl:FunctionalProperty and
+    # owl:InverseFunctionalProperty.
+    rule do
+      condition :mother, type, funcProp
+      condition :Joe, :mother, :Margaret
+      condition :Joe, :mother, :Maggie
+
+      conclusion :Margaret, sameAs, :Maggie
+    end
+
+    rule do
+      condition :motherOf, type, invFuncProp
+      condition :Margaret, :motherOf, :Joe
+      condition :Maggie, :motherOf, :Joe
+
+      conclusion :Margaret, sameAs, :Maggie
+    end
+
+    # TODO If a class A is owl:oneOf a list of objects, say X, Y, and Z, then
+    # each of X, Y, and Z has rdf:type A.
+    
+    # If an object is rdf:type an owl:hasValue owl:Restriction, then the object
+    # has the specified value for the specified property.
+    rule do
+      condition :RestrictionOrangeSkin, onProperty, :skinColor
+      condition :RestrictionOrangeSkin, hasValue, :Orange
+      condition :MrOompaLoompa, type, :RestrictionOrangeSkin
+
+      conclusion :MrOompaLoompa, :skinColor, :Orange
+    end
+
+    # If an owl:hasValue owl:Restriction restricts a particular property to a
+    # particular value, and an object has that value for that property, then
+    # the object has the Restriction as a type.
+    rule do
+      condition :RestrictionOrangeSkin, onProperty, :skinColor
+      condition :RestrictionOrangeSkin, hasValue, :Orange
+      condition :MrOompaLoompa, :skinColor, :Orange
+
+      conclusion :MrOompaLoompa, type, :RestrictionOrangeSkin
+    end
+
+    # If an object is a rdf:type an owl:allValuesFrom owl:Restriction, and the
+    # object has values for the specified property, then the values are of the
+    # specified type.
+    rule do
+      condition :RestrictionCatChildren, onProperty, :child
+      condition :RestrictionCatChildren, allValuesFrom, :Cat
+      condition :Fluffy, type, :RestrictionCatChildren
+      condition :Fluffy, :child, :Cupcake
+
+      conclusion :Cupcake, type, :Cat
+    end
+
+    # If an owl:someValuesFrom owl:Restriction restricts a particular property
+    # to a particular type, and if an object has some values of the specificied
+    # type for the specified property, then that object has the Restriction as
+    # a type.
+    rule do
+      condition :RestrictionIvyLeagueDegree, onProperty, :degree
+      condition :RestrictionIvyLeagueDegree, someValuesFrom, :IvyLeagueSchool
+      condition :Mary, :degree, :Harvard
+      condition :Harvard, type, :IvyLeagueSchool
+
+      conclusion :Mary, type, :RestrictionIvyLeagueDegree
+    end
+
+    # TODO If a property Q is owl:inverseOf of a property P, and P is an
+    # 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
+  OWLRuleBase.rules.freeze
+end

data/lib/activerdf_rules/rule_engine_mixin.rb

@@ -0,0 +1,34 @@
+# 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.
+# 
+# Example:
+#  class << adapter
+#    include RuleEngineMixin
+#  end
+#  adapter.rule_engine = RuleEngine.new :rule_base => RuleEngine::RDFSRuleBase
+# 
+# Notice that you must set the +rule_engine+ attribute after the module is
+# 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.
+module RuleEngineMixin
+  def self.included(base)
+    base.class_eval do
+      attr_accessor :rule_engine
+      attr_accessor :disable_rules
+      alias _add add
+      
+      #TODO
+      def add(*a)
+        r = _add(*a)
+        unless @disable_rules || @rule_engine.nil?
+          @disable_rules = true
+          while @rule_engine.process_rules; end
+          @disable_rules = false
+        end
+        r
+      end
+    end
+  end
+end

data/lib/activerdf_rules/version.rb

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

data/lib/activerdf_rules.rb

@@ -0,0 +1,3 @@
+require 'activerdf_rules/rule_base'
+require 'activerdf_rules/rule_engine'
+require 'activerdf_rules/rule_engine_mixin'