rules 0.0.1 → 0.1.0

data/spec/rules/evaluators/evaluator_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Rules::Evaluators::Evaluator do
+  describe '#evaluate' do
+    let(:evaluator) { Rules::Evaluators::Evaluator.new(:test) }
+    let(:lhv) { 'lhv' }
+    let(:rhv) { 'rhv' }
+
+    it 'raises an error if a block is not defined' do
+      expect {
+        evaluator.evaluate(lhv, rhv)
+      }.to raise_error 'Unknown evaluation method'
+    end
+
+    it 'calls the block for the evaluator with the specified' do
+      evaluator.evaluation_method = ->(lhv, rhv) { true }
+      evaluator.evaluation_method.should_receive(:call).with(lhv, rhv)
+      evaluator.evaluate(lhv, rhv)
+    end
+
+    context 'when an error is raised within the evaluator' do
+      before { evaluator.evaluation_method = ->(lhv, rhv) { raise 'oh noes' } }
+
+      it 'returns false by default' do
+        evaluator.evaluate(lhv, rhv).should be_false
+      end
+
+      it 'raises the error if the errors_are_false config option is false' do
+        Rules.config.stub(errors_are_false?: false)
+        expect {
+          evaluator.evaluate(lhv, rhv)
+        }.to raise_error 'oh noes'
+      end
+    end
+  end
+end

data/spec/rules/parameters/attribute_spec.rb

@@ -7,6 +7,26 @@ describe Rules::Parameters::Attribute do
     end
   end
 
+  let(:attribute) { Rules::Parameters::Attribute.new(key: 'test_key') }
+
   describe '#evaluate' do
+
+    it 'retrieves the attribute value from the given hash' do
+      attribute.evaluate(key_1: 1, key_2: 'john', test_key: 'carol').should == 'carol'
+    end
+
+    context 'when the attribute is missing' do
+      it 'returns nil by default' do
+        attribute.evaluate(key_1: 1, key_2: 'john').should be_nil
+      end
+
+      it 'raises an error if set in the configuration settings' do
+        Rules.config.stub(missing_attributes_are_nil?: false)
+
+        expect {
+          attribute.evaluate(key_1: 1, key_2: 'john')
+        }.to raise_error KeyError
+      end
+    end
   end
 end

data/spec/rules/rule_set_spec.rb

@@ -7,32 +7,42 @@ describe Rules::RuleSet do
   before { stub_const('FakeClass', Class.new) }
 
   describe '.set_attributes_for' do
-    it 'returns nil if there are no attributes for the given class' do
-      Rules::RuleSet.attributes[FakeClass].should be_nil
+    it 'returns an empty hash if there are no attributes for the given class' do
+      Rules::RuleSet.attributes[FakeClass].should == {}
     end
 
     it 'stores the list of attributes for the specified class' do
       Rules::RuleSet.set_attributes_for(FakeClass, attributes)
       Rules::RuleSet.attributes[FakeClass].should have(2).attributes
     end
+
+    it 'appends new attributes when called multiple times' do
+      Rules::RuleSet.set_attributes_for(FakeClass, attributes)
+      Rules::RuleSet.set_attributes_for(FakeClass, {attribute3: {name: 'name of attribute 3'}})
+      Rules::RuleSet.attributes[FakeClass].should have(3).attributes
+    end
   end
 
   describe '#evaluate' do
-    let(:true_rule1) { Rules::Rule.new(lhs_parameter: 'today', evaluator: 'not_nil') }
-    let(:true_rule2) { Rules::Rule.new(lhs_parameter: nil, evaluator: 'nil') }
-    let(:false_rule1) { Rules::Rule.new(lhs_parameter: 'today', evaluator: 'nil') }
-    let(:false_rule2) { Rules::Rule.new(lhs_parameter: nil, evaluator: 'not_nil') }
+    let(:true_rule1) { Rules::Rule.new(lhs_parameter_key: 'today', evaluator_key: 'not_nil') }
+    let(:true_rule2) { Rules::Rule.new(lhs_parameter_key: nil, evaluator_key: 'nil') }
+    let(:false_rule1) { Rules::Rule.new(lhs_parameter_key: 'today', evaluator_key: 'nil') }
+    let(:false_rule2) { Rules::Rule.new(lhs_parameter_key: nil, evaluator_key: 'not_nil') }
+
+    it 'returns true if there are no rules' do
+      rule_set.evaluate.should be_true
+    end
 
     context 'when evaluation logic is all' do
       before { rule_set.evaluation_logic = 'all' }
 
       it 'returns true if all rules are true' do
-        rule_set.rules << [true_rule1, true_rule2]
+        rule_set.rules += [true_rule1, true_rule2]
         rule_set.evaluate.should be_true
       end
 
       it 'returns false if any rules are false' do
-        rule_set.rules << [true_rule1, false_rule1]
+        rule_set.rules += [true_rule1, false_rule1]
         rule_set.evaluate.should be_false
       end
     end
@@ -41,17 +51,17 @@ describe Rules::RuleSet do
       before { rule_set.evaluation_logic = 'any' }
 
       it 'returns true if all rules are true' do
-        rule_set.rules << [true_rule1, true_rule2]
+        rule_set.rules += [true_rule1, true_rule2]
         rule_set.evaluate.should be_true
       end
 
       it 'returns true if a single rule is true' do
-        rule_set.rules << [false_rule1, true_rule1]
+        rule_set.rules += [false_rule1, true_rule1]
         rule_set.evaluate.should be_true
       end
 
       it 'returns false if all rules are false' do
-        rule_set.rules << [false_rule1, false_rule2]
+        rule_set.rules += [false_rule1, false_rule2]
         rule_set.evaluate.should be_false
       end
     end

data/spec/rules/rule_spec.rb

@@ -2,81 +2,97 @@ require 'spec_helper'
 
 describe Rules::Rule do
   let(:rule_set) { Rules::RuleSet.new }
-  let(:evaluator) { 'equals' }
+  let(:evaluator_key) { 'equals' }
   let(:lhs) { 'today' }
-  let(:rhs) { Date.today.to_s }
+  let(:rhs_key) { 'today' }
+  let(:rhs_raw) { Date.today.to_s }
 
   describe 'validations' do
     it 'requires a valid evaluator' do
-      rule = Rules::Rule.new(evaluator: 'fake', lhs_parameter: nil, rhs_parameter: nil)
+      rule = Rules::Rule.new(evaluator_key: 'fake')
       rule.should_not be_valid
-      rule.errors[:evaluator].should include("is not included in the list")
+      rule.errors[:evaluator_key].should include("is not included in the list")
     end
 
     it 'requires a lhs parameter' do
-      rule = Rules::Rule.new(evaluator: evaluator, lhs_parameter: nil, rhs_parameter: nil)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key)
       rule.should_not be_valid
-      rule.errors[:lhs_parameter].should include("is not included in the list")
+      rule.errors[:lhs_parameter_key].should include("is not a valid parameter")
     end
 
     it 'requires a valid lhs parameter' do
-      rule = Rules::Rule.new(evaluator: evaluator, lhs_parameter: 'fake', rhs_parameter: nil)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: 'fake')
       rule.should_not be_valid
-      rule.errors[:lhs_parameter].should include("is not included in the list")
+      rule.errors[:lhs_parameter_key].should include("is not a valid parameter")
     end
 
     it 'requires a rhs parameter if the evaluator requires one' do
-      rule = Rules::Rule.new(evaluator: evaluator, lhs_parameter: lhs, rhs_parameter: nil)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: lhs)
       rule.should_not be_valid
-      rule.errors[:rhs_parameter].should include("can't be blank")
+      rule.errors[:rhs_parameter_key].should include("can't be blank")
     end
 
-    it 'require a blank rhs parameter if the evaluator does not require one' do
-      rule = Rules::Rule.new(evaluator: 'nil', lhs_parameter: lhs, rhs_parameter: rhs)
+    it 'requires a blank rhs parameter if the evaluator does not require one' do
+      rule = Rules::Rule.new(evaluator_key: 'nil', lhs_parameter_key: lhs, rhs_parameter_raw: rhs_raw)
       rule.should_not be_valid
-      rule.errors[:rhs_parameter].should include("must be blank for this evaluation method")
+      rule.errors[:rhs_parameter_raw].should include("must be blank")
+    end
+
+    it 'requires a valid rhs parameter key if provided' do
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: lhs, rhs_parameter_key: 'fake')
+      rule.should_not be_valid
+      rule.errors[:rhs_parameter_key].should include("is not a valid parameter")
+    end
+
+    it 'requires that only one of the rhs parameter key or raw value are set' do
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: lhs, rhs_parameter_key: rhs_key, rhs_parameter_raw: rhs_raw)
+      rule.should_not be_valid
+      rule.errors[:rhs_parameter_key].should include("must be blank")
     end
 
     it 'allows a lhs parameter with a valid constant key' do
-      rule = Rules::Rule.new(evaluator: 'nil', lhs_parameter: 'today')
+      rule = Rules::Rule.new(evaluator_key: 'nil', lhs_parameter_key: 'today')
       rule.should be_valid
     end
 
     it 'allows a lhs parameter with a valid attribute key' do
       rule_set.stub(attributes: {current_user: 'The current user'})
-      rule = Rules::Rule.new(rule_set: rule_set, evaluator: 'nil', lhs_parameter: 'current_user')
+      rule = Rules::Rule.new(rule_set: rule_set, evaluator_key: 'nil', lhs_parameter_key: 'current_user')
       rule.should be_valid
     end
 
     it 'is valid for well defined rules' do
-      rule = Rules::Rule.new(evaluator: evaluator, lhs_parameter: lhs, rhs_parameter: rhs)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: lhs, rhs_parameter_raw: rhs_raw)
       rule.should be_valid
 
-      rule = Rules::Rule.new(evaluator: 'nil', lhs_parameter: lhs, rhs_parameter: nil)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key, lhs_parameter_key: lhs, rhs_parameter_key: rhs_key)
+      rule.should be_valid
+
+      rule = Rules::Rule.new(evaluator_key: 'nil', lhs_parameter_key: lhs)
       rule.should be_valid
     end
   end
 
-  describe '#get_evaluator' do
+  describe '#evaluator' do
     it 'returns nil if an evaluator does not exist for a key' do
-      rule = Rules::Rule.new(evaluator: 'fake')
-      rule.get_evaluator.should be_nil
+      rule = Rules::Rule.new(evaluator_key: 'fake')
+      rule.evaluator.should be_nil
     end
 
     it 'returns the evaluator if an evaluator with the key exists' do
-      rule = Rules::Rule.new(evaluator: evaluator)
-      rule.get_evaluator.should be_kind_of(Rules::Evaluators::Evaluator)
+      rule = Rules::Rule.new(evaluator_key: evaluator_key)
+      rule.evaluator.should be_kind_of(Rules::Evaluators::Evaluator)
     end
   end
 
   describe '#lhs_parameter_value' do
     it 'returns nil if the parameter key does not have a corresponding attribute' do
-      rule = Rules::Rule.new(lhs_parameter: 'fake')
+      rule = Rules::Rule.new(lhs_parameter_key: 'fake')
       rule.lhs_parameter_value.should be_nil
     end
 
     it 'returns the evaluated attribute for a constant key' do
-      rule = Rules::Rule.new(lhs_parameter: 'today')
+      rule = Rules::Rule.new(lhs_parameter_key: 'today')
       rule.lhs_parameter_value.should == Time.now.utc.to_date
     end
 
@@ -85,86 +101,143 @@ describe Rules::Rule do
       current_user_attribute = Rules::Parameters::Attribute.new(key: :current_user, name: 'the current user')
       rule_set.stub(attributes: {current_user: current_user_attribute})
 
-      rule = Rules::Rule.new(rule_set: rule_set, lhs_parameter: 'current_user')
+      rule = Rules::Rule.new(rule_set: rule_set, lhs_parameter_key: 'current_user')
 
       rule.lhs_parameter_value({
         current_user: current_user,
         current_price: 10
       }).should == current_user
     end
-
-    it 'raises an error if the necessary attributes are not provided for an attribute' do
-      current_user_attribute = Rules::Parameters::Attribute.new(key: :current_user, name: 'the current user')
-      rule_set.stub(attributes: {current_user: current_user_attribute})
-
-      rule = Rules::Rule.new(rule_set: rule_set, lhs_parameter: 'current_user')
-
-      expect {
-        rule.lhs_parameter_value(current_price: 10)
-      }.to raise_error KeyError
-    end
   end
 
   describe '#rhs_parameter_value' do
-    it 'returns the original value of the lhs parameter does not require a cast' do
-      rule = Rules::Rule.new(rhs_parameter: 'some string')
-      rule.rhs_parameter_value.should == 'some string'
-    end
-
-    it 'raises an error for rhs parameters that can not be cast' do
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: 'four score and seven years ago')
-      expect {
-        rule.rhs_parameter_value
-      }.to raise_error
+    context 'with a raw value' do
+      it 'returns the original value of the lhs parameter does not require a cast' do
+        rule = Rules::Rule.new(rhs_parameter_raw: 'some string')
+        rule.rhs_parameter_value.should == 'some string'
+      end
+
+      it 'raises an error for rhs parameters that can not be cast' do
+        rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: 'four score and seven years ago')
+        expect {
+          rule.rhs_parameter_value
+        }.to raise_error
+      end
+
+      it 'casts the rhs parameter into the format required by the lhs parameter' do
+        rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: '2012-01-01')
+        rule.rhs_parameter_value.should == Date.parse('2012-01-01')
+      end
+
+      it 'casts the rhs parameter into the format required by the evaluator' do
+        rule = Rules::Rule.new(evaluator_key: 'matches', rhs_parameter_raw: 'test$')
+        rule.rhs_parameter_value.should == Regexp.new('test$')
+      end
     end
 
-    it 'casts the rhs parameter into the format required by the lhs parameter' do
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: '2012-01-01')
-      rule.rhs_parameter_value.should == Date.parse('2012-01-01')
+    context 'with a parameter key' do
+      it 'returns nil if the parameter key does not have a corresponding attribute' do
+        rule = Rules::Rule.new(rhs_parameter_key: 'fake')
+        rule.rhs_parameter_value.should be_nil
+      end
+
+      it 'returns the evaluated attribute for a constant key' do
+        rule = Rules::Rule.new(rhs_parameter_key: 'today')
+        rule.rhs_parameter_value.should == Time.now.utc.to_date
+      end
+
+      it 'returns the right value for an attribute' do
+        current_user = mock('current user')
+        current_user_attribute = Rules::Parameters::Attribute.new(key: :current_user, name: 'the current user')
+        rule_set.stub(attributes: {current_user: current_user_attribute})
+
+        rule = Rules::Rule.new(rule_set: rule_set, rhs_parameter_key: 'current_user')
+
+        rule.rhs_parameter_value({
+          current_user: current_user,
+          current_price: 10
+        }).should == current_user
+      end
     end
   end
 
-  describe '#lhs_parameter_object' do
+  describe '#lhs_parameter' do
     it 'returns nil if the parameter key does not have a corresponding attribute' do
-      rule = Rules::Rule.new(lhs_parameter: 'fake')
-      rule.lhs_parameter_object.should be_nil
+      rule = Rules::Rule.new(lhs_parameter_key: 'fake')
+      rule.lhs_parameter.should be_nil
     end
 
     it 'returns the constant for the parameter key if defined' do
-      rule = Rules::Rule.new(lhs_parameter: lhs)
-      rule.lhs_parameter_object.should be_kind_of(Rules::Parameters::Constant)
+      rule = Rules::Rule.new(lhs_parameter_key: lhs)
+      rule.lhs_parameter.should be_kind_of(Rules::Parameters::Constant)
     end
 
     it 'returns the attribute for the parameter key if defined' do
       rule_set.stub(attributes: {current_user: Rules::Parameters::Attribute.new(key: :current_user)})
-      rule = Rules::Rule.new(rule_set: rule_set, lhs_parameter: 'current_user')
-      rule.lhs_parameter_object.should be_kind_of(Rules::Parameters::Attribute)
+      rule = Rules::Rule.new(rule_set: rule_set, lhs_parameter_key: 'current_user')
+      rule.lhs_parameter.should be_kind_of(Rules::Parameters::Attribute)
+    end
+  end
+
+  describe '#rhs_parameter' do
+    context 'with a raw value' do
+      it 'returns the raw value' do
+        rule = Rules::Rule.new(rhs_parameter_raw: 'value')
+        rule.rhs_parameter.should == 'value'
+      end
+    end
+
+    context 'with a parameter key' do
+      it 'returns nil if the parameter key does not have a corresponding attribute' do
+        rule = Rules::Rule.new(rhs_parameter_key: 'fake')
+        rule.rhs_parameter.should be_nil
+      end
+
+      it 'returns the constant for the parameter key if defined' do
+        rule = Rules::Rule.new(rhs_parameter_key: rhs_key)
+        rule.rhs_parameter.should be_kind_of(Rules::Parameters::Constant)
+      end
+
+      it 'returns the attribute for the parameter key if defined' do
+        rule_set.stub(attributes: {current_user: Rules::Parameters::Attribute.new(key: :current_user)})
+        rule = Rules::Rule.new(rule_set: rule_set, rhs_parameter_key: 'current_user')
+        rule.rhs_parameter.should be_kind_of(Rules::Parameters::Attribute)
+      end
     end
   end
 
   describe '#evaluate' do
+    let(:email_attribute) { Rules::Parameters::Attribute.new(key: :email_address) }
+    let(:name_attribute) { Rules::Parameters::Attribute.new(key: :name) }
+
+    before { rule_set.stub(attributes: {email_address: email_attribute, name: name_attribute}) }
+
     it 'returns true for rules that meet the conditions' do
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: Time.now.utc.to_date, evaluator: 'equals')
+      rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: Time.now.utc.to_date, evaluator_key: 'equals')
       rule.evaluate.should be_true
 
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: 2.weeks.ago.to_s, evaluator: 'not_equals')
+      rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: 2.weeks.ago.to_s, evaluator_key: 'not_equals')
       rule.evaluate.should be_true
 
-      rule_set.stub(attributes: {email_address: Rules::Parameters::Attribute.new(key: :email_address)})
-      rule = Rules::Rule.new(lhs_parameter: :email_address, rhs_parameter: /example.com$/, evaluator: 'matches', rule_set: rule_set)
+      rule = Rules::Rule.new(lhs_parameter_key: :email_address, rhs_parameter_raw: /example.com$/, evaluator_key: 'matches', rule_set: rule_set)
       rule.evaluate(email_address: 'test@example.com').should be_true
+
+      rule = Rules::Rule.new(lhs_parameter_key: :email_address, rhs_parameter_key: :name, evaluator_key: 'contains', rule_set: rule_set)
+      rule.evaluate(email_address: 'sally@example.com', name: 'sally').should be_true
     end
 
     it 'returns false for rules that do not meet the conditions' do
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: Time.now.utc.to_date, evaluator: 'not_equals')
+      rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: Time.now.utc.to_date, evaluator_key: 'not_equals')
       rule.evaluate.should be_false
 
-      rule = Rules::Rule.new(lhs_parameter: 'today', rhs_parameter: 2.weeks.ago.to_s, evaluator: 'equals')
+      rule = Rules::Rule.new(lhs_parameter_key: 'today', rhs_parameter_raw: 2.weeks.ago.to_s, evaluator_key: 'equals')
       rule.evaluate.should be_false
 
-      rule_set.stub(attributes: {email_address: Rules::Parameters::Attribute.new(key: :email_address)})
-      rule = Rules::Rule.new(lhs_parameter: :email_address, rhs_parameter: /example.com$/, evaluator: 'not_matches', rule_set: rule_set)
-     rule.evaluate(email_address: 'test@example.com').should be_false
+      rule = Rules::Rule.new(lhs_parameter_key: :email_address, rhs_parameter_raw: /example.com$/, evaluator_key: 'not_matches', rule_set: rule_set)
+      rule.evaluate(email_address: 'test@example.com').should be_false
+
+      rule = Rules::Rule.new(lhs_parameter_key: :email_address, rhs_parameter_key: :name, evaluator_key: 'contains', rule_set: rule_set)
+      rule.evaluate(email_address: 'sally@example.com', name: 'terry').should be_false
     end
   end