rules_engine_templates 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/rails_generators/manifests/tweet_filter.rb

@@ -0,0 +1,29 @@
+class TweetFilterManifest
+  def self.populate_record(m, rule_name ,rule_class)
+
+    %W(
+      app/rules
+      app/views/re_rule_definitions/#{rule_name}
+      lib/tasks
+      spec/lib/rules
+    ).each do |dirname|
+      m.directory dirname
+    end
+
+    %W(
+    ).each do |filename|
+      m.file filename, filename
+    end
+
+   m.template "app/rules/tweet_filter.rb",  "app/rules/#{rule_name}.rb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_edit.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_edit.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_help.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_help.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_new.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_new.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_script.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_script.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_title.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_title.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_word.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_word.html.erb"
+   m.template "app/views/re_rule_definitions/tweet_filter/_words.html.erb",  "app/views/re_rule_definitions/#{rule_name}/_words.html.erb"
+   m.template "spec/lib/rules/tweet_filter_spec.rb",  "spec/lib/rules/#{rule_name}_spec.rb"
+
+  end
+end

data/rails_generators/manifests/tweet_filter.yml

@@ -0,0 +1,24 @@
+directories :
+  - app/rules
+  - spec/lib/rules
+  - lib/tasks
+
+templates :
+  replacements :
+    - tweet_filter : rule_name
+    - TweetFilter : rule_class
+    
+  directories : 
+    - app/views/re_rule_definitions/tweet_filter
+
+  files : 
+    - app/rules/tweet_filter.rb
+    - app/views/re_rule_definitions/tweet_filter/_edit.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_help.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_new.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_script.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_title.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_word.html.erb
+    - app/views/re_rule_definitions/tweet_filter/_words.html.erb
+    - spec/lib/rules/tweet_filter_spec.rb
+  

data/rails_generators/templates/app/rules/tweet_filter.rb

@@ -0,0 +1,104 @@
+module RulesEngine
+  module Rule
+    class <%=rule_class%> < RulesEngine::Rule::Definition
+
+      attr_reader :words
+
+      ##################################################################
+      # class options
+      self.options = 
+        {
+          :group => 'Twitter',
+          :display_name => 'Twitter Filter',    
+          :help_partial => '/re_rule_definitions/<%=rule_name%>/help',
+          :new_partial => '/re_rule_definitions/<%=rule_name%>/new',
+          :edit_partial => '/re_rule_definitions/<%=rule_name%>/edit'
+        } 
+  
+      ##################################################################
+      # set the rule data
+      def data= data
+        if data.nil?
+          @title = nil
+          @words = nil
+        else
+          @title, @words = ActiveSupport::JSON.decode(data)
+        end  
+      end
+  
+      ##################################################################
+      # get the rule attributes
+      def title
+        @title
+      end
+
+      def summary
+        "Filter out tweets with the #{words.size == 1 ? 'word' : 'words'} #{words.join(', ')}"
+      end
+  
+      def data
+        [title, words].to_json
+      end
+  
+      def expected_outcomes
+          [{:outcome => RulesEngine::Rule::Outcome::NEXT}, {:outcome => RulesEngine::Rule::Outcome::STOP_SUCCESS}]
+      end
+  
+      ##################################################################
+      # set the rule attributes
+      def attributes=(params)
+        param_hash = params.symbolize_keys
+
+        @title = param_hash[:<%=rule_name%>_title]
+    
+        @words = []
+        return if param_hash[:<%=rule_name%>_words].nil?
+        param_hash[:<%=rule_name%>_words].each do |key, values| 
+          if values.is_a?(Hash)
+            word_hash = values.symbolize_keys
+            @words << word_hash[:word].downcase unless word_hash[:word].blank? || word_hash[:_delete] == '1'
+          end  
+        end
+      end
+  
+      ##################################################################
+      # validation and errors
+      def valid?
+        @errors = {}
+        @errors[:<%=rule_name%>_words] = "At least one word must be defined" if words.nil? || words.empty?
+        @errors[:<%=rule_name%>_title] = "Title required" if title.blank?    
+        return @errors.empty?
+      end
+
+      ##################################################################
+      # callbacks when the rule is added and removed from a workflow
+      def after_add_to_workflow(workflow_code)
+      end
+  
+      def before_remove_from_workflow(workflow_code)
+      end
+  
+      ##################################################################
+      # execute the rule
+      # if a match is found procees to the expected outcome
+      # it gets the data parameter :tweet
+      # it sets the data parameter :match
+      def process(process_id, data)
+        tweet = data[:tweet] || data["tweet"]    
+        if tweet.blank?
+          return RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::NEXT) 
+        end
+    
+        words.each do |word|
+          if /#{word}/i =~ tweet        
+            RulesEngine::Process.auditor.audit(process_id, "#{title} Found #{word}", RulesEngine::Process::AUDIT_INFO)
+            data[:match] = word
+            return RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::STOP_SUCCESS)
+          end
+        end
+        
+        RulesEngine::Rule::Outcome.new(RulesEngine::Rule::Outcome::NEXT)
+      end      
+    end
+  end
+end  

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_edit.html.erb

@@ -0,0 +1,5 @@
+<%%= render '/re_rule_definitions/<%=rule_name%>/script' %>
+
+<%%= render '/re_rule_definitions/<%=rule_name%>/title' %>
+
+<%%= render '/re_rule_definitions/<%=rule_name%>/words', :f => f %>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_help.html.erb

@@ -0,0 +1 @@
+<p>Twitter Filter : This will filter out any tweets with the matching text</p>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_new.html.erb

@@ -0,0 +1,5 @@
+<%%= render '/re_rule_definitions/<%=rule_name%>/script' %>
+
+<%%= render '/re_rule_definitions/<%=rule_name%>/title' %>
+
+<%%= render '/re_rule_definitions/<%=rule_name%>/words', :f => f %>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_script.html.erb

@@ -0,0 +1,8 @@
+<%% javascript_tag do %>
+  var new_<%=rule_name%> = '<%%=escape_javascript(render("/re_rule_definitions/<%=rule_name%>/word"))%>'  
+  
+  $(document).ready(function() {	
+    $('#rule_title').focus();	
+  });
+
+<%% end %>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_title.html.erb

@@ -0,0 +1,7 @@
+<%%= re_text_field "Filter Title", 
+                        "<%=rule_name%>_title", 
+                        params[:<%=rule_name%>_title] || @re_rule.rule.title,
+                        :size => 30, 
+                        :required => true, 
+												:error => @re_rule.rule.errors[:<%=rule_name%>_title],
+                        :span => '4x13' %>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_word.html.erb

@@ -0,0 +1,13 @@
+<%% id = local_assigns[:position] ? position : 'NEW_RECORD'  %>
+
+<div id="<%=rule_name%>_<%%=id%>">
+  <%%= re_text_field "Words to filter", "<%=rule_name%>_words[#{id}][word]",  
+                                            local_assigns[:word] ? word : '',
+                                            :size => 25, 
+                                            :required => id == 0, 
+                                            :span => '4x13', 
+																						:error => id == 0 ? @re_rule.rule.errors[:<%=rule_name%>_words] : nil,
+                                            :hint => re_remove_link("Remove", "<%=rule_name%>[#{id}]", id) %>
+        
+  <%%= re_remove_field("<%=rule_name%>[#{id}]", id) %>      
+</div>

data/rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_words.html.erb

@@ -0,0 +1,16 @@
+<%% position = 0 %>
+<%% (@re_rule.rule.words || []).each do | word | %>  
+  <%% f.fields_for :rule_data, {:first => false} do |frd| %>
+    <%%= render '/re_rule_definitions/<%=rule_name%>/word', :f => frd, :position => position, :word => word %>
+    <%% position += 1 %>        
+  <%% end %>
+<%% end %>  
+<%% if position == 0 %>
+  <%% f.fields_for :rule_data, {:first => false} do |frd| %>
+    <%%= render '/re_rule_definitions/<%=rule_name%>/word', :f => frd, :position => position %>      
+  <%% end %>
+<%% end %>
+
+<div id="new_position_<%=rule_name%>"></div>
+<%%= re_form_text "", re_add_link('Add another word to filter', '<%=rule_name%>') %>    
+

data/rails_generators/templates/spec/lib/rules/rule_tweet_filter_spec.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe <%=rule_class%> do
+
+  def valid_attributes
+    {
+      :tweet_filter_title => 'Valid Title',
+      :tweet_filter_words => {
+                    "1" => { "word" => 'first word'  },
+                    "2" => { "word" => 'second word' }
+                  }
+    }
+  end
+  
+  def valid_json_data
+    '["Rule Title", ["one", "two"]]'
+  end
+  
+  it "should be discoverable" do
+    RulesEngine::Discovery.rule_class("<%=rule_class%>").should == <%=rule_class%>
+  end
+
+  describe "the expected class options" do    
+    it "should be in the 'Twitter' group" do
+      <%=rule_class%>.options[:group].should == "Twitter"
+    end
+    
+    it "should have the diplay name of 'Twitter Filter'" do
+      <%=rule_class%>.options[:display_name].should == "Twitter Filter"
+    end
+
+    it "should have the help template of '/re_rule_definitions/<%=rule_name%>/help'" do
+      <%=rule_class%>.options[:help_partial].should == '/re_rule_definitions/<%=rule_name%>/help'
+    end
+
+    it "should have the new template of '/re_rule_definitions/<%=rule_name%>/new'" do
+      <%=rule_class%>.options[:new_partial].should == '/re_rule_definitions/<%=rule_name%>/new'
+    end
+
+    it "should have the edit view partial template of '/re_rule_definitions/<%=rule_name%>/edit'" do
+      <%=rule_class%>.options[:edit_partial].should == '/re_rule_definitions/<%=rule_name%>/edit'
+    end
+  end
+  
+  describe "setting the rule data" do
+    before(:each) do
+      @filter = <%=rule_class%>.new
+      @filter.data = valid_json_data
+    end  
+    
+    describe "the json data is valid" do
+      it "should be valid" do
+        @filter.should be_valid
+      end
+            
+      it "should set the title" do
+        @filter.title.should == "Rule Title"        
+      end
+
+      it "should set the words" do
+        @filter.words.should == ["one", "two"]
+      end
+    end
+
+    describe "the data is nil" do
+      it "should set the title to nil" do
+        @filter.title.should_not be_nil
+        @filter.data = nil
+        @filter.title.should be_nil
+      end
+      
+      it "should set the words to nil" do
+        @filter.words.should_not be_nil
+        @filter.data = nil
+        @filter.words.should be_nil
+      end
+    end
+  end
+  
+  describe "the summary" do
+    it "should be singluar if there is one word" do
+      filter = <%=rule_class%>.new
+      filter.stub!(:words).and_return(["one"])
+      filter.summary.should == "Filter out tweets with the word one"
+    end
+
+    it "should be plural if there are multiple words" do
+      filter = <%=rule_class%>.new
+      filter.stub!(:words).and_return(["one", "two", "three"])
+      filter.summary.should == "Filter out tweets with the words one, two, three"
+    end        
+  end
+
+  describe "the data" do
+    it "should be converted to a json string" do
+      filter = <%=rule_class%>.new
+      filter.should_receive(:title).and_return(["mock title"])
+      filter.should_receive(:words).and_return(["one", "two"])
+      filter.data.should == '[["mock title"],["one","two"]]'
+    end
+  end
+  
+  describe "the expected_outcomes" do
+    it "should be next and stop success" do
+      filter = <%=rule_class%>.new
+      filter.expected_outcomes.should == [{:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT}, {:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS}]
+    end
+  end
+  
+  describe "setting the rule attributes" do
+    before(:each) do
+      @filter = <%=rule_class%>.new
+    end  
+    
+    it "should be valid with valid attributes" do
+      @filter.attributes = valid_attributes
+      @filter.should be_valid
+    end            
+
+    describe "setting the tweet_filter_title" do
+      it "should set the title" do
+        @filter.attributes = valid_attributes
+        @filter.title.should == 'Valid Title'
+      end            
+    
+      it "should not be valid if the 'tweet_filter_title' attribute is missing" do
+        @filter.attributes = valid_attributes.except(:tweet_filter_title)
+        @filter.should_not be_valid
+        @filter.errors.should include(:tweet_filter_title)      
+      end            
+    
+      it "should not be valid if the 'tweet_filter_title' attribute is blank" do
+        @filter.attributes = valid_attributes.merge(:tweet_filter_title => "")
+        @filter.should_not be_valid
+        @filter.errors.should include(:tweet_filter_title)
+      end                
+    end
+
+    describe "setting the tweet_filter_words" do
+      it "should set the words" do
+        @filter.attributes = valid_attributes
+        @filter.words.should == ['first word', 'second word']
+      end            
+    
+      it "should not be valid if the 'tweet_filter_words' attribute is missing" do
+        @filter.attributes = valid_attributes.except(:tweet_filter_words)
+        @filter.should_not be_valid
+        @filter.errors.should include(:tweet_filter_words)      
+      end            
+    
+      it "should not be valid if the 'tweet_filter_words' is not a hash" do
+        @filter.attributes = valid_attributes.merge(:tweet_filter_words => "filter word")
+        @filter.should_not be_valid
+        @filter.errors.should include(:tweet_filter_words)
+      end                
+
+      it "should not be valid if the 'tweet_filter_words' is empty" do
+        @filter.attributes = valid_attributes.merge(:tweet_filter_words => {})
+        @filter.should_not be_valid
+        @filter.errors.should include(:tweet_filter_words)
+      end                
+      
+      it "should not include parameters that are marked for deletion" do
+        @filter.attributes = valid_attributes.merge(:tweet_filter_words => {
+                                                                              "1" => { "word" => 'first word', "_delete" => '1'  },
+                                                                              "2" => { "word" => 'second word' }
+                                                                            }         
+         )
+        @filter.should be_valid
+        @filter.words.should == ['second word']
+      end
+    end
+  end
+
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+  
+  describe "processing the rule" do
+    before(:each) do
+      @filter = <%=rule_class%>.new
+      @filter.stub!(:words).and_return(["found", "word"])
+    end
+    
+    it "should do nothing if there is no tweet" do      
+      @filter.process(1001, {}).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+    end        
+  
+    it "should do nothing if there is no match" do
+      @filter.process(@job, {:tweet => "not here"}).outcome.should == RulesEngine::RuleOutcome::OUTCOME_NEXT
+    end        
+    
+    describe "a match found" do
+      before(:each) do
+        @matched_data = {:tweet => "here is a word"}
+      end
+      
+      it "should add the match to the data" do              
+        @filter.process(@job, @matched_data)
+        @matched_data[:match].should == "word"
+      end        
+      
+      it "should audit the match" do  
+        RulesEngine::Process.auditor.should_receive(:audit) do |process_id, message, code|
+          process_id.should == 1001
+          message.should =~ /word$/
+        end
+        @filter.process(1001, @matched_data)
+      end        
+      
+      it "should return stop_success" do
+        @filter.process(1001, @matched_data).outcome.should == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+      end
+    end    
+  end
+end

data/rails_generators/templates/spec/lib/rules/tweet_filter_spec.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RulesEngine::Rule::<%=rule_class%> do
+
+  def valid_attributes
+    {
+      :<%=rule_name%>_title => 'Valid Title',
+      :<%=rule_name%>_words => {
+                    "1" => { "word" => 'first word'  },
+                    "2" => { "word" => 'second word' }
+                  }
+    }
+  end
+  
+  def valid_json_data
+    '["Rule Title", ["one", "two"]]'
+  end
+  
+  it "should be discoverable" do
+    RulesEngine::Discovery.rule_class("RulesEngine::Rule::<%=rule_class%>").should == RulesEngine::Rule::<%=rule_class%>
+  end
+
+  describe "the expected class options" do    
+    it "should be in the 'Twitter' group" do
+      RulesEngine::Rule::<%=rule_class%>.options[:group].should == "Twitter"
+    end
+    
+    it "should have the diplay name of 'Twitter Filter'" do
+      RulesEngine::Rule::<%=rule_class%>.options[:display_name].should == "Twitter Filter"
+    end
+
+    it "should have the help template of '/re_rule_definitions/<%=rule_name%>/help'" do
+      RulesEngine::Rule::<%=rule_class%>.options[:help_partial].should == '/re_rule_definitions/<%=rule_name%>/help'
+    end
+
+    it "should have the new template of '/re_rule_definitions/<%=rule_name%>/new'" do
+      RulesEngine::Rule::<%=rule_class%>.options[:new_partial].should == '/re_rule_definitions/<%=rule_name%>/new'
+    end
+
+    it "should have the edit view partial template of '/re_rule_definitions/<%=rule_name%>/edit'" do
+      RulesEngine::Rule::<%=rule_class%>.options[:edit_partial].should == '/re_rule_definitions/<%=rule_name%>/edit'
+    end
+  end
+  
+  describe "setting the rule data" do
+    before(:each) do
+      @filter = RulesEngine::Rule::<%=rule_class%>.new
+      @filter.data = valid_json_data
+    end  
+    
+    describe "the json data is valid" do
+      it "should be valid" do
+        @filter.should be_valid
+      end
+            
+      it "should set the title" do
+        @filter.title.should == "Rule Title"        
+      end
+
+      it "should set the words" do
+        @filter.words.should == ["one", "two"]
+      end
+    end
+
+    describe "the data is nil" do
+      it "should set the title to nil" do
+        @filter.title.should_not be_nil
+        @filter.data = nil
+        @filter.title.should be_nil
+      end
+      
+      it "should set the words to nil" do
+        @filter.words.should_not be_nil
+        @filter.data = nil
+        @filter.words.should be_nil
+      end
+    end
+  end
+  
+  describe "the summary" do
+    it "should be singluar if there is one word" do
+      filter = RulesEngine::Rule::<%=rule_class%>.new
+      filter.stub!(:words).and_return(["one"])
+      filter.summary.should == "Filter out tweets with the word one"
+    end
+
+    it "should be plural if there are multiple words" do
+      filter = RulesEngine::Rule::<%=rule_class%>.new
+      filter.stub!(:words).and_return(["one", "two", "three"])
+      filter.summary.should == "Filter out tweets with the words one, two, three"
+    end        
+  end
+
+  describe "the data" do
+    it "should be converted to a json string" do
+      filter = RulesEngine::Rule::<%=rule_class%>.new
+      filter.should_receive(:title).and_return(["mock title"])
+      filter.should_receive(:words).and_return(["one", "two"])
+      filter.data.should == '[["mock title"],["one","two"]]'
+    end
+  end
+  
+  describe "the expected_outcomes" do
+    it "should be next and stop success" do
+      filter = RulesEngine::Rule::<%=rule_class%>.new
+      filter.expected_outcomes.should == [{:outcome => RulesEngine::Rule::Outcome::NEXT}, {:outcome => RulesEngine::Rule::Outcome::STOP_SUCCESS}]
+    end
+  end
+  
+  describe "setting the rule attributes" do
+    before(:each) do
+      @filter = RulesEngine::Rule::<%=rule_class%>.new
+    end  
+    
+    it "should be valid with valid attributes" do
+      @filter.attributes = valid_attributes
+      @filter.should be_valid
+    end            
+
+    describe "setting the <%=rule_name%>_title" do
+      it "should set the title" do
+        @filter.attributes = valid_attributes
+        @filter.title.should == 'Valid Title'
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_title' attribute is missing" do
+        @filter.attributes = valid_attributes.except(:<%=rule_name%>_title)
+        @filter.should_not be_valid
+        @filter.errors.should include(:<%=rule_name%>_title)      
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_title' attribute is blank" do
+        @filter.attributes = valid_attributes.merge(:<%=rule_name%>_title => "")
+        @filter.should_not be_valid
+        @filter.errors.should include(:<%=rule_name%>_title)
+      end                
+    end
+
+    describe "setting the <%=rule_name%>_words" do
+      it "should set the words" do
+        @filter.attributes = valid_attributes
+        @filter.words.should == ['first word', 'second word']
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_words' attribute is missing" do
+        @filter.attributes = valid_attributes.except(:<%=rule_name%>_words)
+        @filter.should_not be_valid
+        @filter.errors.should include(:<%=rule_name%>_words)      
+      end            
+    
+      it "should not be valid if the '<%=rule_name%>_words' is not a hash" do
+        @filter.attributes = valid_attributes.merge(:<%=rule_name%>_words => "filter word")
+        @filter.should_not be_valid
+        @filter.errors.should include(:<%=rule_name%>_words)
+      end                
+
+      it "should not be valid if the '<%=rule_name%>_words' is empty" do
+        @filter.attributes = valid_attributes.merge(:<%=rule_name%>_words => {})
+        @filter.should_not be_valid
+        @filter.errors.should include(:<%=rule_name%>_words)
+      end                
+      
+      it "should not include parameters that are marked for deletion" do
+        @filter.attributes = valid_attributes.merge(:<%=rule_name%>_words => {
+                                                                              "1" => { "word" => 'first word', "_delete" => '1'  },
+                                                                              "2" => { "word" => 'second word' }
+                                                                            }         
+         )
+        @filter.should be_valid
+        @filter.words.should == ['second word']
+      end
+    end
+  end
+
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+
+  describe "after a rule is created" do
+    # xit "There is nothing to do here"
+  end
+  
+  describe "processing the rule" do
+    before(:each) do
+      @filter = RulesEngine::Rule::<%=rule_class%>.new
+      @filter.stub!(:words).and_return(["found", "word"])
+    end
+    
+    it "should do nothing if there is no tweet" do      
+      @filter.process(1001, {}).outcome.should == RulesEngine::Rule::Outcome::NEXT
+    end        
+  
+    it "should do nothing if there is no match" do
+      @filter.process(@job, {:tweet => "not here"}).outcome.should == RulesEngine::Rule::Outcome::NEXT
+    end        
+    
+    describe "a match found" do
+      before(:each) do
+        @matched_data = {:tweet => "here is a word"}
+      end
+      
+      it "should add the match to the data" do              
+        @filter.process(@job, @matched_data)
+        @matched_data[:match].should == "word"
+      end        
+      
+      it "should audit the match" do  
+        RulesEngine::Process.auditor.should_receive(:audit) do |process_id, message, code|
+          process_id.should == 1001
+          message.should =~ /word$/
+        end
+        @filter.process(1001, @matched_data)
+      end        
+      
+      it "should return stop_success" do
+        @filter.process(1001, @matched_data).outcome.should == RulesEngine::Rule::Outcome::STOP_SUCCESS
+      end
+    end    
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rules_engine_templates
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Chris Douglas
@@ -48,16 +48,26 @@ files:
 - README.rdoc
 - VERSION
 - lib/rules_engine_templates.rb
-- rails_generators/manifests/rule_tweet_filter.rb
-- rails_generators/manifests/rule_tweet_filter.yml
+- rails_generators/manifests/tweet_filter.rb
+- rails_generators/manifests/tweet_filter.yml
 - rails_generators/rules_engine_templates_generator.rb
+- rails_generators/templates/app/rules/tweet_filter.rb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_edit.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_help.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_new.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_script.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_title.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_word.html.erb
+- rails_generators/templates/app/views/re_rule_definitions/tweet_filter/_words.html.erb
+- rails_generators/templates/spec/lib/rules/rule_tweet_filter_spec.rb
+- rails_generators/templates/spec/lib/rules/tweet_filter_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/dougochris/rules_engine_templates
 licenses: []
 
-post_install_message: "\n      *** RUN script/generate rules_engine_templates\n    "
+post_install_message: "\n      *** RUN script/generate rules_engine_templates help\n    "
 rdoc_options: 
 - --charset=UTF-8
 require_paths: 

data/rails_generators/manifests/rule_tweet_filter.rb

@@ -1,29 +0,0 @@
-class RuleTweetFilterManifest
-  def self.populate_record(m)
-
-    %W(
-      app/rules
-      app/views/re_rule_definitions/rule_tweet_filter
-      lib/tasks
-      spec/lib/rules
-    ).each do |dirname|
-      m.directory dirname
-    end
-
-    %W(
-      app/rules/rule_tweet_filter.rb
-      app/views/re_rule_definitions/rule_tweet_filter/_edit.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_help.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_new.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_script.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_title.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_word.html.erb
-      app/views/re_rule_definitions/rule_tweet_filter/_words.html.erb
-      spec/lib/rules/rule_tweet_filter_spec.rb
-    ).each do |filename|
-      m.file filename, filename
-    end
-
-
-  end
-end

data/rails_generators/manifests/rule_tweet_filter.yml

@@ -1,12 +0,0 @@
-directories :
-  - app/rules
-  - app/views/re_rule_definitions/rule_tweet_filter
-  - spec/lib/rules
-  - lib/tasks
-  
-contents :
-  - app/views/re_rule_definitions/rule_tweet_filter
-  
-files :
-  - app/rules/rule_tweet_filter.rb
-  - spec/lib/rules/rule_tweet_filter_spec.rb