ruleby 0.6 → 0.7

data/lib/core/engine.rb

@@ -23,6 +23,7 @@ module Ruleby
     attr_accessor :priority
     attr_accessor :name
     attr_reader   :matches
+    attr_reader   :proc
     
     def initialize(&block)
       @name = nil
@@ -30,8 +31,12 @@ module Ruleby
       @priority = 0
     end
             
-    def fire(match)
-      @proc.call(match)        
+    def fire(match, engine=nil)
+      if @proc.arity == 2
+        @proc.call(match, engine)
+      else
+        @proc.call(match)
+      end
     end 
        
     def ==(a2)
@@ -55,9 +60,9 @@ module Ruleby
       @used = false
     end   
     
-    def fire()
+    def fire(engine=nil)
       @used = true
-      @action.fire @match
+      @action.fire @match, engine
     end
     
     def <=>(a2)          
@@ -177,6 +182,7 @@ module Ruleby
   # instantiating it.  Each rule engine has one inference engine, one rule set
   # and one working memory.
   class Engine        
+    
     def initialize(wm=WorkingMemory.new,cr=RulebyConflictResolver.new)
       @root = nil
       @working_memory = wm
@@ -231,7 +237,7 @@ module Ruleby
           agenda = @conflict_resolver.resolve agenda            
           activation = agenda.pop   
           used_agenda.push activation     
-          activation.fire   
+          activation.fire self   
           if @wm_altered          
             agenda = @root.matches(false)    
             @root.increment_counter

data/lib/core/nodes.rb

@@ -414,7 +414,14 @@ module Ruleby
         # false, and the network traverse stops
         return
       end
-      super if @atom.proc.call(val)
+      begin
+        super if @atom.proc.call(val)
+      rescue Exception => e
+        # There is a bug in Ruby MRI that goes away when we call print.  Even if the following
+        # line of code is never executed at runtime.  The problem does not exist in JRuby
+        print ''
+        raise ProcessInvocationError.new(e), e.message
+      end
     end
   end
   

data/lib/core/utils.rb

@@ -18,6 +18,26 @@ module Ruleby
     class InitialFact
       
     end
+    
+    # Appearently Ruby doesn't have any kind of Exception chaining.  So this class will have
+    # fill the gap for Ruleby.  
+    class ProcessInvocationError < StandardError
+      def initialize(root_cause)
+        @root_cause = root_cause
+      end
+      
+      def backtrace
+        @root_cause.backtrace
+      end
+      
+      def inspect
+        @root_cause.inspect
+      end
+      
+      def to_s
+        @root_cause.to_s
+      end
+    end
   
     # This class is a wrapper for the context under which the network executes for
     # for a given fact.  It is essentially a wrapper for a fact and a partial

data/lib/dsl/ferrari.rb

@@ -4,9 +4,9 @@
 # modify it under the terms of the Ruby license defined in the
 # LICENSE.txt file.
 # 
-# Copyright (c) 2009 Joe Kutner and Matt Smith. All rights reserved.
+# Copyright (c) 2010 Joe Kutner and Matt Smith. All rights reserved.
 #
-# * Authors: Joe Kutner
+# * Authors: Joe Kutner, Matt Smith
 #
 
 module Ruleby
@@ -21,76 +21,159 @@ module Ruleby
       def rule(name, *args, &block) 
         options = args[0].kind_of?(Hash) ? args.shift : {}        
 
-        parse_containers(args, RulesContainer.new).build(name,options,@engine,&block)
-      end     
-
-      private
-      def parse_containers(args, container=AndContainer.new)
-        or_builders = []
-        and_container = AndContainer.new
-        args.each do |arg|
-          if arg.kind_of? Array
-            and_container << PatternContainer.new(arg)
-          elsif arg.kind_of? AndBuilder
-            and_container << parse_containers(arg.conditions)
-          elsif arg.kind_of? OrBuilder
-            or_builders << arg
+        rules = Ruleby::Ferrari.parse_containers(args, RulesContainer.new).build(name,options,@engine,&block)
+        rules.each do |r|
+          engine.assert_rule(r)
+        end
+      end
+    end
+    
+    def self.parse_containers(args, container=Container(:and), parent=nil)
+      con = nil
+      if(container.kind_of?(RulesContainer))
+        con = Container.new(:and)
+      else
+        con = container
+      end
+      args.each do |arg|
+        if arg.kind_of? Array
+          con << PatternContainer.new(arg)
+        elsif arg.kind_of? AndBuilder
+          con << parse_containers(arg.conditions, Container.new(:and), container)
+        elsif arg.kind_of? OrBuilder  
+          con << parse_containers(arg.conditions, Container.new(:or), container)
+        else
+          raise 'Invalid condition. Must be an OR, AND or an Array.'
+        end
+      end
+      if container.kind_of?(RulesContainer)
+        container << con
+      end
+      return container
+    end
+    
+    class RulesContainer < Array      
+      def transform_or(parent)
+        ors = []
+        others = []
+        permutations = 1
+        index = 0
+        parent.each do |child|
+          if(child.or?)
+            permutations *= child.size
+            ors << child
           else
-            raise 'Invalid condition. Must be an OR, AND or an Array.'
+            others[index] = child
           end
+          index = index + 1
         end
-                
-        if or_builders.empty?
-          container << and_container
-        else                                   
-          while !or_builders.empty?
-            or_builder = or_builders.pop          
-            parse_containers(or_builder.conditions, OrContainer.new).each do |or_container|
-              or_container.each do |or_container_child|
-                rule = AndContainer.new
-                rule.push or_container_child
-
-                or_builders.each do |sub_or_builder|
-                  parse_containers(sub_or_builder.conditions).each do |sub_or_container|
-                    rule.push *sub_or_container
-                  end
-                end
-
-                rule.push and_container
-                container << rule
-              end
-            end     
+        # set parent type to or and clear
+        parent.kind = :or
+        parent.clear
+        indexes = []
+        # initialize indexes
+        ors.each do |o|
+          indexes << 0
+        end
+        # create children
+        (1.upto(permutations)).each do |i|
+          and_container = Container.new(:and)
+          
+          mod = 1
+          (ors.size - 1).downto(0) do |j|
+            and_container.insert(0,ors[j][indexes[j]])
+            if((i % mod) == 0)
+              indexes[j] = (indexes[j] + 1) % ors[j].size
+            end
+            mod *= ors[j].size
           end
-        end  
-        return container
+          
+          others.each_with_index do |other, k|
+            if others[k] != nil
+              and_container.insert(k, others[k])
+            end
+          end  
+          # add child to parent        
+          parent.push(and_container)         
+        end
+        parent.uniq!
       end
-    end
-
-    class RulesContainer < Array
+      
+      def handle_branching(container)
+        ands = []
+        container.each do |x|
+          if x.or?
+            x.each do |branch|
+              ands << branch
+            end
+          elsif x.and?
+            ands << x
+          else
+            new_and = Container.new(:and)
+            new_and << x
+            ands << new_and
+          end   
+        end
+        return ands
+      end
+      
       def build(name,options,engine,&block)
-        self.each do |x|
-          r = RuleBuilder.new name
-          x.build r
-          r.then(&block)
-          r.priority = options[:priority] if options[:priority]
-          engine.assert_rule(r.build_rule)
+        rules = []        
+        self.each do |x|          
+          x.process_tree do |c|
+            transform_or(c)     
+          end
         end
+        handle_branching(self).each do |a|
+          rules << build_rule(name, a, options, &block)
+        end
+        return rules
+      end
+      
+      def build_rule(name, container, options, &block)
+        r = RuleBuilder.new name
+        container.build r
+        r.then(&block)
+        r.priority = options[:priority] if options[:priority]
+        r.build_rule
       end
     end
 
-    class AndContainer < Array      
+
+    class Container < Array
+      attr_accessor :kind
+      
+      def initialize(kind)
+        @kind = kind
+      end
+      
       def build(builder)
+        if self.or?
+          # OrContainers are never built, they just contain containers that
+          # will be transformed into AndContainers.
+          raise 'Invalid Syntax'
+        end
         self.each do |x|
           x.build builder
         end
       end
-    end
-
-    class OrContainer < Array      
-      def build(builder)
-        # OrContainers are never built, they just contain containers that
-        # will be transformed into AndContainers.
-        raise 'Invalid Syntax'
+      
+      def or?
+        return kind == :or
+      end
+      
+      def and?
+        return kind == :and
+      end
+      
+      def process_tree(&block)
+        has_or_child = false
+        uniq!
+        each do |c|          
+          has_or_child = true if (c.process_tree(&block) or c.or?)
+        end        
+        yield(self) if (has_or_child)
+        return has_or_child
       end
     end
     
@@ -102,6 +185,19 @@ module Ruleby
       def build(builder)
         builder.when(*@condition)
       end
+      
+      def process_tree
+        # there is no tree to process
+        false
+      end
+      
+      def or?
+        false
+      end
+      
+      def and?
+        false
+      end
     end
 
     class RuleBuilder
@@ -288,10 +384,6 @@ module Ruleby
         create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= value}; self
       end 
       
-      def =~(value)
-        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
-      end 
-      
       def build_atoms(tags,methods,when_id)
         atoms = @child_atom_builders.map { |atom_builder|
           tags[atom_builder.tag] = when_id

data/lib/rule_helper.rb

@@ -0,0 +1,56 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors:  Joe Kutner, Matt Smith
+#
+
+require 'core/engine'
+
+module Ruleby
+  module RuleHelper
+    def rule(*args, &block) 
+      name = nil
+      unless args.empty?
+        name = args[0].kind_of?(Symbol) ? args.shift : GeneratedTag.new
+      end
+      options = args[0].kind_of?(Hash) ? args.shift : {}        
+
+      rules = Ruleby::Ferrari.parse_containers(args, Ruleby::Ferrari::RulesContainer.new).build(name,options,@engine,&block)
+      rules
+    end
+
+    def m
+      Ruleby::Ferrari::MethodBuilder.new
+    end
+
+    def method
+      m
+    end
+
+    def b(variable_name)
+      Ruleby::Ferrari::BindingBuilder.new(variable_name)
+    end
+    
+    def c(&block)
+      return lambda(&block)
+    end
+
+    def OR(*args)
+      Ruleby::Ferrari::OrBuilder.new args
+    end
+
+    def AND(*args)
+      Ruleby::Ferrari::AndBuilder.new args
+    end
+
+    def __eval__(x)
+      eval(x)
+    end
+    
+   end
+end

data/lib/rulebook.rb

@@ -10,6 +10,7 @@
 #
 
 require 'ruleby'
+require 'rule_helper'
 require 'dsl/ferrari'
 require 'dsl/letigre'
 require 'dsl/steel'
@@ -17,6 +18,7 @@ require 'dsl/steel'
 module Ruleby
   class Rulebook
     include Ruleby
+    include Ruleby::RuleHelper
     def initialize(engine, &block)
       @engine = engine
       yield self if block_given?
@@ -57,66 +59,30 @@ module Ruleby
         end
       end
     end
-    
-    def m
-      Ruleby::Ferrari::MethodBuilder.new
-    end
-    
-    def method
-      m
-    end
-    
-    def b(variable_name)
-      Ruleby::Ferrari::BindingBuilder.new(variable_name)
-    end
-    
-    def binding(variable_name)
-      b variable_name
-    end
-    
-    def c(&block)
-      return lambda(&block)
-    end
-    
-    def condition(&block)
-      return lambda(&block)
-    end
-    
-    def OR(*args)
-      Ruleby::Ferrari::OrBuilder.new args
-    end
-    
-    def AND(*args)
-      Ruleby::Ferrari::AndBuilder.new args
-    end
-    
-    def __eval__(x)
-      eval(x)
-    end
-  end  
+  end
   
   class GeneratedTag  
     # this counter is incremented for each UniqueTag created, and is
     # appended to the end of the unique_seed in order to create a 
     # string that is unique for each instance of this class.
     @@tag_counter = 0
-    
+
     # every generated tag will be prefixed with this string
     @@unique_seed = 'unique_seed'
-  
+
     def initialize()
       @@tag_counter += 1
       @tag = @@unique_seed + @@tag_counter.to_s
     end
-    
+
     attr_reader:tag_counter
     attr_reader:unique_seed
     attr_reader:tag
-    
+
     def ==(ut)
       return ut && ut.kind_of?(GeneratedTag) && @tag == ut.tag
     end
-    
+
     def to_s
       return @tag.to_s
     end

data/lib/ruleby.rb

@@ -18,7 +18,7 @@ module Ruleby
     e = Core::Engine.new
     yield e if block_given?
     return e
-  end
+  end  
 end
 
 class String

data/tests/test.rb

@@ -17,3 +17,4 @@ require 'assert_facts'
 require 'not_patterns'
 require 'or_patterns'
 require 'join_nodes'
+require 'nil'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruleby
 version: !ruby/object:Gem::Version 
-  version: "0.6"
+  version: "0.7"
 platform: ruby
 authors: 
 - Joe Kutner
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-23 00:00:00 -06:00
+date: 2010-08-27 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -36,6 +36,7 @@ files:
 - lib/dsl/ferrari.rb
 - lib/dsl/letigre.rb
 - lib/dsl/steel.rb
+- lib/rule_helper.rb
 - lib/rulebook.rb
 - lib/ruleby.rb
 has_rdoc: true