slack-smart-bot 1.9.2 → 1.10.0

data/lib/slack/smart-bot/listen.rb

@@ -1,6 +1,6 @@
 class SlackSmartBot
   def listen_simulate
-    @salutations = [config[:nick], "<@#{config[:nick_id]}>", "bot", "smart"]
+    @salutations = [config[:nick], "<@#{config[:nick_id]}>", "bot", "smart", "smartbot", "smart-bot", "smart bot"]
     @pings = []
     @last_activity_check = Time.now
     get_bots_created()
@@ -18,8 +18,6 @@ class SlackSmartBot
           command = message[3].to_s.strip
           # take in consideration that on simulation we are treating all messages even those that are not populated on real cases like when the message is not populated to the specific bot connection when message is sent with the bot          
           @logger.info "treat message: #{message}" if config.testing
-
-
           if command.match?(/^\s*\-!!/) or command.match?(/^\s*\-\^/)
             command.scan(/`([^`]+)`/).flatten.each do |cmd|
               if cmd.to_s!=''

data/lib/slack/smart-bot/process.rb

@@ -13,11 +13,11 @@ class SlackSmartBot
     processed = true
 
     on_demand = false
-    if command.match(/^@?(#{config[:nick]}):*\s+(.+)/im) or
-       command.match(/^()!!(.+)/im) or
-       command.match(/^()\^(.+)/im) or
-       command.match(/^()!(.+)/im) or
-       command.match(/^()<@#{config[:nick_id]}>\s+(.+)/im)
+    if command.match(/\A@?(#{config[:nick]}):*\s+(.+)/im) or
+       command.match(/\A()!!(.+)/im) or
+       command.match(/\A()\^(.+)/im) or
+       command.match(/\A()!(.+)/im) or
+       command.match(/\A()<@#{config[:nick_id]}>\s+(.+)/im)
         command2 = $2
         Thread.current[:command] = command2
         if command2.match?(/^()!!(.+)/im) or
@@ -30,95 +30,230 @@ class SlackSmartBot
     if (on_demand or typem == :on_dm or
       (@listening.key?(from) and (@listening[from].key?(dest) or @listening[from].key?(Thread.current[:thread_ts])) )) and 
       config.on_maintenance and !command.match?(/\A(set|turn)\s+maintenance\s+off\s*\z/)
-      respond config.on_maintenance_message, dest
+      unless Thread.current.key?(:routine) and Thread.current[:routine]
+        respond eval("\"" + config.on_maintenance_message + "\"")
+      end
       processed = true
     end
-
     if !config.on_maintenance or (config.on_maintenance and command.match?(/\A(set|turn)\s+maintenance\s+off\s*\z/))
       #todo: check :on_pg in this case
       if typem == :on_master or typem == :on_bot or typem == :on_pg or typem == :on_dm
     
         case command
 
-        when /^\s*(Hello|Hallo|Hi|Hola|What's\sup|Hey|Hæ)\s+(#{@salutations.join("|")})\s*$/i
-          hi_bot(user, dest, dchannel, from, display_name)
-        when /^\s*what's\s+new\s*$/i
+        when /\A\s*what's\s+new\s*$/i
           whats_new(user, dest, dchannel, from, display_name)
-        when /^\s*(Bye|Bæ|Good\s+Bye|Adiós|Ciao|Bless|Bless\sBless|Adeu)\s+(#{@salutations.join("|")})\s*$/i
-          bye_bot(dest, from, display_name)
-        when /^\s*bot\s+(rules|help)\s*(.+)?$/i, /^bot,? what can I do/i
-          $1.to_s.match?(/rules/i) ? specific = true : specific = false
-          help_command = $2
-
+        when /\A\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i, /\A(#{@salutations.join("|")}),? what can I do/i
+          $2.to_s.match?(/rules/i) ? specific = true : specific = false
+          help_command = $3
           bot_help(user, from, dest, dchannel, specific, help_command, rules_file)
-        when /^\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, /^use\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
+        when /\A\s*(suggest|random)\s+(command|rule)\s*\z/i, /\A\s*(command|rule)\s+suggestion\s*\z/i
+          $2.to_s.match?(/rule/i) || $1.to_s.match?(/rule/i) ? specific = true : specific = false
+          suggest_command(from, dest, dchannel, specific, rules_file)
+        when /\A\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, 
+          /\A\s*use\s+(rules\s+)?(from\s+)?<#(\w+)\|>\s*$/i, 
+          /\Ause\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
           channel = $3
           use_rules(dest, channel, user, dchannel)
-        when /^\s*stop\s+using\s+rules\s+(from\s+)<#\w+\|(.+)>/i, /^stop\s+using\s+rules\s+(from\s+)(.+)/i
+        when /\A\s*stop\s+using\s+rules\s+(on\s+)<#\w+\|(.+)>/i, 
+          /\A\s*stop\s+using\s+rules\s+(on\s+)<#(\w+)\|>/i, 
+          /\A\s*stop\s+using\s+rules\s+(on\s+)(.+)\s*$/i
+          channel = $2
+          stop_using_rules_on(dest, user, from, channel, typem)
+        when /\A\s*stop\s+using\s+(rules\s+from\s+)?<#\w+\|(.+)>/i, 
+          /\A\s*stop\s+using\s+(rules\s+from\s+)?<#(\w+)\|>/i, 
+          /\A\s*stop\s+using\s+(rules\s+from\s+)?(.+)\s*$/i
           channel = $2
           stop_using_rules(dest, channel, user, dchannel)
-        when /^\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /^extend\s+rules\s+(to\s+)(.+)/i,
-            /^\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /^use\s+rules\s+(on\s+)(.+)/i
+        when /\A\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /\A\s*extend\s+rules\s+(to\s+)<#(\w+)\|>/i, 
+            /\A\s*extend\s+rules\s+(to\s+)(.+)/i,
+            /\A\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /\A\s*use\s+rules\s+(on\s+)<#(\w+)\|>/i, 
+            /\A\s*use\s+rules\s+(on\s+)(.+)/i
           channel = $2
           extend_rules(dest, user, from, channel, typem)
-        when /^\s*stop\s+using\s+rules\s+(on\s+)<#\w+\|(.+)>/i, /^stop\s+using\s+rules\s+(on\s+)(.+)/i
-          channel = $2
-          stop_using_rules_on(dest, user, from, channel, typem)
-        when /^\s*exit\s+bot\s*$/i, /^quit\s+bot\s*$/i, /^close\s+bot\s*$/i
+        when /\A\s*exit\s+bot\s*$/i, /\A\s*quit\s+bot\s*$/i, /\A\s*close\s+bot\s*$/i
           exit_bot(command, from, dest, display_name)
-        when /^\s*start\s+(this\s+)?bot$/i
+        when /\A\s*start\s+(this\s+)?bot$/i
           start_bot(dest, from)
-        when /^\s*pause\s+(this\s+)?bot$/i
+        when /\A\s*pause\s+(this\s+)?bot$/i
           pause_bot(dest, from)
-        when /^\s*bot\s+status/i
+        when /\A\s*bot\s+status/i
           bot_status(dest, user)
-        when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, /\Anotify\s+(all)?\s*(.+)\s*\z/im
+        when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, 
+          /\Anotify\s+<#(\w+)\|>\s+(.+)\s*\z/im, 
+          /\Anotify\s+(all)?\s*(.+)\s*\z/im
           where = $1
           message = $2
           notify_message(dest, from, where, message)
-        when /^\s*create\s+(cloud\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, /^create\s+(cloud\s+)?bot\s+on\s+(.+)\s*/i
-          cloud = !$1.nil?
+        when /\Apublish\s+announcements\s*\z/i
+          publish_announcements(user)
+        when /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, 
+          /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#(\w+)\|>\s*/i, 
+          /\Acreate\s+(cloud\s+|silent\s+)?bot\s+on\s+#(.+)\s*/i, 
+          /\Acreate\s+(cloud\s+|silent\s+)?bot\s+on\s+(.+)\s*/i
+          type = $1.to_s.downcase
           channel = $2
-          create_bot(dest, user, cloud, channel)
-        when /^\s*kill\s+bot\s+on\s+<#C\w+\|(.+)>\s*$/i, /^kill\s+bot\s+on\s+(.+)\s*$/i
+          create_bot(dest, user, type, channel)
+        when /\A\s*kill\s+bot\s+on\s+<#C\w+\|(.+)>\s*$/i, 
+          /\A\s*kill\s+bot\s+on\s+<#(\w+)\|>\s*$/i, 
+          /\Akill\s+bot\s+on\s+#(.+)\s*$/i, /\Akill\s+bot\s+on\s+(.+)\s*$/i
           channel = $1
           kill_bot_on_channel(dest, from, channel)
-        when /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s#(\w+)\s*)(\s.+)?\s*$/i,
-          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
-          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*$/i,
-          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
-          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*$/i,
-          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i
+        when /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s#(\w+)\s*)(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#(\w+)\|>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(\w+)\|>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(\w+)\|>\s*)?(\s.+)?\s*\z/im          
           silent = $2.to_s!=''
-          name = $3.downcase
-          type = $4
-          number_time = $5
-          period = $6
-          channel = $8
-          command_to_run = $9
-          add_routine(dest, from, user, name, type, number_time, period, command_to_run, files, silent, channel)
-        when /^\s*(kill|delete|remove)\s+routine\s+(\w+)\s*$/i
+          routine_type = $3.downcase
+          name = $4.downcase
+          type = $5.to_s.downcase
+          number_time = $6
+          period = $7
+          channel = $9
+          command_to_run = $10
+          content = command_to_run.to_s.scan(/\A\s*```(.+)```\s*\z/im).join
+          unless content == ''
+            files = [
+              {
+                name: name,
+                filetype: '',
+                content: content
+              }
+            ]
+            command_to_run = ''
+          end
+          add_routine(dest, from, user, name, type, number_time, period, command_to_run, files, silent, channel, routine_type)
+        when /\A\s*(kill|delete|remove)\s+routine\s+([\w\.]+)\s*$/i
           name = $2.downcase
           remove_routine(dest, from, name)
-        when /^\s*(run|execute)\s+routine\s+(\w+)\s*$/i
+        when /\A\s*see\s+routines?\s+results?\s+([\w\.]+)\s*$/i,
+          /\A\s*see\s+results?\s+routines?\s+([\w\.]+)\s*$/i,
+          /\A\s*results?\s+routines?\s+([\w\.]+)\s*$/i
+          name = $1.downcase
+          see_result_routine(dest, from, name)
+        when /\A\s*(run|execute)\s+routine\s+([\w\.]+)\s*$/i
           name = $2.downcase
           run_routine(dest, from, name)
-        when /^\s*pause\s+routine\s+(\w+)\s*$/i
+        when /\A\s*pause\s+routine\s+([\w\.]+)\s*$/i
           name = $1.downcase
           pause_routine(dest, from, name)
-        when /^\s*start\s+routine\s+(\w+)\s*$/i
+        when /\A\s*start\s+routine\s+([\w\.]+)\s*$/i
           name = $1.downcase
           start_routine(dest, from, name)
-        when /^\s*see\s+(all\s+)?routines\s*$/i
+        when /\A\s*see\s+(all\s+)?routines\s*$/i
           all = $1.to_s != ""
           see_routines(dest, from, user, all)
-        when /^\s*get\s+bot\s+logs?\s*$/i
+        when /\A\s*get\s+bot\s+logs?\s*$/i
           get_bot_logs(dest, from, typem)
-        when /^\s*bot\s+stats\s*(.*)\s*$/i
+        when /\A\s*send\s+message\s+(on|to|in)\s*([^\s]+)\s+([^\s]+)\s*:\s*(.+)\s*$/i,
+          /\A\s*send\s+message\s+(on|to|in)\s*([^\s]+)\s*():\s*(.+)\s*$/i
+          to = $2
+          thread_ts = $3.to_s
+          message = $4
+          to_channel = to.scan(/<#([^>]+)\|.*>/).join 
+          to_channel = to.scan(/#([^\s]+)/).join if to_channel == ''
+          if to_channel == ''
+            to_user = to.scan(/<@(\w+)>/).join
+            if to_user == ''
+              # message_id
+            else
+              to = to_user
+            end
+          else
+            to = to_channel
+          end
+          send_message(dest, from, typem, to, thread_ts, message)
+        when /\A\s*react\s+(on|to|in)\s*([^\s]+)\s+([^\s]+)\s+(.+)\s*$/i
+          to = $2
+          thread_ts = $3.to_s
+          emojis = $4
+          to_channel = to.scan(/<#([^>]+)\|.*>/).join
+          if to_channel == ''
+            to_channel = to.scan(/#([^\s]+)/).join
+            to_channel = @channels_id[to_channel].to_s
+          end
+          if to_channel == ''
+            respond "The channel specified doesn't exist or is in a incorrect format"
+          else
+            to = to_channel
+            react_to(dest, from, typem, to, thread_ts, emojis)
+          end
+
+        when /\A\s*(leader\s+board|leaderboard|ranking|podium)()()\s*$/i,
+          /\A\s*(leader\s+board|leaderboard|ranking|podium)\s+from\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)\s+to\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)\s*$/i,
+          /\A\s*(leader\s+board|leaderboard|ranking|podium)\s+from\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)()\s*$/i,
+          /\A\s*(leader\s+board|leaderboard|ranking|podium)\s+(today|yesterday|last\s+week|this\s+week|last\s+month|this\s+month|last\s+year|this year)()\s*$/i
+          require 'date'
+          opt1 = $2.to_s
+          to = $3.to_s
+          if opt1.match?(/\d/)
+            from = opt1
+            period = ''
+            from = from.gsub('.','-').gsub('/','-')
+            if to.empty?
+              to = Date.today.strftime("%Y-%m-%d")
+            else
+              to = to.gsub('.','-').gsub('/','-')
+            end
+          elsif opt1.to_s==''
+            period = 'last week'
+            date = Date.today
+            wday = date.wday
+            wday = 7 if wday==0
+            wday-=1
+            from = "#{(date-wday-7).strftime("%Y-%m-%d")}"
+            to = "#{(date-wday-1).strftime("%Y-%m-%d")}"
+          else
+            from = ''
+            period = opt1.downcase
+            case period
+            when 'today'
+              from = to = "#{Date.today.strftime("%Y-%m-%d")}"
+            when 'yesterday'
+              from = to ="#{(Date.today-1).strftime("%Y-%m-%d")}"
+            when /this\s+month/
+              from = "#{Date.today.strftime("%Y-%m-01")}"
+              to = "#{Date.today.strftime("%Y-%m-%d")}"
+            when /last\s+month/
+              date = Date.today<<1
+              from = "#{date.strftime("%Y-%m-01")}"
+              to = "#{(Date.new(date.year, date.month, -1)).strftime("%Y-%m-%d")}"
+            when /this\s+year/
+              from = "#{Date.today.strftime("%Y-01-01")}"
+              to = "#{Date.today.strftime("%Y-%m-%d")}"
+            when /last\s+year/
+              date = Date.today.prev_year
+              from = "#{date.strftime("%Y-01-01")}"
+              to = "#{(Date.new(date.year, 12, 31)).strftime("%Y-%m-%d")}"
+            when /this\s+week/
+              date = Date.today
+              wday = date.wday
+              wday = 7 if wday==0
+              wday-=1
+              from = "#{(date-wday).strftime("%Y-%m-%d")}"
+              to = "#{date.strftime("%Y-%m-%d")}"
+            when /last\s+week/
+              date = Date.today
+              wday = date.wday
+              wday = 7 if wday==0
+              wday-=1
+              from = "#{(date-wday-7).strftime("%Y-%m-%d")}"
+              to = "#{(date-wday-1).strftime("%Y-%m-%d")}"
+            end
+          end
+
+          leaderboard(from, to, period)
+
+        when /\A\s*bot\s+stats\s*(.*)\s*$/i
           opts = $1.to_s
           all_opts = opts.downcase.split(' ')
           all_data = all_opts.include?('alldata')
-          st_channel = opts.scan(/<#(\w+)\|.+>/).join
+          st_channel = opts.scan(/<#(\w+)\|.*>/).join
           st_from = opts.scan(/from\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
           st_from = st_from.gsub('.','-').gsub('/','-')
           st_to = opts.scan(/to\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
@@ -154,6 +289,11 @@ class SlackSmartBot
           status = $2.downcase
           message = $3.to_s
           set_maintenance(from, status, message)
+        when /\A(set|turn)\s+(general|generic)\s+message\s+(off)\s*()\z/im, /\A(set|turn)\s+(general|generic)\s+message\s+(on\s+)?\s*(.+)\s*\z/im
+          status = $3.to_s.downcase
+          status = 'on' if status == ''
+          message = $4.to_s
+          set_general_message(from, status, message)
         else
           processed = false
         end
@@ -175,28 +315,24 @@ class SlackSmartBot
     
         case command
 
-        # bot rules for extended channels
-        when /^bot\s+rules\s*(.+)?$/i
-          help_command = $1
-          bot_rules(dest, help_command, typem, rules_file, user)
-        when /^\s*(add\s+)?(global\s+|generic\s+)?shortcut\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i, 
-          /^(add\s+)(global\s+|generic\s+)?sc\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i
+        when /\A\s*(add\s+)?(global\s+|generic\s+)?shortcut\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i, 
+          /\A(add\s+)(global\s+|generic\s+)?sc\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i
           for_all = $3
           shortcut_name = $4.to_s.downcase
           command_to_run = $5
           global = $2.to_s != ''
           add_shortcut(dest, user, typem, for_all, shortcut_name, command, command_to_run, global)
-        when /^\s*(delete|remove)\s+(global\s+|generic\s+)?shortcut\s+(.+)/i, 
-          /^(delete|remove)\s+(global\s+|generic\s+)?sc\s+(.+)/i
+        when /\A\s*(delete|remove)\s+(global\s+|generic\s+)?shortcut\s+(.+)/i, 
+          /\A(delete|remove)\s+(global\s+|generic\s+)?sc\s+(.+)/i
           shortcut = $3.to_s.downcase
           global = $2.to_s != ''
 
           delete_shortcut(dest, user, shortcut, typem, command, global)
-        when /^\s*see\s+shortcuts/i, /^see\ssc/i
+        when /\A\s*see\s+shortcuts/i, /^see\s+sc/i
           see_shortcuts(dest, user, typem)
 
           #kept to be backwards compatible
-        when /^\s*id\schannel\s<#C\w+\|(.+)>\s*/i, /^id channel (.+)/
+        when /\A\s*id\schannel\s<#C\w+\|(.+)>\s*/i, /^id channel (.+)/
           unless typem == :on_extended
             channel_name = $1
             get_channels_name_and_id()
@@ -206,18 +342,20 @@ class SlackSmartBot
               respond "channel: #{channel_name} not found", dest
             end
           end
-        when /^\s*ruby\s(.+)/im, /^\s*code\s(.+)/im
+        when /\A\s*ruby\s+(.+)/im, /\A\s*code\s+(.+)/im
           code = $1
           code.gsub!("\\n", "\n")
           code.gsub!("\\r", "\r")
+          code.gsub!(/^\s*```/,'')
+          code.gsub!(/```\s*$/,'')
           @logger.info code
           ruby_code(dest, user, code, rules_file)
-        when /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s*()()()$/i, 
-          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()()\s*$/i,
-          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"()\s*$/i,
-          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"\s+(.+)\s*$/i,
-          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()\s+(.+)\s*$/i,
-          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)()\s+()(.+)\s*$/i
+        when /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s*()()()\z/i, 
+          /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()()\s*\z/i,
+          /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"()\s*\z/i,
+          /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"\s+(.+)\s*\z/i,
+          /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()\s+(.+)\s*\z/i,
+          /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)()\s+()(.+)\s*\z/i
           opts_type = $1.to_s.downcase.split(' ')
           opts_type.include?('private') ? type = :private : type = :public
           type = "#{type}_clean".to_sym if opts_type.include?('clean')
@@ -235,10 +373,10 @@ class SlackSmartBot
               env_vars[idx] = "ENV['#{ev}"
           end
           repl(dest, user, session_name, env_vars.flatten, rules_file, command, description, type)
-        when /^\s*get\s+(repl|irb|live)\s+([\w\-]+)\s*/i
+        when /\A\s*get\s+(repl|irb|live)\s+([\w\-]+)\s*/i
           session_name = $2
           get_repl(dest, user, session_name)      
-        when /^\s*run\s+(repl|irb|live)\s+([\w\-]+)()\s*$/i,
+        when /\A\s*run\s+(repl|irb|live)\s+([\w\-]+)()\s*$/i,
           /^\s*run\s+(repl|irb|live)\s+([\w\-]+)\s+(.+)\s*$/i
           session_name = $2
           opts = " #{$3}"
@@ -252,10 +390,10 @@ class SlackSmartBot
               env_vars[idx] = "ENV['#{ev}"
           end
           run_repl(dest, user, session_name, env_vars.flatten, rules_file)      
-        when /^\s*(delete|remove)\s+(repl|irb|live)\s+([\w\-]+)\s*$/i
+        when /\A\s*(delete|remove)\s+(repl|irb|live)\s+([\w\-]+)\s*$/i
           repl_name = $3
           delete_repl(dest, user, repl_name)
-        when /^\s*see\s+(repls|repl|irb|irbs)\s*$/i
+        when /\A\s*see\s+(repls|repl|irb|irbs)\s*$/i
           see_repls(dest, user, typem)
         else
           processed2 = false

data/lib/slack/smart-bot/process_first.rb

@@ -1,27 +1,49 @@
 class SlackSmartBot
-  def process_first(user, text, dest, dchannel, typem, files, ts, thread_ts, routine)
+  def process_first(user, text, dest, dchannel, typem, files, ts, thread_ts, routine, routine_name, routine_type)
     nick = user.name
     rules_file = ""
     text.gsub!(/^!!/,'^') # to treat it just as ^
+    shared = []
+    if @shares.key?(@channels_name[dest]) and (ts.to_s!='' or config.simulate) and (user.id!=config.nick_id or (user.id == config.nick_id and !text.match?(/\A\*?Shares from channel/)))
+      @shares[@channels_name[dest]].each do |row|
+        if row[:user_deleted]==''
+          if ((row[:type] == 'text' and text.include?(row[:condition][1..-2])) or (row[:type]=='regexp' and text.match?(/#{row[:condition][1..-2]}/im))) and !shared.include?(row[:to_channel])
+            if config.simulate
+              link = text
+            else
+              link = client.web_client.chat_getPermalink(channel: dest, message_ts: ts).permalink
+            end
+            respond "*<#{link}|Shared> by <@#{row[:user_created]}> from <##{dest}>* using share id #{row[:share_id]}", row[:to_channel]
+            shared << row[:to_channel]
+            sleep 0.2
+          end
+        end
+      end
+    end
+
     if typem == :on_call
       rules_file = config.rules_file
     elsif dest[0] == "C" or dest[0] == "G" # on a channel or private channel
       rules_file = config.rules_file
 
-      if @rules_imported.key?(user.id) and @rules_imported[user.id].key?(dchannel)
-        unless @bots_created.key?(@rules_imported[user.id][dchannel])
+      if @rules_imported.key?(user.name) and @rules_imported[user.name].key?(dchannel)
+        unless @bots_created.key?(@rules_imported[user.name][dchannel])
           get_bots_created()
         end
-        if @bots_created.key?(@rules_imported[user.id][dchannel])
-          rules_file = @bots_created[@rules_imported[user.id][dchannel]][:rules_file]
+        if @bots_created.key?(@rules_imported[user.name][dchannel])
+          rules_file = @bots_created[@rules_imported[user.name][dchannel]][:rules_file]
         end
       end
-    elsif dest[0] == "D" and @rules_imported.key?(user.id) and @rules_imported[user.id].key?(user.id) #direct message
-      unless @bots_created.key?(@rules_imported[user.id][user.id])
+    elsif dest[0] == "D" and @rules_imported.key?(user.name) and @rules_imported[user.name].key?(user.name) #direct message
+      unless @bots_created.key?(@rules_imported[user.name][user.name])
         get_bots_created()
       end
-      if @bots_created.key?(@rules_imported[user.id][user.id])
-        rules_file = @bots_created[@rules_imported[user.id][user.id]][:rules_file]
+      if @bots_created.key?(@rules_imported[user.name][user.name])
+        rules_file = @bots_created[@rules_imported[user.name][user.name]][:rules_file]
+      end
+    elsif dest[0] == 'D' and (!@rules_imported.key?(user.name) or ( @rules_imported.key?(user.name) and !@rules_imported[user.name].key?(user.name)))
+      if File.exist?("#{config.path}/rules/general_rules.rb")
+        rules_file = "/rules/general_rules.rb"
       end
     end
 
@@ -160,6 +182,9 @@ class SlackSmartBot
     begin
       t = Thread.new do
         begin
+          processed = false
+          processed_rules = false
+
           Thread.current[:dest] = dest
           Thread.current[:user] = user
           Thread.current[:command] = command
@@ -169,30 +194,36 @@ class SlackSmartBot
           Thread.current[:ts] = ts
           Thread.current[:thread_ts] = thread_ts
           Thread.current[:routine] = routine
+          Thread.current[:routine_name] = routine_name
+          Thread.current[:routine_type] = routine_type
+          Thread.current[:dchannel] = dchannel
           if thread_ts.to_s == ''
             Thread.current[:on_thread] = false
             Thread.current[:thread_ts] = Thread.current[:ts] # to create the thread if necessary
           else
             Thread.current[:on_thread] = true
           end
-          if (dest[0] == "C") || (dest[0] == "G") and @rules_imported.key?(user.id) &&
-            @rules_imported[user.id].key?(dchannel) && @bots_created.key?(@rules_imported[user.id][dchannel])
-              Thread.current[:using_channel] = @rules_imported[user.id][dchannel]
-          elsif dest[0] == "D" && @rules_imported.key?(user.id) && @rules_imported[user.id].key?(user.id) and
-            @bots_created.key?(@rules_imported[user.id][user.id])
-              Thread.current[:using_channel] = @rules_imported[user.id][user.id]
+          if (dest[0] == "C") || (dest[0] == "G") and @rules_imported.key?(user.name) &&
+            @rules_imported[user.name].key?(dchannel) && @bots_created.key?(@rules_imported[user.name][dchannel])
+              Thread.current[:using_channel] = @rules_imported[user.name][dchannel]
+          elsif dest[0] == "D" && @rules_imported.key?(user.name) && @rules_imported[user.name].key?(user.name) and
+            @bots_created.key?(@rules_imported[user.name][user.name])
+              Thread.current[:using_channel] = @rules_imported[user.name][user.name]
           else
               Thread.current[:using_channel] = ''
           end
-
-          processed = process(user, command, dest, dchannel, rules_file, typem, files, Thread.current[:thread_ts])
+          if typem == :on_pub or typem == :on_pg
+            processed = false
+          else
+            processed = process(user, command, dest, dchannel, rules_file, typem, files, Thread.current[:thread_ts])
+          end
           @logger.info "command: #{nick}> #{command}" if processed
           on_demand = false
-          if command.match(/^@?(#{config[:nick]}):*\s+(.+)/im) or
-            command.match(/^()!!(.+)/im) or
-            command.match(/^()\^(.+)/im) or
-            command.match(/^()!(.+)/im) or
-            command.match(/^()<@#{config[:nick_id]}>\s+(.+)/im)
+          if command.match(/\A@?(#{config[:nick]}):*\s+(.+)/im) or
+            command.match(/\A()!!(.+)/im) or
+            command.match(/\A()\^(.+)/im) or
+            command.match(/\A()!(.+)/im) or
+            command.match(/\A()<@#{config[:nick_id]}>\s+(.+)/im)
             command2 = $2
             Thread.current[:command] = command2
             if command2.match?(/^()!!(.+)/im) or
@@ -202,7 +233,25 @@ class SlackSmartBot
             command = command2
             on_demand = true
           end
-          unless config.on_maintenance and processed
+          unless config.on_maintenance or @status != :on
+            if typem == :on_pub or typem == :on_pg or typem == :on_extended
+              if command.match(/\A\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i) or command.match(/\A(#{@salutations.join("|")}),? what can I do/i)
+                $2.to_s.match?(/rules/i) ? specific = true : specific = false
+                help_command = $3
+                if typem == :on_extended and specific
+                  bot_rules(dest, help_command, typem, rules_file, user)
+                else
+                  bot_help(user, user.name, dest, dchannel, specific, help_command, rules_file)
+                end
+                processed = true
+              end    
+            end
+            processed = (processed || general_bot_commands(user, command, dest, files) )
+            processed = (processed || general_commands(user, command, dest, files) ) if defined?(general_commands)
+            @logger.info "command: #{nick}> #{command}" if processed
+          end
+
+          if !config.on_maintenance and !processed and typem != :on_pub and typem != :on_pg
             if @status == :on and
               (!answer.empty? or
               (@repl_sessions.key?(nick) and dest==@repl_sessions[nick][:dest] and 
@@ -216,9 +265,9 @@ class SlackSmartBot
               #todo: verify this
 
               if dest[0] == "C" or dest[0] == "G" or (dest[0] == "D" and typem == :on_call)
-                if typem != :on_call and @rules_imported.key?(user.id) and @rules_imported[user.id].key?(dchannel)
-                  if @bots_created.key?(@rules_imported[user.id][dchannel])
-                    if @bots_created[@rules_imported[user.id][dchannel]][:status] != :on
+                if typem != :on_call and @rules_imported.key?(user.name) and @rules_imported[user.name].key?(dchannel)
+                  if @bots_created.key?(@rules_imported[user.name][dchannel])
+                    if @bots_created[@rules_imported[user.name][dchannel]][:status] != :on
                       respond "The bot on that channel is not :on", dest
                       rules_file = ""
                     end
@@ -235,19 +284,19 @@ class SlackSmartBot
                     command[0] = "" if command[0] == "!"
                     command.gsub!(/^@\w+:*\s*/, "")
                     if method(:rules).parameters.size == 4
-                      rules(user, command, processed, dest)
+                      processed_rules = rules(user, command, processed, dest)
                     elsif method(:rules).parameters.size == 5
-                      rules(user, command, processed, dest, files)
+                      processed_rules = rules(user, command, processed, dest, files)
                     else
-                      rules(user, command, processed, dest, files, rules_file)
+                      processed_rules = rules(user, command, processed, dest, files, rules_file)
                     end
                   else
                     @logger.warn "It seems like rules method is not defined"
                   end
                 end
-              elsif @rules_imported.key?(user.id) and @rules_imported[user.id].key?(user.id)
-                if @bots_created.key?(@rules_imported[user.id][user.id])
-                  if @bots_created[@rules_imported[user.id][user.id]][:status] == :on
+              elsif @rules_imported.key?(user.name) and @rules_imported[user.name].key?(user.name)
+                if @bots_created.key?(@rules_imported[user.name][user.name])
+                  if @bots_created[@rules_imported[user.name][user.name]][:status] == :on
                     begin
                       eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file) and !['.','..'].include?(config.path + rules_file)
                     rescue Exception => stack
@@ -255,7 +304,7 @@ class SlackSmartBot
                       @logger.fatal stack
                     end
                   else
-                    respond "The bot on <##{@rules_imported[user.id][user.id]}|#{@bots_created[@rules_imported[user.id][user.id]][:channel_name]}> is not :on", dest
+                    respond "The bot on <##{@rules_imported[user.name][user.name]}|#{@bots_created[@rules_imported[user.name][user.name]][:channel_name]}> is not :on", dest
                     rules_file = ""
                   end
                 end
@@ -265,16 +314,43 @@ class SlackSmartBot
                     command[0] = "" if command[0] == "!"
                     command.gsub!(/^@\w+:*\s*/, "")
                     if method(:rules).parameters.size == 4
-                      rules(user, command, processed, dest)
+                      processed_rules = rules(user, command, processed, dest)
                     elsif method(:rules).parameters.size == 5
-                      rules(user, command, processed, dest, files)
+                      processed_rules = rules(user, command, processed, dest, files)
                     else
-                      rules(user, command, processed, dest, files, rules_file)
+                      processed_rules = rules(user, command, processed, dest, files, rules_file)
                     end
                   else
                     @logger.warn "It seems like rules method is not defined"
                   end
                 end
+              elsif dest[0] == 'D' and 
+                (!@rules_imported.key?(user.name) or ( @rules_imported.key?(user.name) and !@rules_imported[user.name].key?(user.name))) and 
+                rules_file.include?('general_rules.rb')
+                begin
+                  eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file) and !['.','..'].include?(config.path + rules_file)
+                rescue Exception => stack
+                  @logger.fatal "ERROR ON imported RULES FILE: #{rules_file}"
+                  @logger.fatal stack
+                end
+
+                if defined?(general_rules)
+                  command[0] = "" if command[0] == "!"
+                  command.gsub!(/^@\w+:*\s*/, "")
+                  #todo: check to change processed > processed_rules
+                  if method(:general_rules).parameters.size == 4
+                    processed = general_rules(user, command, processed, dest)
+                  elsif method(:general_rules).parameters.size == 5
+                    processed = general_rules(user, command, processed, dest, files)
+                  else
+                    processed = general_rules(user, command, processed, dest, files, rules_file)
+                  end
+                else
+                  @logger.warn "It seems like general_rules method is not defined"
+                end
+                unless processed
+                  dont_understand('')
+                end
               else
                 @logger.info "it is a direct message with no rules file selected so no rules file executed."
                 if command.match?(/^\s*bot\s+rules\s*(.*)$/i)
@@ -285,6 +361,8 @@ class SlackSmartBot
                 end
               end
 
+              processed = (processed_rules || processed)
+
               if processed and @listening.key?(nick)
                 if Thread.current[:on_thread] and @listening[nick].key?(Thread.current[:thread_ts])
                   @listening[nick][Thread.current[:thread_ts]] = Time.now
@@ -292,9 +370,12 @@ class SlackSmartBot
                   @listening[nick][dest] = Time.now
                 end
               end
-
             end
           end
+          
+          if processed and config.general_message != '' and !routine
+            respond eval("\"" + config.general_message + "\"")
+          end
         rescue Exception => stack
           @logger.fatal stack
         end