rules_engine 0.1.1 → 0.1.3

data/rails_generators/templates/app/models/re_plan_workflow.rb

@@ -0,0 +1,10 @@
+class RePlanWorkflow < ActiveRecord::Base
+  default_scope :order => 'position'
+  belongs_to :re_plan
+  belongs_to :re_workflow
+  acts_as_list :scope => :re_plan 
+
+  named_scope :order_plan_title, :order => 're_plans.title ASC'
+  named_scope :by_workflow_id, lambda { |workflow_id| {:conditions => ["re_workflow_id = ?", workflow_id] }}
+  
+end

data/rails_generators/templates/app/models/re_rule.rb

@@ -1,11 +1,9 @@
 class ReRule < ActiveRecord::Base
-  belongs_to :re_pipeline
-  acts_as_list :scope => :re_pipeline
-
+  belongs_to :re_workflow
   has_many  :re_rule_expected_outcomes, :dependent => :destroy, :order => "outcome ASC"
-  has_many  :re_job_audits
+  acts_as_list :scope => :re_workflow
       
-  validates_associated  :re_pipeline
+  validates_associated  :re_workflow
   validates_presence_of :rule_class_name
 
   default_scope :order => 're_rules.position ASC'
@@ -14,6 +12,25 @@ class ReRule < ActiveRecord::Base
   after_create :after_create_rule
   before_destroy :before_destroy_rule
 
+  def before_save_rule
+    return if rule.nil?
+    self.title = rule.title
+    self.summary = rule.summary
+    self.data = rule.data
+    
+    self.re_rule_expected_outcomes = (rule.expected_outcomes || []).map { |expected_outcome| ReRuleExpectedOutcome.new(expected_outcome) }
+    
+    re_workflow.changed! if changes.detect { |change| !ignore_attributes.include?(change[0])}    
+  end
+
+  def after_create_rule
+    rule.after_add_to_workflow(self.re_workflow.code) unless rule.nil?
+  end
+
+  def before_destroy_rule
+    rule.before_remove_from_workflow(self.re_workflow.code) unless rule.nil?
+  end
+
   def validate
     if self.rule.nil?
       errors.add("rule_class", "not found") 
@@ -21,36 +38,25 @@ class ReRule < ActiveRecord::Base
       errors.add(self.rule_class_name, "not valid") 
     end
   end
-    
-  def copy! re_rule
-    activated_attrs = re_rule.attributes
-    ignore_attributes.each{|key| activated_attrs.delete(key)}
 
-    activated_attrs.each do |key, value|
-      self[key] = value
-    end
-    
-    self.re_rule_expected_outcomes = re_rule.re_rule_expected_outcomes.map { |rule_expected_outcome| ReRuleExpectedOutcome.new.copy!(rule_expected_outcome) }
+  def publish
+    { "rule_class_name" => rule_class_name, 
+      "title" => title, 
+      "summary" => summary,
+      "data" => data
+    }
+  end  
+
+  def revert!(rule_data)
+    self.rule_class_name = rule_data["rule_class_name"]
+    self.title = rule_data["title"]
+    self.summary = rule_data["summary"]
+    self.data = rule_data["data"]
     
+    self.re_rule_expected_outcomes = (rule.expected_outcomes || []).map { |expected_outcome| ReRuleExpectedOutcome.new(expected_outcome) }
     self
-  end
-
-  def equals? re_rule
-    activated_attrs = re_rule.attributes
-    ignore_attributes.each{|key| activated_attrs.delete(key)}
-
-    activated_attrs.each do |key, value|
-      return false unless self[key] == value
-    end
-    
-    return false unless self.re_rule_expected_outcomes.length == re_rule.re_rule_expected_outcomes.length
-    self.re_rule_expected_outcomes.each_with_index do |rule_expected_outcome, index|
-      return false unless rule_expected_outcome.equals?(re_rule.re_rule_expected_outcomes[index])
-    end
-    
-    true
-  end
-
+  end  
+  
   def rule
     return @rule unless @rule.nil?
     rule_class = RulesEngine::Discovery.rule_class(self.rule_class_name)
@@ -65,37 +71,18 @@ class ReRule < ActiveRecord::Base
     rule.attributes = params
   end
 
-  def before_save_rule
-    return if rule.nil?
-    self.title = rule.title
-    self.summary = rule.summary
-    self.data = rule.data
-    
-    self.re_rule_expected_outcomes = (rule.expected_outcomes || []).map { |expected_outcome| ReRuleExpectedOutcome.new(expected_outcome) }
-  end
-
-  def after_create_rule
-    return if rule.nil?
-    rule.after_add_to_pipeline(self.re_pipeline_id, self.id)
-  end
-
-  def before_destroy_rule
-    return if rule.nil?
-    rule.before_remove_from_pipeline(self.re_pipeline_id, self.id)
-  end
-
   def rule_error
-    return "#{title} class #{rule_class_name} invalid" if rule.nil?
+    return "class #{rule_class_name} missing" if rule.nil?
     return "#{rule.errors.values.join(', ')}" unless rule.valid?
 
     re_rule_expected_outcomes.each do |re_rule_expected_outcome|
-      next if re_rule_expected_outcome.pipeline_code.blank?      
+      next if re_rule_expected_outcome.workflow_code.blank?      
 
-      re_pipeline = RePipeline.find_by_code(re_rule_expected_outcome.pipeline_code)
-      return "#{re_rule_expected_outcome.pipeline_code} missing" if re_pipeline.nil?
+      re_workflow = ReWorkflow.find_by_code(re_rule_expected_outcome.workflow_code)
+      return "#{re_rule_expected_outcome.workflow_code} missing" if re_workflow.nil?
       
-      pipeline_error = re_pipeline.pipeline_error
-      return "#{re_rule_expected_outcome.pipeline_code} invalid" unless re_pipeline.pipeline_error.blank?
+      workflow_error = re_workflow.workflow_error
+      return "#{re_rule_expected_outcome.workflow_code} invalid" unless re_workflow.workflow_error.blank?
     end
     
     nil
@@ -113,13 +100,13 @@ class ReRule < ActiveRecord::Base
     re_rule_expected_outcomes.detect{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE }
   end
 
-  def re_rule_expected_outcomes_start_pipeline
-    re_rule_expected_outcomes.select{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE }
+  def re_rule_expected_outcomes_start_workflow
+    re_rule_expected_outcomes.select{ |re_rule_expected_outcome| re_rule_expected_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW }
   end
 
   protected
     def ignore_attributes 
-      [self.class.primary_key, self.class.inheritance_column, "re_pipeline_id", "created_at", "updated_at"]
+      [self.class.primary_key, self.class.inheritance_column, "re_workflow_id", "created_at", "updated_at"]
     end
 
 end

data/rails_generators/templates/app/models/re_rule_expected_outcome.rb

@@ -3,28 +3,10 @@ class ReRuleExpectedOutcome < ActiveRecord::Base
 
   validates_associated  :re_rule
   validates_presence_of :outcome  
-  def validate    
-    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE && pipeline_code.blank?
-      errors.add(:pipeline_code, "pipeline code required")
-    end
-  end
 
-  def copy! re_rule_expected_outcome    
-    self.outcome = re_rule_expected_outcome.outcome
-    self.pipeline_code = re_rule_expected_outcome.pipeline_code
-    self
-  end
-
-  def equals? re_rule_expected_outcome    
-    if outcome != re_rule_expected_outcome.outcome
-      return false
+  def validate    
+    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW && workflow_code.blank?
+      errors.add(:workflow_code, "workflow code required")
     end
-      
-    if outcome == RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE
-      return false unless pipeline_code == re_rule_expected_outcome.pipeline_code
-      #TODO check the pipeline equals the pipeline code
-    end  
-    
-    return true    
   end
 end

data/rails_generators/templates/app/models/re_workflow.rb

@@ -0,0 +1,61 @@
+class ReWorkflow < ActiveRecord::Base
+  has_many :re_plan_workflows, :dependent => :destroy
+  has_many :re_plans, :through => :re_plan_workflows, :order => 're_plan_workflows.position'
+  has_many :re_rules, :foreign_key => :re_workflow_id, :dependent => :destroy, :order => :position
+  
+  validates_presence_of   :code
+  validates_presence_of   :title
+  validates_uniqueness_of :code, :case_sensitive => false, :message=>"alread taken."
+  
+  named_scope :order_code,  :order => 're_workflows.code ASC'
+  named_scope :order_title, :order => 're_workflows.title ASC'
+  
+  before_save :before_save_workflow
+
+  def before_save_workflow
+    self.changed! if changes.detect { |change| !ignore_attributes.include?(change[0])}    
+  end  
+
+  def code=(new_code)
+    self[:code] = new_code.strip.downcase.gsub(/[^a-zA-Z0-9]+/i, '_') if new_code && new_record?
+  end
+  
+  def publish
+    { "code" => code, 
+      "title" => title, 
+      "description" => description,
+      "rules" => re_rules.map{ | re_rule | re_rule.publish }
+    }
+  end  
+
+  def revert!(rule_data)
+    self.code = rule_data["code"]
+    self.title = rule_data["title"]
+    self.description = rule_data["description"]
+    
+    self.re_rules = (rule_data["rules"] || []).map { |rule| ReRule.new.revert!(rule) }
+    self
+  end  
+
+  def workflow_error
+    return 'rules required' if re_rules.empty?
+    return 'error within rules' if re_rules.any? { | re_rule | re_rule.rule_error }    
+    nil
+  end
+
+  
+  def changed!
+    re_plans.each do |re_plan|
+      re_plan.changed!
+    end
+  end
+  
+  def has_plan? re_plan
+    re_plans.include? re_plan
+  end
+  
+  protected
+    def ignore_attributes 
+      [self.class.primary_key, self.class.inheritance_column, "created_at", "updated_at"]
+    end
+end

data/rails_generators/templates/app/rules/{complex_rule.rb → rule_complex.rb}

@@ -1,18 +1,18 @@
-class <%=rule_class%>Rule < RulesEngine::Rule
+class <%=rule_class%> < RulesEngine::Rule
 
   attr_reader :words
-  attr_reader :pipeline_action
-  attr_reader :pipeline
+  attr_reader :workflow_action
+  attr_reader :workflow
 
   ##################################################################
   # class options
   self.options = 
     {
-      :group => '<%=rule_class%>',
-      :display_name => '<%=rule_class%>',    
-      :help_partial => '/re_rule_definitions/<%=rule_name%>_rule/help',
-      :new_partial => '/re_rule_definitions/<%=rule_name%>_rule/new',
-      :edit_partial => '/re_rule_definitions/<%=rule_name%>_rule/edit'
+      :group => 'General',
+      :display_name => '<%=rule_class%> Rule',    
+      :help_partial => '/re_rule_definitions/<%=rule_name%>/help',
+      :new_partial => '/re_rule_definitions/<%=rule_name%>/new',
+      :edit_partial => '/re_rule_definitions/<%=rule_name%>/edit'
     } 
   
   ##################################################################
@@ -21,10 +21,10 @@ class <%=rule_class%>Rule < RulesEngine::Rule
     if data.nil?
       @title = nil
       @words = nil
-      @pipeline_action = 'continue'
-      @pipeline = nil
+      @workflow_action = 'continue'
+      @workflow = nil
     else
-      @title, @words, @pipeline_action, @pipeline = ActiveSupport::JSON.decode(data)
+      @title, @words, @workflow_action, @workflow = ActiveSupport::JSON.decode(data)
     end  
   end
   
@@ -39,19 +39,19 @@ class <%=rule_class%>Rule < RulesEngine::Rule
   end
   
   def data
-    [title, words, pipeline_action, pipeline].to_json
+    [title, words, workflow_action, workflow].to_json
   end
   
   def expected_outcomes
-    case pipeline_action    
+    case workflow_action    
     when 'next'
       [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]
     when 'stop_success'
       [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS]
     when 'stop_failure'
       [:outcome => RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE]
-    when 'start_pipeline'
-      [:outcome => RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, :pipeline_code => pipeline]
+    when 'start_workflow'
+      [:outcome => RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW, :workflow_code => workflow]
     else
       [:outcome => RulesEngine::RuleOutcome::OUTCOME_NEXT]  
     end
@@ -73,8 +73,8 @@ class <%=rule_class%>Rule < RulesEngine::Rule
       end  
     end
     
-    @pipeline_action = param_hash[:<%=rule_name%>_pipeline_action] || 'continue'
-    @pipeline = param_hash[:<%=rule_name%>_pipeline] || ''
+    @workflow_action = param_hash[:<%=rule_name%>_workflow_action] || 'continue'
+    @workflow = param_hash[:<%=rule_name%>_workflow] || ''
   end
   
   ##################################################################
@@ -83,41 +83,41 @@ class <%=rule_class%>Rule < RulesEngine::Rule
     @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?    
-    @errors[:<%=rule_name%>_pipeline] = "Pipeline required" if pipeline_action == 'start_pipeline' && pipeline.blank?
+    @errors[:<%=rule_name%>_workflow] = "Workflow required" if workflow_action == 'start_workflow' && workflow.blank?
     return @errors.empty?
   end
 
   ##################################################################
-  # callbacks when the rule is added and removed from a pipeline
-  def after_add_to_pipeline(re_pipeline_id, re_rule_id)
+  # callbacks when the rule is added and removed from a workflow
+  def after_add_to_workflow(workflow_code)
   end
   
-  def before_remove_from_pipeline(re_pipeline_id, re_rule_id)
+  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 :sentence
+  # it gets the data parameter :tweet
   # it sets the data parameter :match
-  def process(job, data)
-    sentence = data[:sentence] || data["sentence"]    
-    if sentence.blank?
+  def process(process_id, data)
+    tweet = data[:tweet] || data["tweet"]    
+    if tweet.blank?
       return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_NEXT) 
     end
     
     words.each do |word|
-      if /#{word}/i =~ sentence        
-        job.audit("#{title} Found #{word}", ReJobAudit::AUDIT_INFO)
+      if /#{word}/i =~ tweet        
+        RulesEngine::Process.auditor.audit(process_id, "#{title} Found #{word}", RulesEngine::Process::AUDIT_INFO)
         data[:match] = word
         
-        case pipeline_action
+        case workflow_action
         when 'stop_success'
           return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS)
         when 'stop_failure'
           return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)
-        when 'start_pipeline'
-          return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, pipeline)
+        when 'start_workflow'
+          return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW, workflow)
         else #'next'
           return RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_NEXT)
         end

data/rails_generators/templates/app/rules/{simple_rule.rb → rule_simple.rb}

@@ -1,15 +1,15 @@
-class <%=rule_class%>Rule < RulesEngine::Rule
+class <%=rule_class%> < RulesEngine::Rule
 
   attr_reader :description
   ##################################################################
   # class options
   self.options = 
     {
-      :group => '<%=rule_class%>',
-      :display_name => '<%=rule_class%>',    
-      :help_partial => '/re_rule_definitions/<%=rule_name%>_rule/help',
-      :new_partial => '/re_rule_definitions/<%=rule_name%>_rule/new',
-      :edit_partial => '/re_rule_definitions/<%=rule_name%>_rule/edit'
+      :group => 'General',
+      :display_name => '<%=rule_class%> Rule',    
+      :help_partial => '/re_rule_definitions/<%=rule_name%>/help',
+      :new_partial => '/re_rule_definitions/<%=rule_name%>/new',
+      :edit_partial => '/re_rule_definitions/<%=rule_name%>/edit'
     } 
   
   ##################################################################
@@ -30,7 +30,7 @@ class <%=rule_class%>Rule < RulesEngine::Rule
   end
   
   def summary
-    description
+    description || "Does Nothing"
   end
   
   def data
@@ -55,26 +55,25 @@ class <%=rule_class%>Rule < RulesEngine::Rule
   def valid?
     @errors = {}
     @errors[:<%=rule_name%>_title] = "Title required" if title.blank?    
-    @errors[:<%=rule_name%>_description] = "Description required" if description.blank?    
     return @errors.empty?
   end
 
   ##################################################################
-  # callbacks when the rule is added and removed from a pipeline
-  def after_add_to_pipeline(re_pipeline_id, re_rule_id)
+  # callbacks when the rule is added and removed from a workflow
+  def after_add_to_workflow(workflow_code)
   end
   
-  def before_remove_from_pipeline(re_pipeline_id, re_rule_id)
+  def before_remove_from_workflow(workflow_code)
   end
   
   ##################################################################
   # execute the rule
   # this rule does nothing
-  def process(job, data)
-    job.audit("Inside Rule #{title}", ReJobAudit::AUDIT_INFO)                        
+  def process(process_id, data)
+    RulesEngine::Process.auditor.audit(process_id, "Inside Rule #{title}", RulesEngine::Process::AUDIT_INFO)                        
     # RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS)
     # RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE)
-    # RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_START_PIPELINE, 'next_pipeline')
+    # RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW, 'next_workflow')
     RulesEngine::RuleOutcome.new(RulesEngine::RuleOutcome::OUTCOME_NEXT)
   end  
 end