rulz 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e6ec3d9f0c732273a67886c4c81dc2c6dac0dbf2
+  data.tar.gz: f11c3808909d9eaa72bfaa51aaf55f94ba819896
+SHA512:
+  metadata.gz: b1bf5422a9b0552094b4504d9f8a5c3952702f30ddd31538059bf2588d909877becc6487e35cca2e74d379a52399ab93f768b273a0bcb8fe81084a04dabfcc8d
+  data.tar.gz: 5cc2faa66281dd963a983ab2fdf6625278d7a258ba8bb4aa0336971fd3f2ecc6614841a77ef5a5a9421d56f9ad4e39cb85596c1eda1395094248b10373f549dc

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+rulz

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p195

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rulz.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chase Conklin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,154 @@
+# Rulz
+
+Rulz is a rule engine for Ruby, allowing developers to define rules in their classes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rulz'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rulz
+
+## Usage
+
+In the model(s) which you want to apply rules to, include the rulz module (you may need to `require` it first):
+
+	include Rulz
+
+### Defining Rules
+
+#### Conditions and Actions
+
+	define_rulz do
+		condition "less than" do |other|
+			it < other
+		end
+		condition "contains" do	|other|
+			it.contains? other
+		end
+		action "assign to user" do |user|
+			its.user = user
+		end
+	end
+
+When defining conditions, it is possible to reference other condition:
+
+	condition "not equal to" do |other|
+		opposite_of "equal to", other
+	end
+	
+Actions can be combined in a similar way:
+
+	action "put on shoes" do
+		action "put on socks"
+		its.feet << "shoes"
+	end
+
+The following conditions come predefined with rulz:
+
+* less than
+* greater than
+* equal to
+* not equal to
+* contains
+* does not contain
+* matches
+* does not match
+* like
+* not like
+
+To load these conditions for the whole class `include` any of the following modules
+
+* Rulz::Conditions::Comparison
+* Rulz::Conditions::Container
+* Rulz::Conditions::String
+
+To load these conditions for a cetain attribute, call the `type` method inside the attribute block:
+
+	define_rulz do
+		attribute :foo do
+			type :integer
+		end
+	end
+	
+The following types are allowed:
+
+* integer
+* float
+* string
+* array
+* hash
+
+#### It
+
+"it" refers to the object that the conditions/rules are being applied to. For readability, "it" is aliased to "its"
+
+#### Rules
+
+	class Number < Fixnum
+		define_rulz	do
+			condition "even" do
+				it % 2 == 0
+			end
+			condition "odd" do
+				opposite_of "even"
+			end
+			action "make even" do
+				it += 1
+			end
+			rule do
+				where("odd") { apply! "make even" }
+			end
+		end
+	end
+
+Conditions can also be combined in `where` statements:
+
+	rule do
+		where(["odd", "AND", "prime"]) { apply! "make even" }
+	end
+
+Where statements can also accept the attribute method:
+
+	rule do
+		where :id => "odd" do
+			apply! "make even"
+		end
+	end
+	
+	rule do
+		where :id => ["multiple of", 5] do
+			apply! "make even"
+		end
+	end
+	
+When options need to be combined:
+
+	rule do
+		where [{:id => ["multiple of", 5]}, "AND", "odd"] do
+			apply! "make even"
+		end
+	end
+
+
+### Applying Rules
+
+To apply rules to a single object, call the `apply_rules!` method like so:
+
+	m = Melon.new
+	m.apply_rules!
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rulz.rb

@@ -0,0 +1,46 @@
+require "rulz/version"
+require "rulz/definer"
+require "rulz/condition"
+require "rulz/evaluator"
+require "rulz/action"
+require "rulz/rule"
+require "rulz/conditions/comparison"
+require "rulz/conditions/container"
+require "rulz/conditions/string"
+require "rulz/attribute"
+require "rulz/conditions/conditions"
+
+module Rulz
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+  
+  module InstanceMethods
+    def condition_true?(name, *args)
+      Rulz::Evaluator::Condition.new(self, name, *args).evaluate
+    end
+    
+    def condition_false?(name, *args)
+      not condition_true?(name, *args)
+    end
+    
+    def apply!(action, *args)
+      Rulz::Evaluator::Action.new(self, action, *args).evaluate
+    end
+    
+    def apply_rules!
+      Rulz::Rule.rules(self.class).each { |rule| rule.apply!(self) }
+    end
+    
+  end
+  
+  module ClassMethods
+  
+    def define_rulz(&block)
+      Rulz::Definer.new(self).instance_eval &block
+    end
+    
+  end
+end

data/lib/rulz/action.rb

@@ -0,0 +1,18 @@
+module Rulz
+  class Action
+    attr_accessor :name, :proc
+    
+    def initialize(name, klass, proc)
+      @name = name
+      @proc = proc
+      klass.instance_exec self do |action|
+        @rulz_actions ||= []
+        @rulz_actions << action
+      end
+    end
+    
+    def self.find(klass, name)
+      klass.instance_variable_get(:@rulz_actions).find {|c| c.name == name }
+    end
+  end
+end

data/lib/rulz/attribute.rb

@@ -0,0 +1,40 @@
+module Rulz
+  module Attribute
+    class Block
+      def initialize(attr, klass, &block)
+        @attr = attr
+        @klass = klass
+        instance_eval &block
+      end
+      
+      def condition(name, &block)
+        Rulz::Attribute::Condition.new(@klass, @attr, name, block)
+      end
+      
+      def type(kind)
+        Rulz::Conditions.load_conditions(@klass, @attr, kind)
+      end
+      
+    end
+    
+    class Condition
+      attr_reader :name, :proc
+      def initialize(klass, attr, name, proc)
+        @name = name
+        @proc = proc
+        klass.instance_exec self do |condition|
+          conditions = instance_variable_get("@rulz_#{attr}_conditions") || []
+          conditions << condition
+          instance_variable_set("@rulz_#{attr}_conditions", conditions) 
+        end        
+      end
+    
+      def self.find(klass, attr, name)
+        result = klass.instance_variable_get("@rulz_#{attr}_conditions").find {|c| c.name == name }
+        raise ArgumentError, "Condition '#{name}' for '#{attr}' does not exist" unless result
+        result
+      end
+      
+    end
+  end
+end

data/lib/rulz/condition.rb

@@ -0,0 +1,21 @@
+module Rulz
+  class Condition
+    attr_accessor :name, :proc
+    
+    def initialize(name, klass, proc)
+      @name = name
+      @proc = proc
+      klass.instance_exec self do |condition|
+        @rulz_conditions ||= []
+        @rulz_conditions << condition 
+      end
+    end
+    
+    def self.find(klass, name)
+      result = klass.instance_eval { @rulz_conditions }.find {|c| c.name == name }
+      raise ArgumentError, "Condition '#{name}' does not exist" unless result
+      result
+    end
+    
+  end
+end

data/lib/rulz/conditions/comparison.rb

@@ -0,0 +1,52 @@
+module Rulz
+  module Conditions    
+    module Comparison
+      
+      def self.load_conditions(reciever, attr)
+        reciever.class_eval do
+          define_rulz do
+            attribute attr do
+              condition "greater than" do |other|
+                send(attr) > other
+              end
+        
+              condition "less than" do |other|
+                send(attr) < other
+              end
+        
+              condition "equal to" do |other|
+                send(attr) == other
+              end
+        
+              condition "not equal to" do |other|
+                opposite_of "equal to", other
+              end              
+            end
+          end
+        end
+      end
+      
+      def self.included(base)
+        base.class_eval do
+          define_rulz do        
+            condition "greater than" do |other|
+              it > other
+            end
+        
+            condition "less than" do |other|
+              it < other
+            end
+        
+            condition "equal to" do |other|
+              it == other
+            end
+        
+            condition "not equal to" do |other|
+              opposite_of "equal to", other
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rulz/conditions/conditions.rb

@@ -0,0 +1,19 @@
+module Rulz
+  module Conditions
+    def self.load_conditions(reciever, attribute, kind)
+      case kind
+      when :integer
+        Comparison.load_conditions(reciever, attribute)
+      when :float
+        Comparison.load_conditions(reciever, attribute)
+      when :string
+        Container.load_conditions(reciever, attribute)
+        String.load_conditions(reciever, attribute)
+      when :array
+        Container.load_conditions(reciever, attribute)
+      when :hash
+        Container.load_conditions(reciever, attribute)
+      end
+    end
+  end
+end

data/lib/rulz/conditions/container.rb

@@ -0,0 +1,35 @@
+module Rulz
+  module Conditions
+    module Container
+      
+      def self.load_conditions(reciever, attr)
+        reciever.class_eval do
+          define_rulz do
+            attribute attr do
+              condition "contains" do |other|
+                send(attr).include? other
+              end
+              condition "does not contain" do |other|
+                opposite_of "contains", other
+              end
+            end
+          end
+        end
+      end
+      
+      
+      def self.included(base)
+        base.class_eval do
+          define_rulz do
+            condition "contains" do |other|
+              it.include? other
+            end
+            condition "does not contain" do |other|
+              opposite_of "contains", other
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rulz/conditions/string.rb

@@ -0,0 +1,47 @@
+module Rulz
+  module Conditions
+    module String
+      
+      def self.load_conditions(reciever, attr)
+        reciever.class_eval do
+          define_rulz do
+            attribute attr do
+              condition "does not match" do |regex|
+                send(attr).scan(regex).empty?
+              end
+              condition "matches" do |regex|
+                opposite_of "does not match", regex
+              end
+              condition "like" do |other|
+                send(attr).downcase == other.downcase
+              end
+              condition "not like" do |other|
+                opposite_of "like", other
+              end
+            end
+          end
+        end
+      end
+      
+      def self.included(base)
+        base.class_eval do
+          include Rulz::Conditions::Container
+          define_rulz do
+            condition "does not match" do |regex|
+              it.scan(regex).empty?
+            end
+            condition "matches" do |regex|
+              opposite_of "does not match", regex
+            end
+            condition "like" do |other|
+              it.downcase == other.downcase
+            end
+            condition "not like" do |other|
+              opposite_of "like", other
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rulz/definer.rb

@@ -0,0 +1,24 @@
+module Rulz
+  class Definer
+    
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def condition(name, &block)
+      Rulz::Condition.new(name, @klass, block)
+    end
+    
+    def action(name, &block)
+      Rulz::Action.new(name, @klass, block)
+    end
+    
+    def rule(&block)
+      Rulz::Rule.new(@klass, block)
+    end
+    
+    def attribute(attr, &block)
+      Rulz::Attribute::Block.new(attr, @klass, &block)
+    end
+  end  
+end 

data/lib/rulz/evaluator.rb

@@ -0,0 +1,123 @@
+module Rulz
+  module Evaluator
+    
+    class Base
+      
+      def initialize(receiver, *args)
+        @receiver = receiver
+        @args = args || []
+      end
+            
+      def it
+        @receiver
+      end
+      
+      alias :its :it
+    end
+    
+    class Condition < Evaluator::Base
+      def initialize(receiver, name, *args)
+        @condition = Rulz::Condition.find(receiver.class, name)
+        super(receiver, *args)
+      end
+      
+      
+      def condition(name, *args)
+        Rulz::Evaluator::Condition.new(@receiver, name, *args).evaluate
+      end
+      
+      def opposite_of(name, *args)
+        not condition(name, *args)
+      end
+      
+      def evaluate
+        instance_exec(*@args, &@condition.proc)
+      end
+      
+        
+    end
+    
+    class AttributeCondition < Evaluator::Base
+      def initialize(receiver, attribute, name, *args)
+        @condition = Rulz::Attribute::Condition.find(receiver.class, attribute, name)
+        super(receiver, *args)
+        define_singleton_method attribute do
+          @receiver.send(attribute)
+        end
+      end
+      
+      def evaluate
+        instance_exec(*@args, &@condition.proc)
+      end
+      
+    end
+    
+    class Action < Evaluator::Base
+      def initialize(receiver, name, *args)
+        @action = Rulz::Action.find(receiver.class, name)
+        super(receiver, *args)
+      end
+      
+      def evaluate
+        instance_exec(*@args, &@action.proc)
+      end
+      
+      def action(name, *args)
+        Rulz::Evaluator::Action.new(@receiver, name, *args).evaluate
+      end
+      
+      
+    end
+    
+    class Rule < Evaluator::Base
+      def initialize(receiver, proc)
+        @receiver = receiver
+        @proc = proc
+      end
+      
+      def evaluate
+        instance_eval(&@proc)
+      end
+      
+      def where(condition, *args, &block)
+        if condition.is_a? String
+          @receiver.instance_eval(&block) if Rulz::Evaluator::Condition.new(@receiver, condition, *args).evaluate
+        elsif condition.is_a? Proc
+          @receiver.instance_eval(&block) if condition.call(*args)
+        elsif condition.is_a? Array
+          raise ArgumentError, "Invalid condition" unless condition.include? "AND" or condition.include? "OR"
+          split_condition = condition.inject([[]]) do |results, element|
+            if ["AND", "OR"].include? element
+              results << {"AND" => "&&", "OR" => "||"}[element]
+              results << []
+            elsif element.is_a?(Hash)
+              results.pop if results.last.respond_to?(:empty?) && results.last.empty? 
+              results << element
+            else
+              results.last << element
+            end
+            results
+          end
+          split_condition.map! do |element|
+            if element.is_a?(Array)
+              Rulz::Evaluator::Condition.new(@receiver, *element).evaluate
+            elsif element.is_a?(Hash)
+              attribute, element = *element.first
+              Rulz::Evaluator::AttributeCondition.new(@receiver, attribute, *element).evaluate
+            else
+              element
+            end
+          end
+          @receiver.instance_eval(&block) if eval(split_condition.join(" "))
+        elsif condition.is_a? Hash
+          attribute, condition = *condition.first
+          @receiver.instance_eval(&block) if Rulz::Evaluator::AttributeCondition.new(@receiver, attribute, *condition).evaluate
+        else
+          raise ArgumentError, "Invalid condition"
+        end
+      end            
+    end
+    
+  end  
+end
+

data/lib/rulz/rule.rb

@@ -0,0 +1,21 @@
+module Rulz
+  class Rule
+    attr_accessor :proc
+    
+    def initialize(klass, proc)
+      @proc = proc
+      klass.instance_exec self do |rule| 
+        @rulz_rules ||= []
+        @rulz_rules << rule
+      end
+    end
+    
+    def apply!(receiver)
+      Rulz::Evaluator::Rule.new(receiver, @proc).evaluate
+    end
+    
+    def self.rules(klass)
+      klass.instance_eval { @rulz_rules }
+    end
+  end
+end

data/lib/rulz/version.rb

@@ -0,0 +1,3 @@
+module Rulz
+  VERSION = "1.0.0"
+end

data/rulz.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rulz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rulz"
+  spec.version       = Rulz::VERSION
+  spec.authors       = ["Chase Conklin"]
+  spec.email         = ["chase@conklins.net"]
+  spec.description   = %q{Rule Engine for Ruby}
+  spec.summary       = %q{Enables users to create mail-like rules for processing Ruby objects.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "debugger"
+  
+end

data/spec/action_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe "action" do
+  before :all do
+    
+    class Person
+      attr_accessor :name
+      include Rulz
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      define_rulz do
+        action "add prefix" do |prefix|
+          its.name = "#{prefix} #{its.name}"
+        end
+        
+        action "make doctor" do
+          action "add prefix", "Dr."
+        end
+      end
+    end
+    
+  end
+  
+  it "should act" do
+    bobby = Person.new("Bobby")
+    bobby.apply! "add prefix", "Mr."
+    bobby.name.should == "Mr. Bobby"
+  end
+  
+  it "should be definable with other actions" do
+    bobby = Person.new("Bobby")
+    bobby.apply! "make doctor"
+    bobby.name.should == "Dr. Bobby"    
+  end
+end

data/spec/condition_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe "condition" do
+  context "application" do
+    before :all do
+      class Person
+        include Rulz
+        attr_accessor :name, :age
+      
+        def initialize(name, age)
+          @name = name
+          @age = age
+        end
+      
+        define_rulz do
+          condition "older than" do |age|
+            its.age > age
+          end
+        
+          condition "younger than" do |age|
+            opposite_of "older than", age
+          end
+        
+          condition "middle aged" do
+            condition("older than", 40) and condition("younger than", 50)
+          end
+        
+        end      
+      end
+    end
+  
+    it "recognizes when conditions are true" do
+      billy = Person.new("Billy", 54)
+      billy.condition_true?("older than", 50).should be_true
+      bobby = Person.new("Bobby", 23)
+      bobby.condition_true?("older than", 50).should be_false
+    end
+  
+    it "recognizes when conditions are false" do
+      bilbo = Person.new("Bilbo", 46)
+      bilbo.condition_false?("older than", 23).should be_false
+      baggins = Person.new("Baggins", 12)
+      baggins.condition_false?("older than", 23).should be_true    
+    end
+  
+    it "can define conditions based on other conditions" do
+      bobby = Person.new("Bobby", 11)
+      bobby.condition_true?("younger than", 13).should be_true
+      billy = Person.new("Billy", 45)
+      billy.condition_true?("middle aged").should be_true
+    end
+  end
+  
+  context "come predefined in modules" do
+    before :all do
+      class String
+        include Rulz
+        include Rulz::Conditions::String
+        include Rulz::Conditions::Comparison
+      end
+    end
+    
+    it "should recognize contains" do
+      "foobar".condition_true?("contains", "bar").should be_true
+      "foobar".condition_true?("contains", "baz").should be_false     
+    end
+    
+    it "should recognize matches" do
+      "123".condition_true?("matches", /[0-4][0-4][0-4]/).should be_true
+      "baz".condition_true?("matches",  /[0-4][0-4][0-4]/).should be_false
+    end
+    
+    it "should recognize does not match" do
+      "baz".condition_true?("does not match",  /[0-4][0-4][0-4]/).should be_true 
+      "123".condition_true?("does not match", /[0-4][0-4][0-4]/).should be_false           
+    end
+    
+    it "should recognize like" do
+      "abc".condition_true?("like", "ABC").should be_true
+      "123".condition_true?("like", "ABC").should be_false     
+    end
+    
+    it "should recognize not like" do
+      "123".condition_true?("not like", "ABC").should be_true      
+      "abc".condition_true?("not like", "ABC").should be_false
+    end
+        
+    it "should recognize equal to" do
+      "abc".condition_true?("equal to", "abc").should be_true
+      "ABC".condition_true?("equal to", "abc").should be_false
+    end
+    
+    it "should recognize not equal to" do
+      "ABC".condition_true?("not equal to", "abc").should be_true
+      "abc".condition_true?("not equal to", "abc").should be_false
+    end
+    
+    it "should recognize greater than" do
+      "b".condition_true?("greater than", "a").should be_true
+      "a".condition_true?("greater than", "b").should be_false
+    end
+
+    it "should recognize less than" do
+      "a".condition_true?("less than", "b").should be_true
+      "b".condition_true?("less than", "a").should be_false
+    end
+  
+  end  
+  
+end

data/spec/rule_spec.rb

@@ -0,0 +1,270 @@
+require "spec_helper"
+
+describe "rules" do
+  context "functionality" do
+    before :all do
+      class Person
+        attr_accessor :name, :age, :job
+        include Rulz
+      
+        def initialize(name, age, job = nil)
+          @name = name
+          @age = age
+          @job = job
+        end
+      
+        define_rulz do
+          condition "older than" do |age|
+            its.age > age
+          end
+          condition "younger than" do |age|
+            opposite_of "older than", age
+          end
+          condition "old" do
+            condition "older than", 50
+          end
+          condition "elderly" do
+            condition "older than", 80
+          end
+          condition "name is" do |name|
+            its.name == name
+          end
+          condition "job is" do |job|
+            its.job == job
+          end
+          action "add prefix" do |prefix|
+            its.name = "#{prefix} #{its.name}"
+          end
+          action "add suffix" do |suffix|
+            its.name += " #{suffix}"
+          end
+          action "add job prefix" do |prefix|
+            its.job = "#{prefix} #{its.job}"
+          end
+          rule do
+            where("old") { apply! "add prefix", "Grandpa" }
+          end
+          rule do
+            where("elderly") { apply! "add suffix", "Sr."}
+          end
+          rule do
+            where("younger than", 20) { apply! "add suffix", "Jr."}
+          end
+          rule do
+            where(["name is", "Prometheous", "OR", "name is", "Wisdom"]) { apply! "add suffix", "the wise" }
+          end
+          rule do
+            where(["job is", "Contractor", "AND", "younger than", 40]) { apply! "add job prefix", "Jr."}
+          end
+          rule do
+            where ["job is", "Electrician", "OR", "name is", "Bobby", "AND", "job is", "Contractor"] do
+              apply! "add prefix", "The skilled"
+            end
+          end
+        end      
+      end
+    end
+  
+    it "should apply when the condition is true" do
+      bobby = Person.new("Bobby", 52)
+      bobby.apply_rules!
+      bobby.name.should == "Grandpa Bobby"
+    end
+  
+    it "should not apply when the condition is false" do
+      bobby = Person.new("Bobby", 32)
+      bobby.apply_rules!
+      bobby.name.should == "Bobby"
+    end
+  
+    it "should accept conditions with arguments" do
+      bobby = Person.new("Bobby", 17)
+      bobby.apply_rules!
+      bobby.name.should == "Bobby Jr."
+    end
+  
+    it "should be combined to produce a combined effect" do
+      bobby = Person.new("Bobby", 87)
+      bobby.apply_rules!
+      bobby.name.should == "Grandpa Bobby Sr."
+    end
+    
+    it "accepts 'OR' syntax" do
+      wisdom = Person.new("Wisdom", 32)
+      wisdom.apply_rules!
+      wisdom.name.should == "Wisdom the wise"
+      prometheous = Person.new("Prometheous", 32)
+      prometheous.apply_rules!
+      prometheous.name.should == "Prometheous the wise"
+    end
+  
+    it "accepts 'AND' syntax" do
+      worker = Person.new("Worker", 32, "Contractor")
+      worker.apply_rules!
+      worker.job.should == "Jr. Contractor"
+    
+      worker = Person.new("Worker", 32, "Builder")
+      worker.apply_rules!
+      worker.job.should == "Builder"    
+    end
+  
+    it "accepts both 'AND' and 'OR' syntax together" do
+      electrician = Person.new("Electrician", 32, "Electrician")
+      electrician.apply_rules!
+      electrician.name.should == "The skilled Electrician"
+    end
+  end
+  
+  context "errors" do
+    before :all do
+      class Cactus
+        include Rulz
+        attr_accessor :name, :age
+      
+        def initialize(name, age)
+          @name = name
+          @age = age
+        end
+      
+        define_rulz do
+          condition "older than" do |age|
+            its.age > age
+          end
+        
+          condition "younger than" do |age|
+            opposite_of "older than", age
+          end
+        
+          condition "middle aged" do
+            condition("older than", 40) and condition("younger than", 50)
+          end
+             
+          rule do
+            where("old") { apply! "add prefix", "Grandpa" } # "old" does not exist
+          end
+          
+        end      
+      end
+    end
+    
+    it "should be raised if a condition is not found" do
+      bobby = Cactus.new("Bobby", 42)
+      expect { bobby.apply_rules! }.to raise_error ArgumentError
+    end
+    
+  end
+  
+  context "attributes" do
+    before :all do
+      class Watermelon
+        include Rulz
+        attr_accessor :length, :weight, :width
+      
+        def initialize(length, weight, width=0)
+          @length = length
+          @weight = weight
+          @width = width
+        end
+      
+        define_rulz do
+          attribute :length do
+            condition "greater than" do |other_length|
+              length > other_length
+            end
+            condition "less than" do |other_length|
+              length < other_length
+            end
+          end
+          attribute :weight do
+            condition "greater than" do |other_weight|
+              weight > other_weight
+            end
+          end
+          condition "lopsided" do
+            its.width > its.length
+          end
+          action "cut in half" do
+            its.length /= 2
+          end
+          action "scoop out inside" do
+            action "cut in half"
+            its.weight /= 3
+          end
+          action "rotate" do
+            its.length, its.width = its.width, its.length
+          end
+          rule do
+            where :length => [ "greater than", 12 ] do
+              apply! "cut in half"
+            end
+          end
+          rule do
+            where [{:length => [ "less than", 6]}, "AND", {:weight => ["greater than", 15]}] do
+              apply! "scoop out inside"
+            end
+          end
+          rule do
+            where [{:length => ["less than", 6]}, "AND", "lopsided"] do
+              apply! "rotate"
+            end
+          end
+        end
+      end      
+    end
+    
+    it "should recognize attribute conditions" do
+      w = Watermelon.new(13, 11)
+      w.apply_rules!
+      w.length.should == 6
+      m = Watermelon.new(11, 11)
+      m.apply_rules!
+      m.length.should == 11
+    end
+
+    it "should allow attribute conditions to be combined" do
+      w = Watermelon.new(4, 18)
+      w.apply_rules!
+      w.length.should == 2
+      w.weight.should == 6
+    end
+
+    it "should allow attribute conditions to be combined with normal conditions" do
+      w = Watermelon.new(4, 4, 6)
+      w.apply_rules!
+      w.length.should == 6
+      w.width.should == 4     
+    end
+    
+  end
+  
+  context "using predefined conditions" do
+    class Honeydew
+      include Rulz
+      attr_accessor :diameter
+      
+      define_rulz do
+        attribute :diameter do
+          type :integer
+        end
+        action "cut in half" do
+          its.diameter /= 2
+        end
+        rule do
+          where(diameter: ["greater than", 5]) { apply! "cut in half" }
+        end
+      end
+      
+      def initialize(diameter)
+        @diameter = diameter
+      end
+    end
+    
+    it "should not require conidions to be defined" do
+      h = Honeydew.new(6)
+      h.apply_rules!
+      h.diameter.should == 3
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "rulz"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: rulz
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Chase Conklin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rule Engine for Ruby
+email:
+- chase@conklins.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rulz.rb
+- lib/rulz/action.rb
+- lib/rulz/attribute.rb
+- lib/rulz/condition.rb
+- lib/rulz/conditions/comparison.rb
+- lib/rulz/conditions/conditions.rb
+- lib/rulz/conditions/container.rb
+- lib/rulz/conditions/string.rb
+- lib/rulz/definer.rb
+- lib/rulz/evaluator.rb
+- lib/rulz/rule.rb
+- lib/rulz/version.rb
+- rulz.gemspec
+- spec/action_spec.rb
+- spec/condition_spec.rb
+- spec/rule_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Enables users to create mail-like rules for processing Ruby objects.
+test_files:
+- spec/action_spec.rb
+- spec/condition_spec.rb
+- spec/rule_spec.rb
+- spec/spec_helper.rb