icentris-rules 0.9

data/app/rules/pyr_rules/event_concerns.rb

@@ -0,0 +1,23 @@
+module PyrRules
+	module EventConcerns
+
+		
+
+		def self.included(base)
+			_register(base)
+		end
+
+		def self._register(klazz)
+			self.registered_classes ||= []
+			self.registered_classes << klazz if !self.registered_classes.index(klazz)
+		end
+
+		def build_event_payload(event_type, class_name, action, extras={})
+				payload = { type: event_type, klazz: self.class.name, action: action, id: self.id, data: self, 
+							user: Thread.current[:user] }.merge(extras)
+				ActiveSupport::Notifications.instrument("PyrRules_#{event_type}", payload )
+
+		end
+
+	end
+end

data/app/rules/pyr_rules/event_config_loader.rb

@@ -0,0 +1,97 @@
+module PyrRules
+  class EventConfigLoader
+    @@events_dictionary ||= nil
+    
+    def self.reload_events_dictionary
+      puts "Reloading EventsDictionary"
+      @@events_dictionary = nil
+      events_list(true)
+    end
+
+    # A simple list containing every Event known to the system...
+    def self.events_list(refresh = false)
+      PyrRules::EventConfigLoader.events_dictionary(refresh).map do |et,et_v| 
+        et_v.map do |k,v| 
+          v[:actions].map do |a| 
+            "#{k}::#{a}"
+          end
+        end
+      end.flatten
+    end
+
+
+    def self.events_dictionary(refresh = false)
+      return @@events_dictionary if @@events_dictionary
+      # Force load of models and controllers when eager class loading isn't enabled by default
+      # http://stackoverflow.com/questions/516579/is-there-a-way-to-get-a-collection-of-all-the-models-in-your-rails-app      
+      puts "DEBUG[icentris-rules] Building Events Dictionary"
+      start_time = Time.new
+      if PyrRules.active_record
+        ActiveRecord::Base.send :include, PyrRules::ModelEventEmitter
+        model_classes = ActiveRecord::Base.connection.tables.collect{|t| t.classify.constantize rescue nil }.compact
+        model_classes.each do |mc| 
+          puts "PyrRules::EventConfigLoader loading #{mc.to_s}"
+          mc.class_eval {}
+        end
+      end
+      
+      if Rails.env.development? 
+          PyrRules.development_model_paths.each do |path|
+          puts "PyrRules::EventConfigLoader - scanning models via #{path}"
+          Dir.glob(path).sort.each do |entry|
+            puts "   -  Loading model: #{entry}"
+            require_dependency "#{entry}"
+          end
+        end
+      end
+
+      puts "\n\nPyrRules::ModelEventEmitter.registered_classes = #{PyrRules::ModelEventEmitter.registered_classes}\n\n"
+      @@events_dictionary = {
+        model_events: add_model_events({},PyrRules::ModelEventEmitter.registered_classes),
+        controller_events: add_controller_events
+      }
+      puts "DEBUG[icentris-rules] Events Dictionary Built in #{Time.new - start_time} seconds\n\n\n"
+      @@events_dictionary
+    end
+
+    def self.add_controller_events
+      results = {}
+      r=Rails.application.routes.routes.to_a.dup
+      i=ActionDispatch::Routing::RoutesInspector.new r
+      m=i.send(:collect_routes,r)
+      events = m.map do |a| 
+        p=a[:reqs].split("#")
+        class_name = "#{p[0].camelcase}Controller"
+        c = (results[class_name] ||= {context:{"system" => :messaging_user, "actor" => :user}, actions:[]})
+        if p[1]
+          action = p[1].split(" ").first    # it might have extra routing info on the end (subdomain, format, etc...) - we don't use this yet
+          c[:actions] << action unless c[:actions].include? action
+        end
+      end
+      results
+    end
+
+    # One liner to dump the rules config in consoles
+    # PyrRules::RulesConfig.events.each{|k,v| puts k.to_s.titleize; v.keys.sort.eac:qh{|key| puts "   #{key}"; v[key][:context].each{|col_name, col_config| puts "      #{col_name}(#{col_config[:type]})"}}};nil
+    private
+      def self.add_model_events(results={}, event_classes)
+        puts "DEBUG[icentris-rules] add_model_events"
+        event_classes.each do |klazz|
+          puts "DEBUG[icentris-rules] #{klazz}"
+          cols={};
+          if klazz != ActiveRecord::Base                  # Don't add ActiveRecord::Base as an event type, but recurse its subclasses later
+            cols["system"] = :messaging_user
+            cols["actor"] = :user
+            cols["klazz"] = :string
+            cols["target"] = :object
+            results[klazz.name] = {context: cols, actions: ModelEventEmitter.model_actions }
+          end
+          klazz.subclasses.each do |sc| 
+            add_model_events(results, [sc])
+          end
+          puts "DEBUG[icentris-rules] #{klazz} :: #{results[klazz.name]}"
+        end
+        results
+      end
+  end    
+end

data/app/rules/pyr_rules/event_subscriber.rb

@@ -0,0 +1,36 @@
+module PyrRules
+	class EventSubscriber
+
+		def initialize
+		end
+
+		def connect 
+			@redis = Redis.new
+			begin
+			  @redis.subscribe( "pyr_events" ) do |on|
+			    on.subscribe do |channel, subscriptions|
+			      puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+			    end
+
+			    on.message do |channel, message|
+			      puts "##{channel}: #{message}"
+			      @redis.unsubscribe if message == "exit"
+			    end
+
+			    on.unsubscribe do |channel, subscriptions|
+			      puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+			    end
+			  end
+			rescue Redis::BaseConnectionError => error
+			  puts "#{error}, retrying in 1s"
+			  sleep 1
+			  retry
+			end
+		end
+
+		def disconnect 
+			@redis.unsubscribe
+		end
+
+	end
+end

data/app/rules/pyr_rules/model_creation_handler.rb

@@ -0,0 +1,25 @@
+class PyrRules::ModelCreationHandler < PyrRules::ActionHandler
+
+  needs :type, :class_lookup
+
+  def handle
+    super
+    model_instance = model_class.new
+    if model_instance.respond_to? :user=
+      model_instance.user = owner
+    end
+    set_model_props model_instance
+    puts "Saving instance #{model_instance.attributes}"
+    model_instance.save!
+  end
+
+  # Subclassers add your mappings here
+  def set_model_props(m)
+
+  end
+
+  def model_class
+    raise "Subclassers please implement model_class"
+  end
+
+end

data/app/rules/pyr_rules/model_event_emitter.rb

@@ -0,0 +1,80 @@
+# This will hook into ActiveRecordCallbacks and raise the appropriate crud events
+#
+# For reference: 
+# 					http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html
+#
+# For sanity:
+# 				(-) save
+# 				(-) valid
+# 				(1) before_validation
+# 				(-) validate
+# 				(2) after_validation
+# 				(3) before_save
+# 				(4) before_create
+# 				(-) create
+# 				(5) after_create
+# 				(6) after_save
+# 				(7) after_commit  -or-  after_rollback
+# 				
+#               (1) before_destroy
+# 				(-) destroy
+# 				(2) after_destroy
+#
+# 				(-) find
+# 				(1) after_find
+# 				(2) after_initialize
+
+module PyrRules
+	module ModelEventEmitter
+
+		@@registered_classes = []
+
+		def self.included(base)
+			#base.send :extend, ClassMethods
+			#unless ( File.basename($0) == "rake" && ARGV.include?("db:migrate") )
+			#end
+			base.after_save :raise_updated
+			base.after_create :raise_created
+			base.before_destroy :raise_destroyed
+			@@registered_classes << base if !registered_classes.index(base)
+		end
+
+		def self.registered_classes
+			@@registered_classes
+		end
+
+		def self.model_actions
+ 			[:create, :update, :delete]
+		end
+
+		private
+			def raise_updated
+				_notify("update", changes: self.changes)
+			end
+
+			def raise_created
+				_notify("create")
+			end
+
+			def raise_destroyed
+				_notify("delete")
+			end
+
+			def _notify(action, extras = {})
+				begin
+					puts "DEBUG: DBH: ModelEventEmitter   action[#{action}]   class[#{self.class.name}]"
+					payload = build_event_payload( "ModelEvent", self.class.name, action, extras)
+					payload[:id] = self.id 
+					ActiveSupport::Notifications.instrument("PyrRules_#{self.class.name}_#{action}", payload )
+				rescue Exception => e
+					puts "Unable to raise event payload on #{self} : #{e.message}"
+				end
+			end
+
+			def build_event_payload(event_type, class_name, action, extras={})
+					payload = { type: event_type, klazz: self.class.name, action: action, id: self.id, data: self, 
+								user: Thread.current[:user] }.merge(extras)
+			end
+
+	end
+end

data/app/rules/pyr_rules/rule_context.rb

@@ -0,0 +1,20 @@
+class PyrRules::RuleContext
+  def initialize(event_hash, extras = {})
+    event_hash.each do |key, value|
+      define_singleton_method(key.to_sym) {value}
+    end
+    extras.each do |key, value|
+      define_singleton_method(key.to_sym) {value}
+    end
+    define_singleton_method(:system) {:system_messaging_user}
+    target = event_hash[:klazz].constantize.find event_hash[:id].to_i rescue nil
+    actor = User.find event_hash[:user][:id].to_i rescue nil
+    actor ||= target.try(:user) rescue nil
+    define_singleton_method(:target) {target}
+    define_singleton_method(:actor) {actor}
+  end
+  def get_binding
+    return binding
+  end
+end
+

data/app/rules/pyr_rules/rules_config.rb

@@ -0,0 +1,87 @@
+module PyrRules
+  class RulesConfig
+    
+    @@action_type_handlers ||= {}
+  
+    def self.events_config
+      EventConfigLoader.events_dictionary
+    end
+
+    def self.event_config(event_name)
+      ec = (events_config[:model_events][event_name] || events_config[:controller_events][event_name])
+      unless ec 
+        event_name = event_name.match(/(.*)::.*/)[1]  # 
+        ec = (events_config[:model_events][event_name] || events_config[:controller_events][event_name])
+      end
+      ec
+    end
+
+    def self.events
+      EventConfigLoader.events_list
+    end
+
+    # A very nice hierarchical Hash of all the events
+    def self.events_tree
+      tree={}
+      events_config.keys.sort.each do |event_type|
+        events_config[event_type].keys.sort.each do |class_name|
+          insert_here = (tree[event_type] ||= {})
+          parts = class_name.split("::")
+          parts[0...-1].each do |p|
+            insert_here = (insert_here[p] ||= {})
+          end
+          insert_here[parts.last] = events_config[event_type][class_name]
+        end
+      end
+      tree
+    end
+
+    def self.add_rule(rule_hash)
+      puts "\n\nAdding rule #{rule_hash}"
+      event_inclusion = rule_hash.delete(:event_inclusion) rescue nil
+      event_exclusion = rule_hash.delete(:event_exclusion) rescue nil
+      rule = PyrRules::Rule.where(:name => rule_hash[:name]).first
+      puts "   Updating existing rule..." if rule
+      action_configs = rule_hash.delete(:action_configs)
+      rule ||= PyrRules::Rule.create rule_hash
+      # Match regexp for inclusions
+      events_to_add = EventConfigLoader.events_list.select{|x| x if x.match event_inclusion} if event_inclusion  
+      # Match regexp for exclusions
+      events_to_restrict = EventConfigLoader.events_list.select{|x| x if x.match event_exclusion} if event_exclusion
+      events_to_add = (events_to_add - events_to_restrict) if events_to_restrict
+      rule.events = events_to_add
+      puts "   Mapped to events: #{rule.events}"
+      action_configs.each do |action_config|
+        existing_action = rule.actions.detect{|action| action.title == action_config[:title] rescue false}
+        rule.actions.create!(action_config) unless existing_action
+      end
+      rule.set_default_mappings
+      rule.save!
+      puts "Rule added\n"
+    end
+
+    def self.delete_rules
+      PyrRules::Rule.delete_all
+    end
+
+    # User friendly dump of the event configuration
+    def self.dump_events_config
+      events_config.each do |k,v| 
+        puts "\n\n\n#{k.to_s.titleize}"
+        v.keys.sort.each do |class_name| 
+          puts "\n   #{class_name}"
+          puts "       - actions"
+          v[class_name][:actions].each do |action| 
+            puts "           #{action}"
+          end
+          puts "       - context"
+          v[class_name][:context].each do |col_name, col_config| 
+            puts "           #{col_name}(#{col_config[:type]})"
+          end
+        end
+      end
+      nil
+    end
+
+  end
+end  

data/app/rules/pyr_rules/rules_engine.rb

@@ -0,0 +1,38 @@
+require_dependency 'pyr_rules/rule'
+
+module PyrRules
+  class RulesEngine
+    def self.reload_configuration
+      events = PyrRules::EventConfigLoader.reload_events_dictionary
+      actions = PyrRules::ActionHandler.reload_configuration
+      {events: events, actions: actions}
+    end
+
+    def self.handle_event(event)
+      event = event_from_string(event) if event.class == String
+      # Get super event rules tooo?
+      rules = PyrRules::Rule.where(events: "#{event[:klazz]}::#{event[:action]}" ).all
+      rules.each do |rule|
+        begin
+          rule.process_rule(event) 
+        rescue Exception => e
+          puts "\n\n ERROR ENCOUNTERED processing rule: #{rule.name} ==> #{e.message}"
+          puts e.backtrace
+        end
+      end
+    end
+
+
+    private
+      # Takes a hash and turns all hash keys into symbols.  It does
+      #   this recursively into nested hashes and arrays of hashes
+      def event_from_string(event_string)
+          event = JSON.parse(event_string)
+          HashWithIndifferentAccess.new(event)    # Allow use of symbols or strings as keys
+      end
+
+  end
+
+
+end
+

data/app/rules/pyr_rules/web_request_logger.rb

@@ -0,0 +1,6 @@
+class PyrRules::WebRequestLogger < PyrRules::ActionHandler
+
+	def handle
+	  super
+	end
+end

data/app/views/pyr_rules/actions/index.html.erb

@@ -0,0 +1,12 @@
+<h3>Rule Actions</h3>
+
+<div class="row">
+<% @actions.each_with_index do |a,idx| %>
+
+	<%= render 'shared/action', action: a %>
+
+	<% if idx % 3 == 2 %>
+		</div><div class="row">
+	<% end %>
+<% end %>
+</div>

data/app/views/pyr_rules/events/_sidebar.html.erb

@@ -0,0 +1,8 @@
+<%events = PyrRules::RulesConfig.events%>
+<table>
+<% events.each do |event| %>
+  <tr>
+    <td><% if event[:name] == params[:event_id] %><b><% end %><%= link_to event[:name], pyr_rules_event_rules_path(event_id: event[:name]) %><% if event[:name] == params[:event_id] %></b><% end%></td>
+  </tr>
+<% end %>
+</table>