slack-smart-bot 1.9.1 → 1.11.0

data/lib/slack/smart-bot/commands/on_bot/general/suggest_command.rb

@@ -0,0 +1,36 @@
+class SlackSmartBot
+
+  # help: ----------------------------------------------
+  # help: `suggest command`
+  # help: `random command`
+  # help: `command suggestion`
+  # help: `suggest rule`
+  # help: `random rule`
+  # help: `rule suggestion`
+  # help:    it will display the help content for a random command.
+  # help:    if used 'rule' then it will display a random rule.
+  # help:    if used 'command' it will show any kind of command or rule.
+  # help: command_id: :suggest_command
+  # help:
+  def suggest_command(from, dest, dchannel, specific, rules_file)
+    save_stats(__method__)
+    dont_suggest = []
+    help_message = get_help(rules_file, dest, from, specific, true, descriptions: false, only_normal_user: true)
+    commands = help_message.gsub(/====+/,'-'*30).split(/^\s*-------*$/).flatten
+    commands.reject!{|c| c.match?(/These are specific commands for this bot on this/i) || c.match?(/\A\s*\z/)}
+    dont_suggest.each do |ds|
+      commands.reject!{|c| c.match?(/:#{ds}\s*$/i)}
+    end
+    @last_suggested_commands ||= []
+    @last_suggested_commands.shift if @last_suggested_commands.size >=5
+    command = ''
+    begin 
+      command = commands.sample
+    end until !@last_suggested_commands.include?(command) or commands.size <= 5
+    @last_suggested_commands << command
+    command.gsub!(/^\s*command_id:\s+:\w+\s*$/,'')
+    message = "*Command suggestion*:\n#{command}"
+    respond message, dest, unfurl_links: false, unfurl_media: false
+  end
+
+end

data/lib/slack/smart-bot/commands/{general → on_bot/general}/use_rules.rb

@@ -6,22 +6,23 @@ class SlackSmartBot
   # help: `use CHANNEL`
   # help:    it will use the rules from the specified channel.
   # help:    you need to be part of that channel to be able to use the rules.
+  # help:    <https://github.com/MarioRuiz/slack-smart-bot#using-rules-from-other-channels|more info>
+  # help: command_id: :use_rules
   # help:
   def use_rules(dest, channel, user, dchannel)
     save_stats(__method__)
     get_bots_created()
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       #todo: add pagination for case more than 1000 channels on the workspace
       channels = get_channels()
-
+      channel.gsub!('#','') # for the case the channel name is in plain text including #
+      channel = @channels_name[channel] if @channels_name.key?(channel)
       channel_found = channels.detect { |c| c.name == channel }
-      members = get_channel_members(@channels_id[channel]) unless channel_found.nil?
+      get_channels_name_and_id() unless @channels_id.key?(channel)
+      members = get_channel_members(@channels_id[channel]) unless channel_found.nil? or !@channels_id.key?(channel)
 
-      if channel_found.nil?
-        respond "The channel you are trying to use doesn't exist", dest
+      if channel_found.nil? or !@channels_id.key?(channel)
+        respond "The channel you are trying to use doesn't exist or cannot be found.", dest
       elsif channel_found.name == config.master_channel
         respond "You cannot use the rules from Master Channel on any other channel.", dest
       elsif !@bots_created.key?(@channels_id[channel])
@@ -30,12 +31,13 @@ class SlackSmartBot
         respond "The bot in that channel is not :on", dest
       else
         if user.id == channel_found.creator or members.include?(user.id)
-          @rules_imported[user.id] = {} unless @rules_imported.key?(user.id)
+          @rules_imported[user.name] = {} unless @rules_imported.key?(user.name)
           if dest[0] == "C" or dest[0] == "G" #todo: take in consideration bots that are not master
-            @rules_imported[user.id][dchannel] = channel_found.id
+            @rules_imported[user.name][dchannel] = channel_found.id
           else
-            @rules_imported[user.id][user.id] = channel_found.id
+            @rules_imported[user.name][user.name] = channel_found.id
           end
+          sleep 0.5
           update_rules_imported()
           respond "I'm using now the rules from <##{channel_found.id}>", dest
 

data/lib/slack/smart-bot/commands/{general → on_bot/general}/whats_new.rb

@@ -3,11 +3,12 @@ class SlackSmartBot
     # help: ----------------------------------------------
     # help: `What's new`
     # help:    It will display the last user changes on Slack Smart Bot
+    # help: command_id: :whats_new
     # help:
     def whats_new(user, dest, dchannel, from, display_name)
       if @status == :on
         save_stats(__method__)
-        whats_new_file = (__FILE__).gsub(/lib\/slack\/smart-bot\/commands\/general\/whats_new\.rb$/, "whats_new.txt")
+        whats_new_file = (__FILE__).gsub(/lib\/slack\/smart-bot\/commands\/on_bot\/general\/whats_new\.rb$/, "whats_new.txt")
         whats_new = File.read(whats_new_file)
         whats_new.split(/^\-\-\-\-\-\-+$/).each do |msg|
             respond msg

data/lib/slack/smart-bot/commands/on_bot/get_repl.rb

@@ -4,20 +4,19 @@ class SlackSmartBot
   # help: `get irb SESSION_NAME`
   # help: `get live SESSION_NAME`
   # help:     Will get the Ruby commands sent on that SESSION_NAME.
+  # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :get_repl
   # help:
   def get_repl(dest, user, session_name)
     #todo: add tests
     save_stats(__method__)
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       Dir.mkdir("#{config.path}/repl") unless Dir.exist?("#{config.path}/repl")
       Dir.mkdir("#{config.path}/repl/#{@channel_id}") unless Dir.exist?("#{config.path}/repl/#{@channel_id}")
       if File.exist?("#{config.path}/repl/#{@channel_id}/#{session_name}.run")
         if @repls.key?(session_name) and (@repls[session_name][:type] == :private or @repls[session_name][:type] == :private_clean) and 
           @repls[session_name][:creator_name]!=user.name and 
-          !config.admins.include?(user.name)
+          !is_admin?(user.name)
           respond "The REPL with session name: #{session_name} is private", dest
         else
           content = "require 'nice_http'\n"

data/lib/slack/smart-bot/commands/on_bot/repl.rb

@@ -17,9 +17,9 @@ class SlackSmartBot
   # help:     If 'clean' specified the repl won't pre execute the code written on the .smart-bot-repl file
   # help:     To avoid a message to be treated, start the message with '-'.
   # help:     Send _quit_, _bye_ or _exit_ to finish the session.
-  # help:     Send puts, print, p or pp if you want to print out something when using `run repl` later.
+  # help:     Send puts, print, p or pp if you want to print out something when using _run repl_ later.
   # help:     After 30 minutes of no communication with the Smart Bot the session will be dismissed.
-  # help:     If you declare on your rules file a method called `project_folder` returning the path for the project folder, the code will be executed from that folder. 
+  # help:     If you declare on your rules file a method called 'project_folder' returning the path for the project folder, the code will be executed from that folder. 
   # help:     By default it will be automatically loaded the gems: string_pattern, nice_hash and nice_http
   # help:     To pre-execute some ruby when starting the session add the code to .smart-bot-repl file on the project root folder defined on project_folder
   # help:     If you want to see the methods of a class or module you created use _ls TheModuleOrClass_
@@ -29,14 +29,13 @@ class SlackSmartBot
   # help:       _repl CreateCustomer: "It creates a random customer for testing" LOCATION=spain HOST='https://10.30.40.50:8887'_
   # help:       _repl delete_logs_
   # help:       _private repl random-ssn_
+  # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :repl
   # help:
   def repl(dest, user, session_name, env_vars, rules_file, command, description, type)
     #todo: add more tests
     from = user.name
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       if !@repl_sessions.key?(from)
         save_stats(__method__)
         Dir.mkdir("#{config.path}/repl") unless Dir.exist?("#{config.path}/repl")
@@ -80,11 +79,14 @@ class SlackSmartBot
           update_repls()        
         end
         react :running
+        @ts_react ||= {}
         if Thread.current[:ts].to_s == ''
-          @ts_react = Thread.current[:thread_ts]
+          @ts_react[session_name] = Thread.current[:thread_ts]
         else
-          @ts_react = Thread.current[:ts]
+          @ts_react[session_name] = Thread.current[:ts]
         end        
+        @ts_repl ||= {}
+        @ts_repl[session_name] = ''
 
         message = "Session name: *#{session_name}*
         From now on I will execute all you write as a Ruby command and I will keep the session open until you send `quit` or `bye` or `exit`. 
@@ -117,14 +119,14 @@ class SlackSmartBot
         end
 
         process_to_run = '
-            ruby -e "' + env_vars.join("\n") + '
+            ' + env_vars.join("\n") + '
             require \"amazing_print\"
             bindme' + serialt + ' = binding
             eval(\"require \'nice_http\'\" , bindme' + serialt + ')
             def ls(obj)
               (obj.methods - Object.methods)
             end
-            
+            file_run_path = \"' +  + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.rb\"
             file_input_repl = File.open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.input\", \"r\")
             ' + pre_execute + '
             while true do 
@@ -143,21 +145,43 @@ class SlackSmartBot
                   end
                   error = false
                   begin
-                    resp_repl = eval(code_to_run_repl.gsub(/^\s*(puts|print|p|pp)\s/, \"\"), bindme' + serialt + ')
+                    begin
+                      original_stdout = $stdout
+                      $stdout = StringIO.new 
+                      resp_repl = eval(code_to_run_repl, bindme' + serialt + ')
+                      stdout_repl = $stdout.string
+                    ensure 
+                      $stdout = original_stdout
+                    end
                   rescue Exception => resp_repl
                     error = true
                   end
-                  if resp_repl.to_s != \"\"
+                  if error
+                    open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
+                      f.puts \"\`\`\`\n#{resp_repl.to_s.gsub(/^.+' + session_name + '\.rb:\d+:/,\"\")}\`\`\`\"
+                    }
+                  else
                     if code_to_run_repl.match?(/^\s*p\s+/i)
+                      resp_repl = stdout_repl unless stdout_repl.to_s == \'\'
+                      if stdout_repl.to_s == \'\'
+                        resp_repl = resp_repl.inspect
+                      else
+                        resp_repl = stdout_repl 
+                      end
                       open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
-                        f.puts \"\`\`\`\n#{resp_repl.inspect}\n\`\`\`\"
+                        f.puts \"\`\`\`\n#{resp_repl}\`\`\`\"
                       }
                     else
+                      if stdout_repl.to_s == \'\'
+                        resp_repl = resp_repl.ai
+                      else
+                        resp_repl = stdout_repl 
+                      end
                       open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
-                        f.puts \"\`\`\`\n#{resp_repl.ai}\n\`\`\`\"
+                        f.puts \"\`\`\`\n#{resp_repl}\`\`\`\"
                       }
                     end
-                    unless error or !add_to_run_repl
+                    unless !add_to_run_repl
                       open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.run\", \"a+\") {|f|
                         f.puts code_to_run_repl
                       }
@@ -165,16 +189,35 @@ class SlackSmartBot
                   end
                 end
               end
-            end"
+            end
         '
         unless rules_file.empty? # to get the project_folder
           begin
             eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
           end
         end
-        started = Time.now
-        process_to_run = ("cd #{project_folder} &&" + process_to_run) if defined?(project_folder)
+        process_to_run.gsub!('\"','"')
+        file_run_path = "./tmp/repl/#{@channel_id}/#{session_name}.rb"
+        if defined?(project_folder)
+          Dir.mkdir("#{project_folder}/tmp/") unless Dir.exist?("#{project_folder}/tmp/")
+          Dir.mkdir("#{project_folder}/tmp/repl") unless Dir.exist?("#{project_folder}/tmp/repl")
+          Dir.mkdir("#{project_folder}/tmp/repl/#{@channel_id}/") unless Dir.exist?("#{project_folder}/tmp/repl/#{@channel_id}/")
+          file_run = File.open(file_run_path.gsub('./',"#{project_folder}/"), "w")
+          file_run.write process_to_run
+          file_run.close
+        else
+          Dir.mkdir("./tmp/") unless Dir.exist?("./tmp/")
+          Dir.mkdir("./tmp/repl") unless Dir.exist?("./tmp/repl")
+          Dir.mkdir("./tmp/repl/#{@channel_id}/") unless Dir.exist?("./tmp/repl/#{@channel_id}/")
+          file_run = File.open(file_run_path, "w")
+          file_run.write process_to_run
+          file_run.close
+        end
 
+        process_to_run = "ruby #{file_run_path}"
+
+        started = Time.now
+        process_to_run = ("cd #{project_folder} && " + process_to_run) if defined?(project_folder)
         stdin, stdout, stderr, wait_thr = Open3.popen3(process_to_run)
         timeout = 30 * 60 # 30 minutes
         
@@ -187,7 +230,7 @@ class SlackSmartBot
                   f.puts 'quit'
                 }
                 respond "REPL session finished: #{@repl_sessions[from][:name]}", dest
-                unreact :running, @ts_react
+                unreact :running, @ts_react[@repl_sessions[from].name]
                 pids = `pgrep -P #{@repl_sessions[from][:pid]}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
                 pids.each do |pid|
                   begin
@@ -201,6 +244,10 @@ class SlackSmartBot
             sleep 0.2
             resp_repl = file_output_repl.read
             if resp_repl.to_s!=''
+              if @ts_repl[@repl_sessions[from].name].to_s != ''
+                unreact(:running, @ts_repl[@repl_sessions[from].name]) 
+                @ts_repl[@repl_sessions[from].name] = ''
+              end
               if resp_repl.to_s.lines.count < 60 and resp_repl.to_s.size < 3500
                 respond resp_repl, dest
               else
@@ -213,6 +260,8 @@ class SlackSmartBot
             @logger.fatal excp
           end
         end
+      elsif @repl_sessions.key?(from) and @repl_sessions[from][:command].to_s == ''
+        respond 'You are already in a repl on this SmartBot. You need to quit that one before starting a new one.'
       else
         @repl_sessions[from][:finished] = Time.now
         code = @repl_sessions[from][:command]
@@ -226,7 +275,9 @@ class SlackSmartBot
           code.match?(/open3/i) or code.match?(/bundle/i) or code.match?(/gemfile/i) or code.include?("%x") or
           code.include?("ENV") or code.match?(/=\s*IO/) or code.include?("Dir.") or 
           code.match?(/=\s*File/) or code.match?(/=\s*Dir/) or code.match?(/<\s*File/) or code.match?(/<\s*Dir/) or
-          code.match?(/\w+:\s*File/) or code.match?(/\w+:\s*Dir/)
+          code.match?(/\w+:\s*File/) or code.match?(/\w+:\s*Dir/) or 
+          code.match?(/=?\s*(require|load)(\(|\s)/i)
+
           respond "Sorry I cannot run this due security reasons", dest
         else
           @repl_sessions[from][:input]<<code
@@ -236,7 +287,7 @@ class SlackSmartBot
               f.puts code
             }
             respond "REPL session finished: #{@repl_sessions[from][:name]}", dest
-            unreact :running, @ts_react
+            unreact :running, @ts_react[@repl_sessions[from].name]
             pids = `pgrep -P #{@repl_sessions[from][:pid]}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
             pids.each do |pid|
               begin
@@ -248,6 +299,10 @@ class SlackSmartBot
           when /^\s*-/i
             #ommit
           else
+            if @ts_repl[@repl_sessions[from].name].to_s == ''
+              @ts_repl[@repl_sessions[from].name] = Thread.current[:ts]
+              react :running 
+            end
             open("#{config.path}/repl/#{@channel_id}/#{@repl_sessions[from][:name]}.input", 'a+') {|f|
               f.puts code
             }

data/lib/slack/smart-bot/commands/on_bot/ruby_code.rb

@@ -5,14 +5,13 @@ class SlackSmartBot
   # help:     runs the code supplied and returns the output. Also you can send a Ruby file instead. Examples:
   # help:       _code puts (34344/99)*(34+14)_
   # help:       _ruby require 'json'; res=[]; 20.times {res<<rand(100)}; my_json={result: res}; puts my_json.to_json_
+  # help:     <https://github.com/MarioRuiz/slack-smart-bot#running-ruby-code-on-a-conversation|more info>
+  # help: command_id: :ruby_code
   # help:
 
   def ruby_code(dest, user, code, rules_file)
     save_stats(__method__)
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       unless code.match?(/System/i) or code.match?(/Kernel/i) or code.include?("File.") or
             code.include?("`") or code.include?("exec") or code.include?("spawn") or code.include?("IO.") or
             code.match?(/open3/i) or code.match?(/bundle/i) or code.match?(/gemfile/i) or code.include?("%x") or

data/lib/slack/smart-bot/commands/on_bot/run_repl.rb

@@ -9,21 +9,20 @@ class SlackSmartBot
   # help:     It will return only the values that were print out on the repl with puts, print, p or pp
   # help:     Example:
   # help:       _run repl CreateCustomer LOCATION=spain HOST='https://10.30.40.50:8887'_
+  # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :run_repl
   # help:
   def run_repl(dest, user, session_name, env_vars, rules_file)
     #todo: add tests
     from = user.name
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       save_stats(__method__)
       Dir.mkdir("#{config.path}/repl") unless Dir.exist?("#{config.path}/repl")
       Dir.mkdir("#{config.path}/repl/#{@channel_id}") unless Dir.exist?("#{config.path}/repl/#{@channel_id}")
       if File.exist?("#{config.path}/repl/#{@channel_id}/#{session_name}.run")
         if @repls.key?(session_name) and (@repls[session_name][:type] == :private or @repls[session_name][:type] == :private_clean) and 
           @repls[session_name][:creator_name]!=user.name and 
-          !config.admins.include?(user.name)
+          !is_admin?(user.name)
           respond "The REPL with session name: #{session_name} is private", dest
         else
           if @repls.key?(session_name) #not temp
@@ -43,7 +42,8 @@ class SlackSmartBot
               eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
             end
           end
-          if File.exist?("#{project_folder}/.smart-bot-repl") and @repls[session_name][:type] != :private_clean and @repls[session_name][:type] != :public_clean
+          if File.exist?("#{project_folder}/.smart-bot-repl") and 
+            ((@repls.key?(session_name) and @repls[session_name][:type] != :private_clean and @repls[session_name][:type] != :public_clean) or !@repls.key?(session_name))
             content += File.read("#{project_folder}/.smart-bot-repl")
             content += "\n"
           end
@@ -60,7 +60,15 @@ class SlackSmartBot
               respond "*#{session_name}*: Nothing returned."
             else
               if stdout.to_s.lines.count < 60 and stdout.to_s.size < 3500
-                respond "*#{session_name}*: #{stdout}"
+                output = ''
+                stdout.each_line do |line|
+                  if line.match?(/^{.+}$/) or line.match?(/^\[.+\]$/)
+                    output += "```\n#{line}```\n"
+                  else
+                    output +=line
+                  end
+                end
+                respond "*#{session_name}*: #{output}"
               else
                 send_file(dest, "", 'response.rb', "", 'text/plain', "ruby", content: stdout)
               end

data/lib/slack/smart-bot/commands/on_bot/see_repls.rb

@@ -2,19 +2,18 @@ class SlackSmartBot
   # help: ----------------------------------------------
   # help: `see repls`
   # help: `see irbs`
-  # help:    It will display the repls
+  # help:     It will display the repls
+  # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :see_repls
   # help:
   def see_repls(dest, user, typem)
     #todo: add tests
     save_stats(__method__)
     from = user.name
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       message = ""
       @repls.sort.to_h.each do |session_name, repl|
-        if (repl.creator_name == user.name or repl.type == :public or repl.type == :public_clean) or (config.admins.include?(user.name) and typem == :on_dm)
+        if (repl.creator_name == user.name or repl.type == :public or repl.type == :public_clean) or (is_admin?(user.name) and typem == :on_dm)
           message += "(#{repl.type}) *#{session_name}*: #{repl.description} / created: #{repl.created} / accessed: #{repl.accessed} / creator: #{repl.creator_name} / runs: #{repl.runs_by_creator+repl.runs_by_others} / gets: #{repl.gets} \n"
         end
       end

data/lib/slack/smart-bot/commands/on_bot/see_shortcuts.rb

@@ -3,14 +3,13 @@ class SlackSmartBot
   # help: `see shortcuts`
   # help: `see sc`
   # help:    It will display the shortcuts stored for the user and for :all
+  # help:    <https://github.com/MarioRuiz/slack-smart-bot#shortcuts|more info>
+  # help: command_id: :see_shortcuts
   # help:
   def see_shortcuts(dest, user, typem)
     save_stats(__method__)
     from = user.name
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       unless typem == :on_extended
         msg = ""
         if @shortcuts[:all].keys.size > 0 or @shortcuts_global[:all].keys.size > 0
@@ -30,7 +29,7 @@ class SlackSmartBot
         end
         msg2 = ''
         if @shortcuts.keys.include?(from) and @shortcuts[from].keys.size > 0
-          new_hash = @shortcuts[from].dup
+          new_hash = @shortcuts[from].deep_copy
           @shortcuts[:all].keys.each { |k| new_hash.delete(k) }
           if new_hash.keys.size > 0
             msg2 = "*Available shortcuts for #{from}:*\n"
@@ -40,7 +39,7 @@ class SlackSmartBot
           end
         end
         if @shortcuts_global.keys.include?(from) and @shortcuts_global[from].keys.size > 0
-          new_hash = @shortcuts_global[from].dup
+          new_hash = @shortcuts_global[from].deep_copy
           @shortcuts_global[:all].keys.each { |k| new_hash.delete(k) }
           if new_hash.keys.size > 0
             msg2 = "*Available shortcuts for #{from}:*\n" if msg2 == ''

data/lib/slack/smart-bot/commands/on_extended/bot_rules.rb

@@ -2,12 +2,9 @@ class SlackSmartBot
   def bot_rules(dest, help_command, typem, rules_file, user)
     save_stats(__method__)
     from = user.name
-    if config[:allow_access].key?(__method__) and !config[:allow_access][__method__].include?(user.name) and !config[:allow_access][__method__].include?(user.id) and 
-      (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
-      respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
-    else
+    if has_access?(__method__, user)
       if typem == :on_extended or typem == :on_call #for the other cases above.
-
+        output = []
         if help_command.to_s != ''
           help_command = '' if help_command.to_s.match?(/^\s*expanded\s*$/i) or help_command.to_s.match?(/^\s*extended\s*$/i)
           expanded = true
@@ -17,22 +14,47 @@ class SlackSmartBot
   
         help_filtered = get_help(rules_file, dest, from, true, expanded)
 
+        commands = []
+        commands_search = []
         if help_command.to_s != ""
           help_found = false
           help_filtered.split(/^\s*-------*$/).each do |h|
             if h.match?(/[`_]#{help_command}/i)
-              respond "*#{config.channel}*:#{h}", dest
+              output << "*#{config.channel}*:#{h}"
               help_found = true
+              commands << h
+            elsif !h.match?(/\A\s*\*/) and !h.match?(/\A\s*=+/) #to avoid general messages for bot help *General rules...*
+              all_found = true
+              help_command.to_s.split(' ') do |hc|
+                unless hc.match?(/^\s*\z/)
+                  if !h.match?(/#{hc}/i)
+                    all_found = false                  
+                  end
+                end
+              end
+              commands_search << h if all_found
+            end
+          end
+          if commands.size < 10 and help_command.to_s!='' and commands_search.size > 0
+            commands_search.shuffle!
+            (10-commands.size).times do |n|
+              unless commands_search[n].nil?
+                output << commands_search[n]
+                help_found = true
+              end
             end
           end
-          respond("*#{config.channel}*: I didn't find any command starting by `#{help_command}`", dest) unless help_found
+          unless help_found
+            output << "*#{config.channel}*: I didn't find any command with `#{help_command}`"
+          end
+
         else
           message = "-\n\n\n===================================\n*Rules from channel #{config.channel}*\n"
           if typem == :on_extended
             message += "To run the commands on this extended channel, add `!`, `!!` or `^` before the command.\n"
           end
           message += help_filtered
-          respond message, dest
+          output << message
         end
 
         unless rules_file.empty?
@@ -41,16 +63,27 @@ class SlackSmartBot
           end
         end
         if defined?(git_project) and git_project.to_s != "" and help_command.to_s == ""
-          respond "Git project: #{git_project}", dest
+          output << "Git project: #{git_project}"
         else
           def git_project() "" end
           def project_folder() "" end
         end
         unless expanded
-          message_not_expanded = "*If you want to see the expanded version of `bot rules`, please call `bot rules expanded`*\n"
-          message_not_expanded += "*Also to get specific expanded help for a specific command or rule call `bot rules COMMAND`*\n"
-          respond message_not_expanded
+          message_not_expanded = "If you want to see the *expanded* version of *`bot rules`*, please call  *`bot rules expanded`*\n"
+          message_not_expanded += "Also to get specific *expanded* help for a specific command or rule call *`bot rules COMMAND`*\n"
+          output << message_not_expanded
+        end
+        if output.join("\n").lines.count > 50 and dest[0]!='D'
+          dest = :on_thread
+          output.unshift('Since there are many lines returned the results are returned on a thread by default.')
+        end
+        output.each do |h|
+          msg = h.gsub(/^\s*command_id:\s+:\w+\s*$/,'')
+          unless msg.match?(/\A\s*\z/)
+            respond msg, dest, unfurl_links: false, unfurl_media: false
+          end
         end
+    
       end
     end
   end

data/lib/slack/smart-bot/commands/on_master/admin/kill_bot_on_channel.rb

@@ -3,6 +3,8 @@ class SlackSmartBot
   # helpmaster: `kill bot on CHANNEL_NAME`
   # helpmaster:    kills the bot on the specified channel
   # helpmaster:    Only works if you are on Master channel and you created that bot or you are an admin user
+  # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpmaster: command_id: :kill_bot_on_channel
   # helpmaster:
   def kill_bot_on_channel(dest, from, channel)
     save_stats(__method__)
@@ -18,14 +20,16 @@ class SlackSmartBot
       if channel_id.nil?
         respond "There is no channel with that name: #{channel}, please be sure is written exactly the same", dest
       elsif @bots_created.keys.include?(channel_id)
-        if @bots_created[channel_id][:admins].split(",").include?(from)
+        @bots_created[channel_id] ||= {}
+        if @bots_created[channel_id][:admins].to_s.split(",").include?(from) # todo: consider adding is_admin?
           if @bots_created[channel_id][:thread].kind_of?(Thread) and @bots_created[channel_id][:thread].alive?
             @bots_created[channel_id][:thread].kill
           end
           @bots_created.delete(channel_id)
-          update_bots_file()
-          respond "Bot on channel: #{channel}, has been killed and deleted.", dest
           send_msg_channel(channel, "Bot has been killed by #{from}")
+          respond "Bot on channel: #{channel}, has been killed and deleted.", dest
+          save_status :off, :killed, "The admin killed SmartBot on *##{@channels_name[channel_id]}*"
+          update_bots_file()
         else
           respond "You need to be the creator or an admin of that bot channel", dest
         end

data/lib/slack/smart-bot/commands/on_master/admin_master/exit_bot.rb

@@ -6,11 +6,13 @@ class SlackSmartBot
   # helpadmin: `close bot`
   # helpadmin:    The bot stops running and also stops all the bots created from this master channel
   # helpadmin:    You can use this command only if you are an admin user and you are on the master channel
+  # helpadmin:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpadmin: command_id: :exit_bot
   # helpadmin:
   def exit_bot(command, from, dest, display_name)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if answer.empty?
           ask("are you sure?", command, from, dest)
         else
@@ -21,6 +23,7 @@ class SlackSmartBot
             @bots_created.each { |key, value|
               value[:thread] = ""
               send_msg_channel(key, "Bot has been closed by #{from}")
+              save_status :off, :exited, "The admin closed SmartBot on *##{value.channel_name}*"
               sleep 0.5
             }
             update_bots_file()

data/lib/slack/smart-bot/commands/on_master/admin_master/notify_message.rb

@@ -7,11 +7,13 @@ class SlackSmartBot
   # helpmaster:    It will send a notification message to all channels the bot joined and private conversations with the bot
   # helpmaster:    It will send a notification message to the specified channel and to its extended channels
   # helpmaster:    Only works if you are on Master channel and you are a master admin user
+  # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#sending-notifications|more info>
+  # helpmaster: command_id: :notify_message
   # helpmaster:
   def notify_message(dest, from, where, message)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if where.nil? #not all and not channel
           @bots_created.each do |k, v|
             respond message, k