ruleby 0.1

data/lib/rulebook.rb

@@ -0,0 +1,205 @@
+require 'ruleby'
+
+class Rulebook
+  include Ruleby
+  def initialize(rete)
+    @rete = rete
+  end
+
+  attr_reader :rete
+
+  def rule(name, &block)
+    r = Core::Rule.new name
+    yield r if block_given?
+    @rete.assert_rule r
+    r
+  end
+  
+  def action(&block)
+    return Core::Action.new(&block)
+  end
+  
+  def pattern(&block)
+    pb = PatternBuilder.new
+    yield pb
+    return pb.condition
+  end
+end
+
+
+ class PatternInternal
+    def initialize(tag, type)
+      @tag = tag
+      @type = type  
+      @atoms = []
+    end
+
+    def atom(tag, name, references, &block)
+      if references
+        references = [references] unless references.kind_of?(Array)
+        return Core::ReferenceAtom.new(tag, name, references, &block)
+      else
+        return Core::PropertyAtom.new(tag, name, &block)
+      end
+    end
+    def method_missing(method_id, *args, &block)
+      if block_given?
+        with(method_id.to_s, *args, &block) 
+      else
+        with(method_id.to_s, *args)
+      end
+    end
+    def with(property, options={}, &block)
+      tag = options[:name]      
+      tag = GeneratedTag.new if tag == options.default
+      if block_given?        
+        @atoms.push atom(tag, property, options[:references], &block)
+      else
+        # QUESTION do we really want to do this?  What if someone does:
+        #   :equals => -1
+        # How do we handle a case where it is not a ReferenceAtom?  should we
+        # have a :equals_ref key too?
+#        if options[:equals] != options.default
+#          @atoms.push(atom(tag, property, [options[:equals]]) do |p,a| p==a end)
+#        elsif options[:not_equals] != options.default
+#          @atoms.push(atom(tag, property, [options[:not_equals]]) do |p,a| p!=a end)
+#        else
+          @atoms.push(atom(tag, property, nil) do |p| true end)
+#        end
+      end
+    end
+
+    def pattern
+      @atoms = Array.new(1){@atoms} unless @atoms.kind_of?(Array)
+      return Core::ObjectPattern.new(@tag, @type, @atoms)
+    end
+   
+    def not
+      @atoms = Array.new(1){@atoms} unless @atoms.kind_of?(Array)
+      return Core::NotPattern.new(@tag, @type, @atoms)
+    end
+  end
+class PatternInternal
+  public_instance_methods.each do |m|
+    a = [:not, :pattern, :with, :method_missing, :atom, :new, :public_instance_methods, :__send__, :__id__]
+    undef_method m.to_sym unless a.include? m.to_sym
+  end
+end
+  
+  class PatternBuilder < Rulebook
+       
+    attr_reader :condition
+   
+    def initialize()
+      @condition = nil
+    end
+    
+    def has(type, tag=GeneratedTag.new, &block)
+      pi = pattern_internal(tag, type)
+      yield pi if block_given? 
+      op = pi.pattern
+      if(@condition)
+        pat = [@condition, op]
+        @condition = and_pattern(pat)
+      else
+        @condition = op
+      end
+      @condition
+    end
+    def and(operands)
+      if @condition
+        p = [@condition] + operands
+        @condition = and_pattern(p)
+      else
+        @condition = and_pattern(operands)
+      end
+      @condition
+    end
+       
+    def or(operands)
+      if(@condition)
+        p = [@condition] + operands
+        @condition = or_pattern(p)
+      else
+        @condition = or_pattern(operands)
+      end
+      @condition
+    end
+       
+    def not(type, tag=GeneratedTag.new, &block)
+     pi = pattern_internal(tag, type)
+     yield pi if block_given? 
+     n = pi.not
+     if(@condition)
+       p = [@condition, n]
+       @condition = and_pattern(p)
+     else
+       @condition = n
+     end
+    end
+       
+    private
+    def pattern_internal(tag, type)
+      return PatternInternal.new(tag, type)
+    end
+
+    def or_pattern(operands)
+      # TODO raise exception if referenceAtoms from the right do not
+      # have the values they referenece in the left
+      # TODO raise exception if there are repeated tags?
+      left = nil
+      operands.each do |operand|
+        if left.nil?
+          left = operand
+        else           
+          right = operand
+          left = Core::OrPattern.new(left, right)
+        end
+      end
+      left
+    end
+
+    def and_pattern(operands)
+      # TODO raise exception if referenceAtoms from the right do not
+      # have the values they referenece in the left
+      # TODO raise exception if there are repeated tags?
+      left = nil
+      operands.each do |operand|
+        if left.nil?
+          left = operand
+        else           
+          right = operand
+          left = Core::AndPattern.new(left, right)
+        end
+      end
+      left
+    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
+  end

data/lib/ruleby.rb

@@ -0,0 +1,29 @@
+require 'core/engine'
+module Ruleby
+  #helper classes for using ruleby go here
+  def engine(name, &block)
+    e = Core::Engine.new
+    yield e if block_given?
+    return e
+  end
+  def assert(rete,object,&block)
+    fact(rete,object,:plus,&block)
+  end
+  
+  def retract(rete,object,&block)
+    fact(rete,object,:minus,&block)
+  end
+  
+  def modify(rete,object,&block)
+    retract(rete,object,&block)
+    assert(rete,object,&block)
+  end
+  
+  private 
+  def fact(rete, object, sign=:plus, &block)
+    f = Core::Fact.new object, sign
+    yield f if block_given?
+    rete.assert_fact f
+    f
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ruleby
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2007-04-29 00:00:00 -05:00
+summary: the Rule Engine for Ruby
+require_paths: 
+- lib
+email: matt@ruleby.org
+homepage: http://www.ruleby.org
+rubyforge_project: 
+description: ruleby is the Rule Engine for Ruby
+autorequire: ruleby
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Joe Kutner, Matt Smith
+files: 
+- lib/rulebook.rb
+- lib/ruleby.rb
+- lib/core/atoms.rb
+- lib/core/engine.rb
+- lib/core/nodes.rb
+- lib/core/patterns.rb
+- lib/core/utils.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+