rules_engine 0.0.1

data/rails_generators/templates/spec/models/re_pipeline_base_spec.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe RePipelineBase do
+  def valid_attributes
+    {
+      :code => "AA-MOCK",
+      :title => "Mock Title"
+    }
+  end
+
+  it "should be valid with valid attributes" do
+    RePipelineBase.new(valid_attributes).should be_valid
+  end
+          
+  should_validate_presence_of :code
+  should_validate_presence_of :title
+  
+  describe "unique attributes" do
+    before(:each) do
+      RePipelineBase.create!(valid_attributes)
+    end
+  
+    should_validate_uniqueness_of :code, :scope => :parent_re_pipeline_id, :case_sensitive => false, :message=>"alread taken."    
+  end  
+
+  it "should change the code to lower case when creating" do
+    src = RePipelineBase.new(valid_attributes.merge(:code => "My code"))
+    src.save!
+    src.code.should == "my code"
+  end
+    
+  describe "code cannot be changed after creation" do
+    it "should save the code with a new record" do
+      src = RePipelineBase.new(valid_attributes.merge(:code => "my code"))
+      src.save!
+      src.code.should == "my code"
+    end
+    
+    it "should ignore the code attribute for an existing record" do
+      src = RePipelineBase.new(valid_attributes.merge(:code => "my code"))
+      src.save!
+      src.code = "new code"
+      src.save!
+      src.code.should == "my code"
+    end            
+  end
+
+  describe "copying the pipeline" do
+    
+    %W(code title description).each do |key|
+      it "should copy the attribute #{key}" do
+        src = RePipelineBase.new(valid_attributes.merge(key.to_sym => "mock source value"))
+        dest = RePipelineBase.new(valid_attributes.merge(key.to_sym => "mock dest value"))
+        dest.copy!(src)
+        dest.read_attribute(key).should == "mock source value"
+      end
+      
+      it "should copy the rules" do
+        src = RePipelineBase.new(valid_attributes)
+        dest = RePipelineBase.new(valid_attributes)
+        
+        src_rule = mock_model(ReRule)
+        dest_rule = mock_model(ReRule)
+                
+        ReRule.should_receive(:new).and_return(dest_rule)
+        dest_rule.should_receive(:copy!).with(src_rule).and_return(dest_rule)
+        
+        src.should_receive(:re_rules).and_return([src_rule])
+        dest.should_receive(:re_rules=).with([dest_rule])
+        
+        dest.copy!(src)
+      end
+    end
+  end
+  
+  describe "comparing pipeline" do
+    it "should be equal if the attributes are equal" do
+      src = RePipelineBase.new(valid_attributes)
+      dest =RePipelineBase.new(valid_attributes)
+      dest.equals?(src).should be_true
+    end
+    
+    %W(code title description).each do |key|
+      it "should not be equal if the attribute #{key} are different" do
+        src = RePipelineBase.new(valid_attributes.merge(key.to_sym => "mock source value"))
+        dest = RePipelineBase.new(valid_attributes.merge(key.to_sym => "mock dest value"))
+        dest.equals?(src).should be_false
+      end
+    end
+
+    describe "equals rule" do
+      before(:each) do
+        @rule_1 = mock_model(ReRule)
+        @rule_2 = mock_model(ReRule)
+        @re_pipeline_1 = RePipeline.new(valid_attributes)
+        @re_pipeline_2 = RePipeline.new(valid_attributes)
+        @re_pipeline_1.stub!(:re_rules).and_return([@rule_1, @rule_2])
+        @re_pipeline_2.stub!(:re_rules).and_return([@rule_1, @rule_2])
+        
+      end
+      it "should not compare the rules if the the number is different" do
+        @re_pipeline_2.stub!(:re_rules).and_return([@rule_1])
+      
+        @rule_1.should_not_receive(:equals?)
+        @rule_2.should_not_receive(:equals?)
+      
+        @re_pipeline_1.equals?(@re_pipeline_2)
+      end
+    
+      it "should check the equals status of each rule outcome" do
+        @rule_1.should_receive(:equals?).with(@rule_1).and_return(true)
+        @rule_2.should_receive(:equals?).with(@rule_2).and_return(true)
+      
+        @re_pipeline_1.equals?(@re_pipeline_2).should be_true
+      end
+      
+      it "should stop on the rule outcome equals error" do
+        @rule_1.should_receive(:equals?).with(@rule_1).and_return(false)
+        @rule_2.should_not_receive(:equals?)
+      
+        @re_pipeline_1.equals?(@re_pipeline_2).should be_false
+      end
+    end
+  end  
+  
+  describe "verify the pipeline" do
+    it "should return a failed message if there are no rules" do
+      src = RePipelineBase.new(valid_attributes.merge(:code => "my code"))
+      src.verify.should_not be_blank
+      src.verify.should =~ /rules required/
+    end
+    
+    it "should verify each rule" do
+      rule1 = mock_model(ReRule)
+      rule2 = mock_model(ReRule)
+      re_pipeline = RePipelineBase.new
+      re_pipeline.stub!(:re_rules).and_return([rule1, rule2])
+      
+      rule1.should_receive(:verify).at_least(:once).and_return(nil)
+      rule2.should_receive(:verify).at_least(:once).and_return(nil)
+      
+      re_pipeline.verify.should be_nil
+    end
+
+    it "should stop on the first verify error" do
+      rule1 = mock_model(ReRule)
+      rule2 = mock_model(ReRule)
+      re_pipeline = RePipelineBase.new
+      re_pipeline.stub!(:re_rules).and_return([rule1, rule2])
+      
+      rule1.should_receive(:verify).at_least(:once).and_return('failed rule 1')
+      rule2.should_not_receive(:verify)
+      
+      re_pipeline.verify.should == 'failed rule 1'
+    end
+  end
+end

data/rails_generators/templates/spec/models/re_pipeline_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+# require File.expand_path(File.dirname(__FILE__) + '/re_pipeline_base_spec')
+
+describe RePipeline do
+  def valid_attributes
+    {
+      :code => "AA-MOCK",
+      :title => "Mock Title"
+    }
+  end
+  
+  should_have_one :activated_re_pipeline
+  should_have_many :re_job_audits
+  
+  describe "setting the activated status" do
+    before(:each) do
+      @re_pipeline = RePipeline.new(valid_attributes)
+      @re_pipeline_activated = RePipeline.new(valid_attributes)
+      @re_pipeline.stub!(:activated_re_pipeline).and_return(@re_pipeline_activated)
+    end
+
+    it "should be set to draft when there is no activated re_pipeline" do
+      @re_pipeline.stub!(:activated_re_pipeline).and_return(nil)
+      @re_pipeline.stub!(:validate).and_return(true)
+      @re_pipeline.save
+      @re_pipeline.activated_status.should == RePipelineBase::ACTIVATED_STATUS_DRAFT
+    end
+
+    it "should be active if there is an activated re_pipeline" do
+      @re_pipeline.stub!(:validate).and_return(true)
+      @re_pipeline.save
+      @re_pipeline.activated_status.should == RePipelineBase::ACTIVATED_STATUS_ACTIVE
+    end
+  end
+    
+  describe "setting the changed status" do
+    before(:each) do
+      @re_pipeline = RePipeline.new(valid_attributes)
+      @re_pipeline_activated = RePipeline.new(valid_attributes)
+      @re_pipeline.stub!(:activated_re_pipeline).and_return(@re_pipeline_activated)
+    end
+    
+    it "should be set to draft when there is no activated re_pipeline" do
+      @re_pipeline.stub!(:activated_re_pipeline).and_return(nil)
+      @re_pipeline.stub!(:validate).and_return(true)
+      @re_pipeline.save
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_DRAFT
+    end
+    
+    it "should be set to changed if the activated re_pipeline is not equal" do
+      @re_pipeline.should_receive(:equals?).with(@re_pipeline_activated).and_return(false)      
+      @re_pipeline.save
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CHANGED
+    end
+  end
+  
+
+  describe "activating a re_pipeline" do
+    before(:each) do
+      @re_pipeline = RePipeline.new(valid_attributes)
+      @re_pipeline_activated = RePipelineActivated.new
+      RePipelineActivated.stub!(:new).and_return(@re_pipeline_activated)
+    end
+        
+    it "should create an associated activated re_pipeline if it does not exist" do
+      RePipelineActivated.should_receive(:new).and_return(@re_pipeline_activated)
+      @re_pipeline.activate!
+    end
+
+    it "should update the activated_status to RePipelineBase::ACTIVATED_STATUS_ACTIVE" do
+      @re_pipeline.activate!
+      @re_pipeline.activated_status.should == RePipelineBase::ACTIVATED_STATUS_ACTIVE
+    end
+
+    it "should update the changed_status to RePipelineBase::CHANGED_STATUS_CURRENT" do
+      @re_pipeline.activate!
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CURRENT
+    end
+
+    it "should copy itself to the activated re_pipeline" do
+      @re_pipeline_activated.should_receive(:copy!).with(@re_pipeline)
+      @re_pipeline.activate!
+    end
+
+    it "should save the re_pipeline" do
+      @re_pipeline.should_receive(:save)
+      @re_pipeline.activate!
+    end
+    
+    it "should do the saving in a transaction" do
+      RePipeline.should_receive(:transaction)
+      @re_pipeline.should_not_receive(:save)
+      @re_pipeline.activate!
+    end
+        
+    it "should save the activated re_pipeline if it is not a new record" do
+      @re_pipeline.should_receive(:new_record?).at_least(:once).and_return(false)
+      @re_pipeline_activated.should_receive(:save!)
+      @re_pipeline.activate!
+    end
+
+    it "should not save the activated re_pipeline if it is a new record" do
+      @re_pipeline.should_receive(:new_record?).at_least(:once).and_return(true)
+      @re_pipeline_activated.should_not_receive(:save!)
+      @re_pipeline.activate!
+    end
+  end
+
+  describe "reverting a re_pipeline to it's previous state" do
+    before(:each) do
+      @re_pipeline = RePipeline.create(valid_attributes)
+      @re_pipeline.activate!
+      @re_pipeline_activated = @re_pipeline.activated_re_pipeline
+      
+      @re_pipeline.update_attributes(:title => "new title")
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CHANGED
+    end
+
+    it "should copy the content from the activated re_pipeline" do
+      @re_pipeline.should_receive(:copy!).with(@re_pipeline_activated)
+      @re_pipeline.revert!
+    end
+
+    it "should not try and copy content id there is no activated re_pipeline" do
+      @re_pipeline.stub!(:activated_re_pipeline).and_return(nil)      
+      @re_pipeline.should_not_receive(:copy!)
+      @re_pipeline.revert!
+    end
+        
+    it "should save the re_pipeline" do
+      @re_pipeline.should_receive(:save)
+      @re_pipeline.revert!
+    end
+    
+    it "should update the activated_status to RePipelineBase::ACTIVATED_STATUS_ACTIVE" do
+      @re_pipeline.revert!
+      @re_pipeline.activated_status.should == RePipelineBase::ACTIVATED_STATUS_ACTIVE
+    end
+
+    it "should update the changed_status to RePipelineBase::CHANGED_STATUS_CURRENT" do
+      @re_pipeline.revert!
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CURRENT
+    end    
+  end
+  
+  describe "changing a re_pipeline" do
+    before(:each) do
+      @re_pipeline = RePipeline.create(valid_attributes)
+      @re_pipeline.activate!
+      @re_pipeline_activated = @re_pipeline.activated_re_pipeline
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CURRENT
+    end
+        
+    it "should update the activated_status to RePipelineBase::ACTIVATED_STATUS_ACTIVE" do
+      @re_pipeline.update_attributes(:title => "new title")
+      @re_pipeline.activated_status.should == RePipelineBase::ACTIVATED_STATUS_ACTIVE
+    end
+
+    it "should update the changed_status to RePipelineBase::CHANGED_STATUS_CHANGED" do
+      @re_pipeline.update_attributes(:title => "new title")
+      @re_pipeline.changed_status.should == RePipelineBase::CHANGED_STATUS_CHANGED
+    end
+    
+  end
+  
+end

data/rails_generators/templates/spec/models/re_rule_outcome_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ReRuleOutcome do
+  def valid_attributes
+    {
+      :outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT
+    }
+  end
+  
+  it "should be valid with valid attributes" do
+    ReRuleOutcome.new(valid_attributes).should be_valid
+  end
+  
+  should_validate_presence_of :outcome
+
+  describe "START PIPELINE" do
+    it "should be invalid when the outcome pipeline code is blank" do
+      re_rule_outcome = ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE)
+      re_rule_outcome.should_not be_valid
+      re_rule_outcome.errors.on(:pipeline_code).should_not be_blank
+    end      
+
+    it "should be valid when outcome pipeline code is present" do
+      re_rule_outcome = ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "mock code")
+      re_rule_outcome.should be_valid
+    end      
+  end
+
+  describe "copying the details from another rule outcome" do
+    
+    %W(pipeline_code).each do |key|
+      it "should copy the attribute #{key}" do
+        src = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => "mock source value"))
+        dest = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => "mock dest value"))
+        dest.copy!(src)
+        dest.read_attribute(key).should == "mock source value"
+      end
+    end
+
+    %W(outcome).each do |key|
+      it "should copy the attribute #{key}" do
+        src = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => 101))
+        dest = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => 202))
+        dest.copy!(src)
+        dest.read_attribute(key).should == 101
+      end
+    end
+  end
+
+  describe "comparing rule outcomes" do
+    it "should be equal if the attributes are equal" do
+      src = ReRuleOutcome.new(valid_attributes)
+      dest = ReRuleOutcome.new(valid_attributes)
+      dest.equals?(src).should be_true
+    end
+    
+    %W(outcome).each do |key|
+      it "should not be equal if the attribute #{key} are different" do
+        src = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => 101))
+        dest = ReRuleOutcome.new(valid_attributes.merge(key.to_sym => 202))
+        dest.equals?(src).should be_false
+      end
+    end
+    
+    it "should not be equal if the outcome is OUTCOME_START_PIPELINE and pipeline_code are different" do
+      src = ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 1")
+      dest = ReRuleOutcome.new(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 2")
+      dest.equals?(src).should be_false
+    end
+    
+  end
+  
+  describe "verify the rule outcome" do
+    it "should be nil if the outcome is OUTCOME_NEXT" do
+      ReRuleOutcome.new(valid_attributes.merge(:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT)).verify.should be_nil
+    end
+
+    it "should be nil if the outcome is OUTCOME_STOP_SUCCESS" do
+      ReRuleOutcome.new(valid_attributes.merge(:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT)).verify.should be_nil
+    end
+
+    it "should be nil if the outcome is OUTCOME_STOP_FAILURE" do
+      ReRuleOutcome.new(valid_attributes.merge(:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)).verify.should be_nil
+    end
+
+    it "should be valid if the outcome is OUTCOME_START_PIPELINE and the pipleine exists" do
+      RePipeline.should_receive(:find).with(:first, {:conditions=>["code = ?", "value 2"]}).and_return(true)
+      ReRuleOutcome.new(valid_attributes.merge(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 2")).verify.should be_nil
+    end
+
+    it "should be invalid if the outcome is OUTCOME_START_PIPELINE and the pipleine does not exist" do
+      RePipeline.should_receive(:find).with(:first, {:conditions=>["code = ?", "value 2"]}).and_return(nil)
+      ReRuleOutcome.new(valid_attributes.merge(:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => "value 2")).verify.should == "outcome pipeline missing"
+    end
+  end
+  
+end

data/rails_generators/templates/spec/models/re_rule_spec.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ReRule do
+  def valid_attributes
+    {
+      :title => "Mock Title",      
+      :rule_class => "Mock Type",
+      :summary => "Mock Summary",
+      :data_version => 0,
+      :data => "Lots Of Data"
+    }
+  end
+  
+  it "should be valid with valid attributes" do
+    ReRule.new(valid_attributes).should be_valid
+  end
+
+  should_have_many :re_rule_outcomes
+  should_have_many :re_job_audits
+  
+  should_validate_presence_of :title
+  should_validate_presence_of :rule_class
+  should_validate_presence_of :summary
+  should_validate_presence_of :data_version
+  should_validate_presence_of :data
+  
+  describe "copying the rule" do
+    
+    %W(title rule_class summary data error).each do |key|
+      it "should copy the attribute #{key}" do
+        src = ReRule.new(valid_attributes.merge(key.to_sym => "mock source value"))
+        dest = ReRule.new(valid_attributes.merge(key.to_sym => "mock dest value"))
+        dest.copy!(src)
+        dest.read_attribute(key).should == "mock source value"
+      end
+    end
+
+    %W(position data_version).each do |key|
+      it "should copy the attribute #{key}" do
+        src = ReRule.new(valid_attributes.merge(key.to_sym => 101))
+        dest = ReRule.new(valid_attributes.merge(key.to_sym => 202))
+        dest.copy!(src)
+        dest.read_attribute(key).should == 101
+      end
+    end
+    
+    it "should copy the rule outcomes" do
+      src = ReRule.new(valid_attributes)
+      dest = ReRule.new(valid_attributes)
+      
+      src_outcome = mock_model(ReRuleOutcome)
+      dest_outcome = mock_model(ReRuleOutcome )
+              
+      ReRuleOutcome.should_receive(:new).and_return(dest_outcome)
+      dest_outcome.should_receive(:copy!).with(src_outcome).and_return(dest_outcome)
+      
+      src.should_receive(:re_rule_outcomes).and_return([src_outcome])
+      dest.should_receive(:re_rule_outcomes=).with([dest_outcome])
+      
+      dest.copy!(src)
+    end
+  end
+
+  describe "comparing rules" do
+    it "should be equal if the attributes are equal" do
+      src = ReRule.new(valid_attributes)
+      dest = ReRule.new(valid_attributes)
+      dest.equals?(src).should be_true
+    end
+    
+    %W(title rule_class summary data).each do |key|
+      it "should not be equal if the attribute #{key} are different" do
+        src = ReRule.new(valid_attributes.merge(key.to_sym => "mock source value"))
+        dest = ReRule.new(valid_attributes.merge(key.to_sym => "mock dest value"))
+        dest.equals?(src).should be_false
+      end
+    end
+
+    %W(position data_version).each do |key|
+      it "should not be equal if the attribute #{key} are different" do
+        src = ReRule.new(valid_attributes.merge(key.to_sym => 101))
+        dest = ReRule.new(valid_attributes.merge(key.to_sym => 202))
+        dest.equals?(src).should be_false
+      end
+    end
+
+    describe "equals rule outcome" do
+      before(:each) do
+        @re_rule_re_rule_outcome_1 = mock_model(ReRuleOutcome)
+        @re_rule_re_rule_outcome_2 = mock_model(ReRuleOutcome)
+        @re_rule_1 = ReRule.new(valid_attributes)
+        @re_rule_2 = ReRule.new(valid_attributes)
+        @re_rule_1.stub!(:re_rule_outcomes).and_return([@re_rule_re_rule_outcome_1, @re_rule_re_rule_outcome_2])
+        @re_rule_2.stub!(:re_rule_outcomes).and_return([@re_rule_re_rule_outcome_1, @re_rule_re_rule_outcome_2])
+        
+      end
+      it "should not compare the outcomes if the the number is different" do
+        @re_rule_2.stub!(:re_rule_outcomes).and_return([@re_rule_re_rule_outcome_1])
+        
+        @re_rule_re_rule_outcome_1.should_not_receive(:equals?)
+        @re_rule_re_rule_outcome_2.should_not_receive(:equals?)
+      
+        @re_rule_1.equals?(@re_rule_2)
+      end
+    
+      it "should check the equals status of each rule outcome" do
+        @re_rule_re_rule_outcome_1.should_receive(:equals?).with(@re_rule_re_rule_outcome_1).and_return(true)
+        @re_rule_re_rule_outcome_2.should_receive(:equals?).with(@re_rule_re_rule_outcome_2).and_return(true)
+      
+        @re_rule_1.equals?(@re_rule_2).should be_true
+      end
+      
+      it "should stop on the rule outcome equals error" do
+        @re_rule_re_rule_outcome_1.should_receive(:equals?).with(@re_rule_re_rule_outcome_1).and_return(false)
+        @re_rule_re_rule_outcome_2.should_not_receive(:equals?)
+      
+        @re_rule_1.equals?(@re_rule_2).should be_false
+      end
+    end
+  end  
+
+  describe "verify the rule" do
+    it "should return the rule_error if not blank" do
+      src = ReRule.new(valid_attributes.merge(:error => "mock rule error"))
+      src.verify.should_not be_blank
+      src.verify.should == "mock rule error"
+    end
+    
+    it "should verify each rule outcome" do
+      re_rule_outcome_1 = mock_model(ReRule)
+      re_rule_outcome_2 = mock_model(ReRule)
+      re_rule = ReRule.new
+      re_rule.stub!(:re_rule_outcomes).and_return([re_rule_outcome_1, re_rule_outcome_2])
+      
+      re_rule_outcome_1.should_receive(:verify).at_least(:once).and_return(nil)
+      re_rule_outcome_2.should_receive(:verify).at_least(:once).and_return(nil)
+      
+      re_rule.verify.should be_nil
+    end
+
+    it "should stop on the first verify error" do
+      re_rule_outcome_1 = mock_model(ReRule)
+      re_rule_outcome_2 = mock_model(ReRule)
+      re_rule = ReRule.new
+      re_rule.stub!(:re_rule_outcomes).and_return([re_rule_outcome_1, re_rule_outcome_2])
+      
+      re_rule_outcome_1.should_receive(:verify).at_least(:once).and_return("mock fail error")
+      re_rule_outcome_2.should_not_receive(:verify)
+      
+      re_rule.verify.should == "mock fail error"
+    end
+  end
+
+  describe "moving items up in a list" do
+    it "should move a rule down in the list" do
+      base = RePipelineBase.create!(:code => "AA-MOCK",:title => "Mock Title")
+      re_rule_1 = ReRule.new(valid_attributes)
+      re_rule_2 = ReRule.new(valid_attributes)
+      base.re_rules << re_rule_1
+      base.re_rules << re_rule_2
+      
+      base.reload    
+      
+      base.re_rules.should == [re_rule_1, re_rule_2]
+      base.re_rules[1].move_higher
+      base.reload    
+
+      base.re_rules.should == [re_rule_2, re_rule_1]
+    end
+  end
+end

data/rails_generators/templates/spec/support/blueprint_re_pipelines.rb

@@ -0,0 +1,11 @@
+# PIPELINES
+RePipeline.blueprint do
+  title         { | index |  "#{Faker::Lorem.words(2).join(' ')} #{index} #{Faker::Lorem.words(2).join(' ')}" }
+  description   { Faker::Lorem.sentence }
+end
+
+RePipelineActivated.blueprint do
+  title         { | index |  "#{Faker::Lorem.words(2).join(' ')} #{index} #{Faker::Lorem.words(2).join(' ')}" }
+  description   { Faker::Lorem.sentence }
+end
+

data/spec/rules_engine_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "RulesEngine" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'dougo_rules_engine'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/tasks/rspec.rake

@@ -0,0 +1,18 @@
+require 'spec/rake/spectask'
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov (excluding plugin specs)"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/../spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = lambda do
+      IO.readlines("#{File.dirname(__FILE__)}/../spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+    end
+  end
+end