ruleby 0.9.b4 → 0.9.b7

data/tests/nil.rb

@@ -0,0 +1,72 @@
+# 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) 2010 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith
+#
+
+require 'test/unit'
+require 'ruleby'
+
+include Ruleby
+
+module Nil
+  
+  class Number
+    def initialize(value)
+       @value = value
+     end
+     attr:value, true
+  end
+  
+  class NilRulebook < Rulebook
+    def rules        
+      rule [Number, :m, m.value == 42], [Context, :c] do |v|
+        v[:c].inc :rule1
+      end  
+      
+      rule [Number, :m, m.value < 42], [Context, :c] do |v|
+        v[:c].inc :rule2
+      end   
+      
+      rule [Number, :m, m.value > 42], [Context, :c] do |v|
+        v[:c].inc :rule3
+      end
+      
+      rule [Number, :m, m.value <= 42], [Context, :c] do |v|
+        v[:c].inc :rule4
+      end
+      
+      rule [Number, :m, m.value >= 42], [Context, :c] do |v|
+        v[:c].inc :rule5
+      end
+    end
+  end
+  
+  class Test < Test::Unit::TestCase
+  
+    def test_0
+      
+      engine :engine do |e|
+        NilRulebook.new(e).rules
+        
+        ctx = Context.new
+        e.assert ctx
+        e.assert Number.new(43)
+        e.assert Number.new(42)
+        e.assert Number.new(41)
+        e.match
+        
+        assert_equal 1, ctx.get(:rule1)
+        assert_equal 1, ctx.get(:rule3)
+        assert_equal 1, ctx.get(:rule2)
+        assert_equal 2, ctx.get(:rule4)
+        assert_equal 2, ctx.get(:rule5)
+      end
+    end
+  end
+end

data/tests/not_patterns.rb

@@ -0,0 +1,91 @@
+# 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) 2008 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
+require 'test/unit'
+
+require 'ruleby'
+
+include Ruleby
+
+module NotPatterns
+  
+  class A 
+    attr :name, true
+  end
+  
+  class B
+    attr :name, true    
+  end
+
+  class C
+    attr :name, true    
+  end
+
+  class NotPatternsRulebook < Rulebook
+    def rules        
+      rule [:not, A], [Context, :c] do |v|
+        v[:c].inc :rule1
+      end   
+            
+      rule [Context, :c], [:not, A, m.name == :X] do |v|
+        v[:c].inc :rule2
+      end 
+      
+      rule [:not, A, m.name == :Y], [Context, :c] do |v|
+        v[:c].inc :rule3
+      end 
+            
+      rule [A, {m.name => :x}], 
+           [:not, B, m.name == b(:x)], 
+           [Context, :c] do |v|
+        v[:c].inc :rule4
+      end
+
+      rule [A, :a, {m.name => :x}], 
+           [:not, C, :c, m.name == b(:x)], 
+           [Context, :c] do |v|
+        v[:c].inc :rule5
+      end
+      
+      rule [:not, Message], [Context, :c] do |v|
+        v[:c].inc :rule6
+      end
+    end
+  end
+    
+  class Test < Test::Unit::TestCase  
+    def test_0  
+      engine :engine do |e|
+        NotPatternsRulebook.new(e).rules
+        ctx = Context.new
+        e.assert ctx
+        
+        a = A.new
+        a.name = :X
+        e.assert a
+        b = B.new
+        b.name = :Y
+        e.assert b
+        c = C.new
+        c.name = :X        
+        e.assert c
+        
+        e.match          
+        assert_equal 0, ctx.get(:rule1)
+        assert_equal 1, ctx.get(:rule3)
+        assert_equal 0, ctx.get(:rule2)
+        assert_equal 1, ctx.get(:rule4)
+        assert_equal 0, ctx.get(:rule5)
+        assert_equal 1, ctx.get(:rule6)
+      end
+    end
+  end
+end

data/tests/or_patterns.rb

@@ -0,0 +1,154 @@
+# 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) 2009 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
+require 'test/unit'
+
+require 'ruleby'
+
+include Ruleby
+
+module OrPatterns
+
+  class OrPatternsRulebook < Rulebook
+    def rules    
+      rule OR([Message, m.message == :FIRST], [Message, m.message == :SECOND]), [Context, :c] do |v|
+        v[:c].inc :rule1
+      end  
+      
+      rule OR([Message, m.message == :FIRST], [Message, m.message == :FOOBAR]), [Context, :c] do |v|
+        v[:c].inc :rule2
+      end 
+      
+      rule OR([Message, m.message == :FIRST], [Message, m.message == :FIRST]), [Context, :c] do |v|
+        v[:c].inc :rule3
+      end
+      
+      rule OR([Message, m.message == :FOO], [Message, m.message == :BAR]), [Context, :c] do |v|
+        # this is not expected to pass
+        v[:c].inc :rule4
+      end
+         
+      rule OR([Message, m.message == :FOOBAR], [Message, m.message == :SECOND]), [Context, :c] do |v|
+        v[:c].inc :rule5
+      end
+      
+      rule AND([Message, m.message == :FIRST], [Message, m.message == :SECOND]), [Context, :c] do |v|
+        # no reason for this to work - its verbose, just checking.
+        v[:c].inc :rule6
+      end
+      
+      rule AND([Message, m.message == :FOOBAR], [Message, m.message == :SECOND]), [Context, :c] do |v|
+        # no reason for this to work - its verbose, just checking.
+        v[:c].inc :rule7
+      end
+      
+      rule OR(AND([Message, m.message == :FIRST], [Message, m.message == :SECOND])), [Context, :c] do |v|
+        v[:c].inc :rule8
+      end
+      
+      rule OR([Message, m.message == :FIRST]), [Context, :c] do |v|
+        v[:c].inc :rule9
+      end
+      
+      rule OR(AND([Message, m.message == :FIRST], [Message, m.message == :SECOND]), [Message, m.message == :FOOBAR]), [Context, :c] do |v|
+        v[:c].inc :rule10
+      end
+      
+      rule AND([Message, m.message == :FIRST], [Context, :c]) do |v|
+        # no reason for this to work - its verbose.  But it does work, so just checking.
+        v[:c].inc :rule11
+      end
+      
+      rule AND([Message, m.message == :FOOBAR], [Context, :c]) do |v|
+        # no reason for this to work - its verbose.  But it does work, so just checking.
+        v[:c].inc :rule12
+      end
+      
+      rule OR([Message, :f, m.message == :FOOBAR], [Message, :g, m.message == :SECOND]), [Context, :c] do |v|
+        if v[:f]
+          # :f should be null
+          v[:c].inc :rule13a          
+        end
+            
+        
+        if v[:g]
+          # :g should never be null
+          v[:c].inc :rule13b
+        end
+      end
+
+      rule OR([Message, :f, m.message == :FIRST], [Message, :s, m.message == :SECOND]), [Context, :c] do |v|
+        if v[:f]
+          v[:c].inc :rule14a          
+        end
+
+        if v[:s]
+          v[:c].inc :rule14b
+        end
+      end
+      
+      rule OR(AND([Message, m.message == :FIRST], [Message, m.message == :SECOND]), [Message, m.message == :FOOBAR], [Message, m.message == :THIRD]), [Context, :c] do |v|
+        v[:c].inc :rule16
+      end
+      
+      rule OR(AND(OR([Message, m.message == :FIRST], [Message, m.message == :SECOND]), [Message, m.message == :THIRD])), [Context, :c] do |v|
+        v[:c].inc :rule17
+      end
+      
+      rule OR(AND(OR(OR([Message, m.message == :FIRST])))), [Context, :c] do |v|
+        v[:c].inc :rule18
+      end
+      
+      rule OR(AND(OR(OR([Message, m.message == :FOOBAR])))), [Context, :c] do |v|
+        v[:c].inc :rule19
+      end
+      
+      rule OR([Message, m.message == :FIRST], [Message, m.message == :SECOND], [Message, m.message == :THIRD]), [Context, :c] do |v|
+        v[:c].inc :rule20
+      end
+    end
+  end
+    
+  class Test < Test::Unit::TestCase  
+    def test_0  
+      engine :engine do |e|
+        OrPatternsRulebook.new(e).rules
+        ctx = Context.new
+        e.assert ctx
+        e.assert Message.new(:FIRST, :FIRST)
+        e.assert Message.new(:FIRST, :SECOND)
+        e.assert Message.new(:FIRST, :THIRD)
+        e.match  
+        assert_equal 3, ctx.get(:rule20)        
+        assert_equal 0, ctx.get(:rule19)
+        assert_equal 1, ctx.get(:rule18)
+        assert_equal 2, ctx.get(:rule17)
+        assert_equal 2, ctx.get(:rule16)
+        assert_equal 1, ctx.get(:rule14b)
+        assert_equal 1, ctx.get(:rule14a)
+        assert_equal 1, ctx.get(:rule13b)
+        assert_equal 0, ctx.get(:rule13a)
+        assert_equal 0, ctx.get(:rule12)
+        assert_equal 1, ctx.get(:rule11)
+        assert_equal 1, ctx.get(:rule10)
+        assert_equal 1, ctx.get(:rule9)
+        assert_equal 1, ctx.get(:rule8)
+        assert_equal 0, ctx.get(:rule7)
+        assert_equal 1, ctx.get(:rule6)
+        assert_equal 1, ctx.get(:rule5)
+        assert_equal 0, ctx.get(:rule4)
+        assert_equal 2, ctx.get(:rule3)
+        assert_equal 1, ctx.get(:rule2)
+        assert_equal 2, ctx.get(:rule1) 
+      end
+    end
+  end
+end

data/tests/regex.rb

@@ -0,0 +1,47 @@
+# 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 'test/unit'
+require 'ruleby'
+
+include Ruleby
+
+MY_RE = /slot_(\d+)/
+
+module RE
+  
+  class RERulebook < Rulebook
+    def rules    
+      
+      rule [Message, :m, m.message =~ MY_RE], [Context, :c] do |v|
+        v[:c].inc :my_re
+      end   
+      
+    end
+  end
+  
+  class Test < Test::Unit::TestCase
+  
+    def test_0
+      ctx = Context.new
+      
+      engine :engine do |e|
+        RERulebook.new(e).rules
+        e.assert ctx
+        e.assert Message.new(:HELLO, 'slot_1')
+        e.assert Message.new(:HELLO, 'slot_x')
+        e.match  
+      end
+      
+      assert_equal 1, ctx.get(:my_re)
+    end
+  end
+end

data/tests/self_reference.rb

@@ -0,0 +1,54 @@
+# 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) 2008 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner, Matt Smith, John Mettraux
+#
+
+require 'test/unit'
+
+require 'ruleby'
+
+include Ruleby
+
+module SelfReference
+
+  class SelfRefRulebook < Rulebook
+    def rules
+      rule [Message, :m, {m.message => :x}, m.status == b(:x)],
+           [Context, :c] do |v|
+        v[:c].inc :rule2
+      end
+
+      # This is effectively the same as the rule above
+      rule [Message, :m, m.status == m.message],
+           [Context, :c] do |v|
+        v[:c].inc :rule3
+      end
+            
+    end
+  end
+  
+  
+  class Test < Test::Unit::TestCase
+  
+    def test_0
+  
+      engine :engine do |e|
+        SelfRefRulebook.new(e).rules
+        ctx = Context.new
+        e.assert ctx
+        e.assert Message.new(:HELLO, :HELLO)
+        e.assert Message.new(:HELLO, :GOODBYE)
+        e.match  
+        
+        assert_equal 1, ctx.get(:rule2)
+        assert_equal 1, ctx.get(:rule3)
+      end
+    end
+  end
+end

metadata

@@ -1,71 +1,103 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ruleby
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.9.b7
   prerelease: 4
-  version: 0.9.b4
 platform: ruby
-authors: 
-  - Joe Kutner
-  - Matt Smith
+authors:
+- Joe Kutner
+- Matt Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-27 00:00:00 -05:00
-default_executable: 
+date: 2011-11-16 00:00:00.000000000Z
 dependencies: []
-
-description: |
-  Ruleby is a rule engine written in the Ruby language. It is a system for executing a set 
-  of IF-THEN statements known as production rules. These rules are matched to objects using 
-  the forward chaining Rete algorithm. Ruleby provides an internal Domain Specific Language 
-  (DSL) for building the productions that make up a Ruleby program.
-
+description: ! "Ruleby is a rule engine written in the Ruby language. It is a system
+  for executing a set \nof IF-THEN statements known as production rules. These rules
+  are matched to objects using \nthe forward chaining Rete algorithm. Ruleby provides
+  an internal Domain Specific Language \n(DSL) for building the productions that make
+  up a Ruleby program.\n"
 email: jpkutner@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - lib/rule_helper.rb
-  - 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
-  - lib/dsl/ferrari.rb
-  - tests/test.rb
-has_rdoc: true
+files:
+- .gitignore
+- GPL.txt
+- LICENSE.txt
+- README.markdown
+- benchmarks/basic_rules.rb
+- benchmarks/joined_rules.rb
+- benchmarks/miss_manners/data.rb
+- benchmarks/miss_manners/miss_manners.rb
+- benchmarks/miss_manners/model.rb
+- benchmarks/miss_manners/rules.rb
+- benchmarks/model.rb
+- examples/diagnosis.rb
+- examples/fibonacci_example1.rb
+- examples/fibonacci_example2.rb
+- examples/fibonacci_example3.rb
+- examples/fibonacci_rulebook.rb
+- examples/hello.rb
+- examples/ticket.rb
+- examples/wordgame.rb
+- lib/core/atoms.rb
+- lib/core/engine.rb
+- lib/core/nodes.rb
+- lib/core/patterns.rb
+- lib/core/utils.rb
+- lib/dsl/ferrari.rb
+- lib/rule_helper.rb
+- lib/rulebook.rb
+- lib/ruleby.rb
+- ruleby.gemspec
+- spec/and_or_spec.rb
+- spec/coercion_spec.rb
+- spec/collect_spec.rb
+- spec/errors_spec.rb
+- spec/ferrari_spec.rb
+- spec/function_spec.rb
+- spec/hello_spec.rb
+- spec/node_sharing_spec.rb
+- spec/property_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/documentation.rake
+- tasks/rspec.rake
+- tasks/test.rake
+- tests/assert_facts.rb
+- tests/common.rb
+- tests/duck_type.rb
+- tests/gets.rb
+- tests/join_nodes.rb
+- tests/nil.rb
+- tests/not_patterns.rb
+- tests/or_patterns.rb
+- tests/regex.rb
+- tests/self_reference.rb
+- tests/test.rb
 homepage: http://ruleby.org
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.8.2
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">"
-      - !ruby/object:Gem::Version 
-        version: 1.3.1
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
 requirements: []
-
 rubyforge_project: ruleby
-rubygems_version: 1.5.1
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Rete based Ruby Rule Engine
-test_files: 
-  - tests/test.rb
+test_files: []