rules_engine 0.1.1 → 0.1.3

data/README.textile

@@ -37,7 +37,7 @@ Rails::Initializer.run do |config|
   config.gem 'will_paginate'
   config.gem 'acts_as_list'
   ...
-  config.active_record.observers = :re_pipeline_activated_observer
+  config.active_record.observers = :re_workflow_activated_observer
   ...
 end
 
@@ -89,25 +89,25 @@ h3. 5. Add the Routes
 ActionController::Routing::Routes.draw do |map|
   ...
   ### remove map.root if already defined
-  map.root :controller => 're_pipelines', :action => 'template'
-  ### map.preview '/preview', :controller => 're_pipelines', :action => 'template'
-  map.resources :re_pipelines, 
+  map.root :controller => 're_workflows', :action => 'template'
+  ### map.preview '/preview', :controller => 're_workflows', :action => 'template'
+  map.resources :re_workflows, 
                         :collection => {:lookup => :get, 
                                         :activate_all => :put}, 
                         :member => {:change => :get, 
                                         :activate => :put, 
                                         :deactivate => :put, 
-                                        :revert => :put} do |re_pipeline|  
-  re_pipeline.resources :re_rules, 
-                            :controller => :re_pipeline_rules, 
+                                        :revert => :put} do |re_workflow|  
+  re_workflow.resources :re_rules, 
+                            :controller => :re_workflow_rules, 
                             :collection => {:help => :get, :error => :get}, 
                             :member => {:move_up => :put, :move_down => :put}
-    re_pipeline.resources :re_jobs, 
-                            :controller => :re_pipeline_jobs, 
+    re_workflow.resources :re_processs, 
+                            :controller => :re_workflow_processs, 
                             :only => [:index]
   end
 
-  map.resources :re_jobs, :only => [:index, :show]
+  map.resources :re_processs, :only => [:index, :show]
   ...
 end  
 </pre>
@@ -173,9 +173,9 @@ h3. 10. Start the Server
 
 <pre>
 ./script/server
-open http://localhost:3000/re_pipelines
+open http://localhost:3000/re_workflows
 </pre>
 
-h3. 11. Create Pipelines and Rules
+h3. 11. Create Workflows and Rules
 
 Watch the demo at "TODO":http://www.r3ef.com/

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/rules_engine.rb

@@ -1,22 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + "/rules_engine/discovery")
 require File.expand_path(File.dirname(__FILE__) + "/rules_engine/rule")
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine/cache")
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine/job")
 require File.expand_path(File.dirname(__FILE__) + "/rules_engine/rule_outcome")
 
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/form_styles")
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/form_fields")
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/form_builder")
-
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/buttons")
-
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/boxes")
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/navigate")
-
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/alerts")
-
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/defer")
-
-require File.expand_path(File.dirname(__FILE__) + "/rules_engine_view/model_loader")
-
-
+require File.expand_path(File.dirname(__FILE__) + "/rules_engine/cache")
+require File.expand_path(File.dirname(__FILE__) + "/rules_engine/publish/publisher")
+require File.expand_path(File.dirname(__FILE__) + "/rules_engine/process/auditor")
+require File.expand_path(File.dirname(__FILE__) + "/rules_engine/process/runner")

data/lib/rules_engine/cache.rb

@@ -19,7 +19,7 @@ module RulesEngine
 
       def cache_store
         @cache_store 
-      end      
+      end
     end
     
   end

data/lib/rules_engine/discovery.rb

@@ -1,25 +1,34 @@
 module RulesEngine
   class Discovery
     
-    RULES_PATH = File.expand_path(File.join(RAILS_ROOT, '/app/rules'))
+    @rules_path = nil
     @rule_classes = nil
     @rule_groups = nil
         
     class << self
+      def rules_path= path
+        @rules_path = path
+      end  
+
+      def rules_path
+        return @rules_path if @rules_path
+        return File.expand_path(File.join(Rails.root, '/app/rules')) if defined?(Rails) && Rails.root
+        throw Exception.new("Rails.root or rules_path not defined") 
+      end  
+      
       def discover!
         @rule_classes = []
         @rule_groups = {}
         
-        Dir.glob("#{ RULES_PATH }/**/*.rb").each do |rule| 
-          require rule
-          
+        Dir.glob("#{rules_path}/**/*.rb").each do |rule| 
+          Kernel.load rule
+
           rule_class = Kernel.const_get(File.basename(rule, '.rb').classify)
           @rule_classes << rule_class
           
           group = rule_class.options[:group]
           @rule_groups[group] = [] unless @rule_groups.include?(group)
           @rule_groups[group] << rule_class
-          
         end  
         
         @rule_classes.sort! { |left, right| return left.to_s < right.to_s}

data/lib/rules_engine/process/auditor.rb

@@ -0,0 +1,62 @@
+module RulesEngine  
+  module Process
+    
+    AUDIT_NONE    =   0
+    AUDIT_INFO    =   1
+    AUDIT_SUCCESS =   2
+    AUDIT_FAILURE =   3
+
+    autoload :DbAuditor, 'rules_engine/process/auditor/db_auditor'
+    
+    class << self
+
+      def auditor=(auditor_options)
+        type, *parameters = *([ auditor_options ].flatten)
+
+        case type
+        when Symbol
+          auditor_class_name = type.to_s.camelize
+          auditor_class = RulesEngine::Process.const_get(auditor_class_name)
+          @auditor = auditor_class.new(*parameters)
+        when nil
+          @auditor = Auditor.new
+        else
+          @auditor = auditor_options
+        end
+      end
+
+      def auditor
+        @auditor ||= Auditor.new 
+      end      
+    end
+    
+    class Auditor
+      attr_accessor :audit_level
+
+      def audit(process_id, message, code = RulesEngine::Process::AUDIT_INFO)
+        if perform_audit?(code)
+          if defined?(Rails) && Rails.logger 
+            case code
+            when RulesEngine::Process::AUDIT_FAILURE
+              Rails.logger.error("#{'*' * 5} #{process_id}, #{code}, #{message}")
+            else # when RulesEngine::Process::AUDIT_INFO, RulesEngine::Process::AUDIT_SUCCESS
+              Rails.logger.info("#{'*' * 5} #{process_id}, #{code}, #{message}")
+            end
+          else  
+            $stderr.puts("#{'*' * 5} #{process_id}, #{code}, #{message}")
+          end
+        end   
+      end
+    
+      def history(process_id, options = {})
+        {
+          "audits" => []
+        }  
+      end
+    
+      def perform_audit?(code)
+        audit_level.nil? || (audit_level != RulesEngine::Process::AUDIT_NONE && code >= audit_level)
+      end
+    end  
+  end
+end

data/lib/rules_engine/process/auditor/db_auditor.rb

@@ -0,0 +1,48 @@
+module RulesEngine
+  module Process
+    class ReProcessAudit < ActiveRecord::Base
+  
+      validates_presence_of :code
+    
+      named_scope :by_process_id, lambda {|process_id| {:conditions => ['process_id = ?', process_id]} }
+      named_scope :order_created_at, lambda {|order| {:order => "created_at #{order}, id #{order}"} }
+      
+      def self.history(process_id, options = {})
+        klass = self
+        klass = klass.by_process_id(process_id)
+        klass = klass.order_created_at('ASC')
+        klass.find(:all)
+      end
+    end
+
+    class DbAuditor < Auditor
+
+      def initialize(*options)        
+      end
+      
+      def audit(process_id, message, code = RulesEngine::Process::AUDIT_INFO)
+        if perform_audit?(code)
+          ReProcessAudit.create({
+            :process_id => process_id,
+            :created_at => Time.now,  
+            :code => code,
+            :message => message});
+        end  
+      end
+  
+      def history(process_id, options ={})
+        re_process_audits = ReProcessAudit.history(process_id, options)
+        {
+          "audits" => re_process_audits.map do |re_process_audit| 
+            {
+              "process_id" => re_process_audit.process_id, 
+              "created_at" => re_process_audit.created_at.utc.to_s, 
+              "code" => re_process_audit.code, 
+              "message" => re_process_audit.message
+            }
+          end
+        }                          
+      end    
+    end  
+  end  
+end

data/lib/rules_engine/process/runner.rb

@@ -0,0 +1,147 @@
+module RulesEngine  
+  module Process
+    
+    PROCESS_STATUS_NONE = 0
+    PROCESS_STATUS_RUNNING = 1
+    PROCESS_STATUS_SUCCESS = 2
+    PROCESS_STATUS_FAILURE = 3    
+  
+    autoload :DbRunner, 'rules_engine/process/runner/db_runner'
+    # autoload :FileProcessRunner, 'rules_engine/process/runner/file_process_runner'
+    
+    class << self
+      def runner=(runner_options)
+        type, *parameters = *([ runner_options ].flatten)
+
+        case type
+        when Symbol
+          runner_class_name = type.to_s.camelize
+          runner_class = RulesEngine::Process.const_get(runner_class_name)
+          @runner = runner_class.new(*parameters)
+        when nil
+          @runner = nil
+        else
+          @runner = runner_options
+        end
+      end
+
+      def runner
+        throw "RulesEngine::Process::Runner required" unless @runner
+        @runner 
+      end      
+    end
+    
+    class Runner      
+      
+      @@max_workflows = 500
+      
+      def create
+        throw "RulesEngine::Process::Runner required"
+        # 0
+      end
+      
+      def run(process_id, plan, data = {})
+        _run_plan(process_id, plan, data)
+      end
+      
+      def status(process_id)
+        throw "RulesEngine::Process::Runner required"
+      end      
+      
+      def history(plan_code = nil, options = {})
+        throw "RulesEngine::Process::Runner required"
+        # {
+        #   :proceses => []
+        # }
+      end
+      
+      protected
+        def _run_plan(process_id, plan, data = {})
+        
+          RulesEngine::Process.auditor.audit(process_id, "Plan : #{plan["code"]} : started", RulesEngine::Process::AUDIT_INFO)
+
+          workflow_count = 0
+          done = false
+          error = false
+        
+          first_workflow = plan['first_workflow']
+          if (first_workflow.blank? || plan["workflow_#{first_workflow}"].nil?)
+            RulesEngine::Process.auditor.audit(process_id, "First Workflow : #{first_workflow} : missing", RulesEngine::Process::AUDIT_FAILURE)
+            error = done = true 
+          end
+
+          current_workflow = first_workflow
+          next_workflow = ""
+          while (!done && workflow_count < @@max_workflows)
+            workflow_count += 1 
+        
+            RulesEngine::Process.auditor.audit(process_id, "Workflow : #{current_workflow} : started", RulesEngine::Process::AUDIT_INFO)
+          
+            workflow = plan["workflow_#{current_workflow}"]
+            if workflow.nil?
+              RulesEngine::Process.auditor.audit(process_id, "Workflow : #{current_workflow} : not found", RulesEngine::Process::AUDIT_FAILURE) 
+              error = done = true 
+              break 
+            end
+          
+            workflow["rules"].each do | workflow_rule |
+              rule_class = RulesEngine::Discovery.rule_class(workflow_rule["rule_class_name"])
+              unless rule_class
+                RulesEngine::Process.auditor.audit(process_id, "Rule : #{workflow_rule["rule_class_name"]} : not found", RulesEngine::Process::AUDIT_FAILURE) 
+                error = done = true 
+                break 
+              end  
+              rule = rule_class.new
+              rule.data = workflow_rule["data"]
+            
+              RulesEngine::Process.auditor.audit(process_id, "Rule : #{rule.title} : starting")                    
+              rule_outcome = rule.process(process_id, data)
+              RulesEngine::Process.auditor.audit(process_id, "Rule : #{rule.title} : finished")
+
+              if !rule_outcome.nil? && rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_SUCCESS
+                RulesEngine::Process.auditor.audit(process_id, "Workflow : #{current_workflow} : stop success", RulesEngine::Process::AUDIT_SUCCESS)
+                done = true 
+                break
+              end
+        
+              if !rule_outcome.nil? && rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_STOP_FAILURE
+                RulesEngine::Process.auditor.audit(process_id, "Workflow : #{current_workflow} : stop failure", RulesEngine::Process::AUDIT_FAILURE)
+                error = done = true 
+                break
+              end
+        
+              if !rule_outcome.nil? && rule_outcome.outcome == RulesEngine::RuleOutcome::OUTCOME_START_WORKFLOW
+                RulesEngine::Process.auditor.audit(process_id, "Workflow : #{current_workflow} : start next workflow - #{rule_outcome.workflow_code}", RulesEngine::Process::AUDIT_INFO)
+                next_workflow = rule_outcome.workflow_code
+                break
+              end
+            end          
+          
+            if next_workflow.blank?
+              current_workflow = workflow["next_workflow"]
+            else
+              current_workflow = next_workflow  
+            end            
+          
+            if current_workflow.blank?
+              done = true 
+              break
+            end
+          end  
+
+          if workflow_count >= @@max_workflows
+            RulesEngine::Process.auditor.audit(process_id, "Plan : #{plan["code"]} : error - Maximum workflow depth #{@@max_workflows} exceeded", RulesEngine::Process::PROCESS_STATUS_FAILURE)
+            error = true
+          end
+
+          if error  
+            RulesEngine::Process.auditor.audit(process_id, "Plan : #{plan["code"]} : failure", RulesEngine::Process::AUDIT_FAILURE)
+          else  
+            RulesEngine::Process.auditor.audit(process_id, "Plan : #{plan["code"]} : success", RulesEngine::Process::AUDIT_SUCCESS)
+          end
+      
+          !error
+        end
+    end  
+  end
+end

data/lib/rules_engine/process/runner/db_runner.rb

@@ -0,0 +1,78 @@
+require 'will_paginate'
+
+module RulesEngine
+  module Process
+    
+    class ReProcessRun < ActiveRecord::Base
+      validates_presence_of :process_status
+      
+      named_scope :by_plan_code, lambda {|plan_code| {:conditions => ['plan_code = ?', plan_code]} }
+      named_scope :by_process_status_gt, lambda {|process_status| {:conditions => "process_status > #{process_status}"} }
+      named_scope :order_started_at, lambda {|order| {:order => "started_at #{order}, id #{order}"} }
+      
+      def self.history(plan_code, options = {})
+
+        klass = self
+        klass = klass.by_plan_code(plan_code) unless plan_code.nil?
+        klass = klass.by_process_status_gt(RulesEngine::Process::PROCESS_STATUS_NONE)
+        klass = klass.order_started_at('DESC')
+        
+        klass.paginate({:page => 1, :per_page => 10}.merge(options))
+      end
+    end
+    
+      
+    class DbRunner < Runner
+
+      def initialize(*options)        
+      end
+      
+      def create()
+        ReProcessRun.create(:process_status => RulesEngine::Process::PROCESS_STATUS_NONE).id
+      end
+      
+      def run(process_id, plan, data = {})
+        re_process = ReProcessRun.find_by_id(process_id)
+
+        if re_process.nil?
+          RulesEngine::Process.auditor.audit(process_id, "Process missing", RulesEngine::Process::AUDIT_FAILURE)
+          return false
+        end
+        
+        re_process.update_attributes(:plan_code => plan["code"], :plan_version => plan["version"], :started_at => Time.now.utc, :process_status => RulesEngine::Process::PROCESS_STATUS_RUNNING)  
+        
+        success = _run_plan(process_id, plan, data)
+        
+        re_process.update_attributes(:finished_at => Time.now.utc, :process_status => success ? RulesEngine::Process::PROCESS_STATUS_SUCCESS : RulesEngine::Process::PROCESS_STATUS_FAILURE)
+      
+        success
+      end
+      
+      def status(process_id)
+        re_process = ReProcessRun.find_by_id(process_id)
+        re_process ? re_process.process_status : RulesEngine::Process::PROCESS_STATUS_NONE
+      end      
+   
+   
+      def history(plan_code = nil, options = {})
+        
+        re_process_runs = ReProcessRun.history(plan_code, options)
+
+        {  "next_page" => re_process_runs.next_page, 
+           "previous_page" => re_process_runs.previous_page,
+           "processes" => re_process_runs.map do |re_process_run| 
+              { 
+                "process_id" => re_process_run.id,  
+                "plan_code" => re_process_run.plan_code, 
+                "plan_version" => re_process_run.plan_version, 
+                "process_status" => re_process_run.process_status,  
+                "started_at" => re_process_run.started_at.nil? ? nil : re_process_run.started_at.utc.to_s, 
+                "finished_at" =>re_process_run.finished_at.nil? ? nil : re_process_run.finished_at.utc.to_s
+              }
+            end
+        }
+      end
+      
+    end  
+  end  
+end