slack-smart-bot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ad8c9b6d08d27ac0fa0f03b054b39032a2228f25082433b2d58d400dfabbc99
+  data.tar.gz: 7a37e23992b269849aa522a5f25865f8e143a22ced0777b6fb08fc1cec05bc3f
+SHA512:
+  metadata.gz: 1388d4e8eff5990665fcf8da616eec0164d242b9b87fdb667c018894e465c76bd00cd709aebaf5bf26a0421f29692d81e1d3f80c46388f559c46023176762890
+  data.tar.gz: 00e0ba16a2b50d6bf64582bc3e8443694a473732a6c02175097be935c1ee252984ecbc151fe225aab0ceaa9aaf0b7d3ab286d0c7992cfe4794fcfdaa95267dc9

data/.yardopts

@@ -0,0 +1,5 @@
+--readme README.md
+--title 'slack-smart-bot - Create a Slack bot that is smart and easy to expand.'
+--charset utf-8
+--markup markdown
+'lib/**/*.rb' - '*.md' - 'LICENSE'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Mario Ruiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,248 @@
+# Slack Smart Bot
+
+[![Gem Version](https://badge.fury.io/rb/slack-smart-bot.svg)](https://rubygems.org/gems/slack-smart-bot)
+
+Create a Slack bot that is really smart and so easy to expand.
+
+The main scope of this ruby gem is to be used internally in your company so teams can create team channels with their own bot to help them on their daily work, almost everything is suitable to be automated!!
+
+slack-smart-bot can create bots on demand, create shortcuts, run ruby code... just on a chat channel, you can access it just from your mobile phone if you want and run those tests you forgot to run, get the results, restart a server... no limits.
+
+## Installation and configuration
+
+    $ gem install slack-smart-bot
+    
+After you install it you will need just a couple of things to configure it.
+
+Create a file like this on the folder you want:
+
+```ruby
+# the channel that will act like the master channel, main channel
+MASTER_CHANNEL="my_master_channel"
+#names of the master users
+MASTER_USERS=["mario"]
+
+require 'slack-smart-bot'
+
+settings = {
+    nick: 'my_smart_bot', # the smart bot name
+    token: 'xxxxxxxxxxxxxxxxxx' # the API Slack token
+}
+
+SlackSmartBot.new(settings).listen
+```
+
+The MASTER_CHANNEL will be the channel where you will be able to create other bots and will have special treatment.
+
+The MASTER_USERS will have full access to everything. The names should be written exactly the same like they appear on Slack.
+
+For the token remember you need to generate a token on the Slack web for the bot user.
+
+This is something done in Slack, under [integrations](https://my.slack.com/services). Create a [new bot](https://my.slack.com/services/new/bot), and note its API token.
+
+*Remember to invite the smart bot to the channels where they will be accessible before creating the bot*
+
+## Usage
+
+### creating the MASTER BOT
+Let's guess the file you created was called my_smart_bot.rb so, just run it:
+```
+ruby my_smart_bot.rb
+```
+
+After the run, it will be generated a rules file with the same name but adding _rules, in this example: my_smart_bot_rules.rb
+
+The rules file can be edited and will be only affecting this particular bot.
+
+You can add all the rules you want for your bot in the rules file, this is an example:
+
+```ruby
+def rules(from, command, processed)
+  firstname = from.split(" ").first
+  case command
+
+    # help: `echo SOMETHING`
+    # help:     repeats SOMETHING
+    # help:
+    when /echo\s(.+)/i
+      respond $1
+
+    # help: `go to sleep`
+    # help:   it will sleep the bot for 10 seconds
+    # help:
+    when /go\sto\ssleep/i
+      unless @questions.keys.include?(from)
+        ask("do you want me to take a siesta?", command, from)
+      else
+        case @questions[from]
+          when /yes/i, /yep/i, /sure/i
+            respond "zZzzzzzZZZZZZzzzzzzz!"
+            respond "I'll be sleeping for 10 secs... just for you"
+            sleep 10
+          when /no/i, /nope/i, /cancel/i
+            @questions.delete(from)
+            respond "Thanks, I'm happy to be awake"
+          else
+            respond "I don't understand"
+            ask("are you sure do you want me to sleep? (yes or no)", "go to sleep", from)
+        end
+      end
+    else
+      unless processed
+        resp = %w{ what huh sorry }.sample
+        respond "#{firstname}: #{resp}?"
+      end
+  end
+end
+
+```
+### How to access the smart bot
+You can access the bot directly on the MASTER CHANNEL, on a secondary channel where the bot is running and directly by opening a private chat with the bot, in this case the conversation will be just between you and the bot.
+
+### Available commands even when the bot is not listening to you
+Some of the commands are available always even when the bot is not listening to you but it is running
+
+**_`bot help`_**
+
+**_`bot what can I do?`_**
+
+>It will display all the commands we can use
+>What is displayed by this command is what is written on your rules file like this: #help: THE TEXT TO SHOW
+
+**_`Hello Bot`_**
+
+**_`Hello THE_NAME_OF_THE_BOT`_**
+
+>Also apart of Hello you can use Hallo, Hi, Hola, What's up, Hey, Hæ
+
+>Bot starts listening to you
+
+**_`Bye Bot`_**
+
+**_`Bye THE_NAME_OF_THE_BOT`_**
+
+>Also apart of Bye you can use Bæ, Good Bye, Adiós, Ciao, Bless, Bless Bless, Adeu
+
+>Bot stops listening to you
+
+**_`exit bot`_**
+
+**_`quit bot`_**
+
+**_`close bot`_**
+
+>The bot stops running and also stops all the bots created from this master channel
+
+>You can use this command only if you are an admin user and you are on the master channel
+
+**_`start bot`_**
+
+**_`start this bot`_**
+
+>The bot will start to listen
+
+>You can use this command only if you are an admin user
+
+**_`pause bot`_**
+
+**_`pause this bot`_**
+
+>The bot will pause so it will listen only to admin commands
+
+>You can use this command only if you are an admin user
+
+**_`bot status`_**
+   
+>Displays the status of the bot
+
+>If on master channel and admin user also it will display info about bots created
+
+**_`create bot on CHANNEL_NAME`_**
+
+>Creates a new bot on the channel specified. 
+
+>slack-smart-bot will create a default rules file specific for your channel. 
+You can edit it and add the rules you want. 
+As soon as you save the file after editing it will become available on your channel.
+
+>It will work only if you are on Master channel
+
+**_`kill bot on CHANNEL_NAME`_**
+
+>Kills the bot on the specified channel
+
+>Only works if you are on Master channel and you created that bot or you are an admin user
+
+### Available commands only when listening to you or on demand
+
+All the commands described on here or on your specific Rules file can be used when the bot is listening to you or on demand.
+
+For the bot to start listening to you you need to use the "Hi bot" command or one of the aliases
+
+Also you can call any of these commands on demand by using:
+
+**_`!THE_COMMAND`_**
+
+**_`@bot THE_COMMAND`_**
+
+**_`@smart THE_COMMAND`_**
+
+**_`@BOT_NAME THE_COMMAND`_**
+
+**_`BOT_NAME THE_COMMAND`_**
+
+Apart of the specific commands you define on the rules file of the channel, you can use:
+
+**_`ruby RUBY_CODE`_**
+
+**_`code RUBY_CODE`_**
+
+>runs the code supplied and returns the output. Examples:
+
+>code puts (34344/99)*(34+14)
+
+>ruby require 'json'; res=[]; 20.times {res<<rand(100)}; my_json={result: res}; puts my_json.to_json
+
+
+**_`add shortcut NAME: COMMAND`_**
+
+**_`add shortcut for all NAME: COMMAND`_**
+
+**_`shortchut NAME: COMMAND`_**
+
+**_`shortchut for all NAME: COMMAND`_**
+
+>It will add a shortcut that will execute the command we supply.
+
+>In case we supply 'for all' then the shorcut will be available for everybody
+
+>Example:
+>add shortcut for all Spanish account: /code require 'iso/iban'; 10.times {puts ISO::IBAN.random('ES')}
+
+>Then to call this shortcut:
+
+>sc spanish account
+
+>shortcut Spanish Account
+
+**_`delete shortcut NAME`_**
+
+>It will delete the shortcut with the supplied name
+
+**_`see shortcuts`_**
+
+>It will display the shortcuts stored for the user and for :all
+
+**_`id channel CHANNEL_NAME`_**
+>shows the id of a channel name
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/slack-smart-bot.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/slack-smart-bot.rb

@@ -0,0 +1,681 @@
+require "slack-ruby-client"
+require "open-uri"
+require "cgi"
+require "json"
+require "logger"
+require "fileutils"
+require "open3"
+
+if ARGV.size == 0
+  CHANNEL = MASTER_CHANNEL
+  ON_MASTER_CHANNEL = true
+  ADMIN_USERS = MASTER_USERS
+  RULES_FILE = "#{$0.gsub(".rb", "_rules.rb")}" unless defined?(RULES_FILE)
+  unless File.exist?(RULES_FILE)
+    default_rules = (__FILE__).gsub(/\.rb$/, "_rules.rb")
+    FileUtils.copy_file(default_rules, RULES_FILE)
+  end
+  STATUS_INIT = :on
+else
+  ON_MASTER_CHANNEL = false
+  CHANNEL = ARGV[0]
+  ADMIN_USERS = ARGV[1].split(",")
+  RULES_FILE = ARGV[2]
+  STATUS_INIT = ARGV[3].to_sym
+end
+
+SHORTCUTS_FILE = "slack-smart-bot_shortcuts_#{CHANNEL}.rb".gsub(" ", "_")
+
+class SlackSmartBot
+  attr_accessor :config, :client, :wclient
+
+  def initialize(config)
+    Dir.mkdir("./logs") unless Dir.exist?("./logs")
+    Dir.mkdir("./shortcuts") unless Dir.exist?("./shortcuts")
+    logfile = File.basename(RULES_FILE.gsub("_rules_", "_logs_"), ".rb") + ".log"
+    @logger = Logger.new("./logs/#{logfile}")
+    config_log = config.dup
+    config_log.delete(:token)
+    @logger.info "Initializing bot: #{config_log.inspect}"
+
+    config[:channel] = CHANNEL
+    self.config = config
+
+    Slack.configure do |conf|
+      conf.token = config[:token]
+    end
+    self.wclient = Slack::Web::Client.new
+    self.client = Slack::RealTime::Client.new
+
+    @listening = Array.new
+
+    @bots_created = Hash.new()
+    @shortcuts = Hash.new()
+    @shortcuts[:all] = Hash.new()
+
+    if File.exist?("./shortcuts/#{SHORTCUTS_FILE}")
+      file_sc = IO.readlines("./shortcuts/#{SHORTCUTS_FILE}").join
+      unless file_sc.to_s() == ""
+        @shortcuts = eval(file_sc)
+      end
+    end
+
+    if ON_MASTER_CHANNEL and File.exist?($0.gsub(".rb", "_bots.rb"))
+      file_conf = IO.readlines($0.gsub(".rb", "_bots.rb")).join
+      unless file_conf.to_s() == ""
+        @bots_created = eval(file_conf)
+        if @bots_created.kind_of?(Hash)
+          @bots_created.each { |key, value|
+            @logger.info "ruby #{$0} \"#{value[:channel_name]}\" \"#{value[:admins]}\" \"#{value[:rules_file]}\" #{value[:status].to_sym}"
+            t = Thread.new do
+              `ruby #{$0} \"#{value[:channel_name]}\" \"#{value[:admins]}\" \"#{value[:rules_file]}\" #{value[:status].to_sym}`
+            end
+            value[:thread] = t
+          }
+        end
+      end
+    end
+
+    wclient.auth_test
+
+    begin
+      user_info = wclient.users_info(user: "#{"@" if config[:nick][0] != "@"}#{config[:nick]}")
+      config[:nick_id] = user_info.user.id
+    rescue Exception => stack
+      @logger.fatal stack
+      abort("The bot user specified on settings: #{config[:nick]}, doesn't exist on Slack. Execution aborted")
+    end
+
+    client.on :hello do
+      m = "Successfully connected, welcome '#{client.self.name}' to the '#{client.team.name}' team at https://#{client.team.domain}.slack.com."
+      puts m
+      @logger.info m
+      respond "Smart Bot started\nIf you want to know what I can do for you: *`bot help`*\nYou can send me also a direct message."
+    end
+
+    @status = STATUS_INIT
+    @questions = Hash.new()
+    @channels_id = Hash.new()
+    @channels_name = Hash.new()
+    get_channels_name_and_id()
+    self
+  end
+
+  def update_bots_file
+    file = File.open($0.gsub(".rb", "_bots.rb"), "w")
+    bots_created = @bots_created.dup
+    bots_created.each { |k, v| v[:thread] = "" }
+    file.write bots_created.inspect
+    file.close
+  end
+
+  def update_shortcuts_file
+    file = File.open("./shortcuts/#{SHORTCUTS_FILE}", "w")
+    file.write @shortcuts.inspect
+    file.close
+  end
+
+  def get_channels_name_and_id
+    channels = wclient.channels_list.channels
+    @channels_id = Hash.new()
+    @channels_name = Hash.new()
+    channels.each do |ch|
+      unless ch.is_archived
+        @channels_id[ch.name] = ch.id
+        @channels_name[ch.id] = ch.name
+      end
+    end
+  end
+
+  def listen
+    @salutations = [config[:nick], config[:nick_id], "bot", "smart"]
+    client.on :message do |data|
+      if data.channel[0] == "D" #Direct message
+        id_user = data.user
+      else
+        id_user = nil
+      end
+      user_info = wclient.users_info(user: data.user)
+      if !id_user.nil? or @channels_id[CHANNEL] == data.channel or user_info.user.name == config[:nick]
+        res = process_first(user_info.user.name, data.text, id_user)
+        next if res.to_s == "next"
+      end
+    end
+
+    @logger.info "Bot listening"
+    client.start!
+  end
+
+  def process_first(nick, text, id_user)
+    #todo: verify if on slack on anytime nick == config[:nick]
+    if nick == config[:nick] or nick == (config[:nick] + " · Bot") #if message is coming from the bot
+      begin
+        @logger.info "#{nick}: #{text}"
+        case text
+        when /^Bot has been killed by/
+          exit!
+        when /^Changed status on (.+) to :(.+)/i
+          channel = $1
+          status = $2
+          @bots_created[channel][:status] = status.to_sym
+          update_bots_file()
+        end
+        return :next #don't continue analyzing
+      rescue Exception => stack
+        @logger.fatal stack
+        return :next
+      end
+    end
+
+    if text.match?(/^!?(shortcut|sc)\s(.+)/i)
+      shortcut = text.scan(/!?\w+\s*(.+)\s*/i).join.downcase
+      if text[0] == "!"
+        addexcl = true
+      else
+        addexcl = false
+      end
+      if @shortcuts.keys.include?(nick) and @shortcuts[nick].keys.include?(shortcut)
+        text = @shortcuts[nick][shortcut].dup
+      elsif @shortcuts.keys.include?(:all) and @shortcuts[:all].keys.include?(shortcut)
+        text = @shortcuts[:all][shortcut].dup
+      else
+        respond "Shortcut not found", id_user
+        return :next
+      end
+      text = "!" + text if addexcl and text[0] != "!"
+    end
+
+    if @questions.keys.include?(nick)
+      command = @questions[nick]
+      @questions[nick] = text
+    else
+      command = text
+    end
+    begin
+      t = Thread.new do
+        begin
+          processed = process(nick, command, id_user)
+          @logger.info "command: #{nick}> #{command}" if processed
+          if @status == :on and
+             ((@questions.keys.include?(nick) or
+               @listening.include?(nick) or
+               !id_user.nil? or
+               command.match?(/^@?#{@salutations.join("|")}:*\s+(.+)$/i) or
+               command.match?(/^<@#{@salutations.join("|")}>\s+(.+)$/i) or
+               command.match?(/^!(.+)$/)))
+            @logger.info "command: #{nick}> #{command}" unless processed
+            begin
+              eval(File.new(RULES_FILE).read) if File.exist?(RULES_FILE)
+            rescue Exception => stack
+              @logger.fatal "ERROR ON RULES FILE: #{RULES_FILE}"
+              @logger.fatal stack
+            end
+            if defined?(rules)
+              command[0] = "" if command[0] == "!"
+              command.gsub!(/^@\w+:*\s*/, "")
+              rules(nick, command, processed, id_user)
+            else
+              @logger.warn "It seems like rules method is not defined"
+            end
+          end
+        rescue Exception => stack
+          @logger.fatal stack
+        end
+      end
+    rescue => e
+      @logger.error "exception: #{e.inspect}"
+    end
+  end
+
+  #help: *Commands you can use*:
+  #help:
+  def process(from, command, id_user)
+    firstname = from.split(/ /).first
+    processed = true
+
+    case command
+
+    #help: `Hello Bot`
+    #help: `Hello Smart`
+    #help: `Hello THE_NAME_OF_THE_BOT`
+    #help: Also apart of Hello you can use _Hallo, Hi, Hola, What's up, Hey, Hæ_
+    #help:    Bot starts listening to you
+    #help:
+    when /^(Hello|Hallo|Hi|Hola|What's\sup|Hey|Hæ)\s(#{@salutations.join("|")})\s*$/i
+      if @status == :on
+        greetings = ["Hello", "Hallo", "Hi", "Hola", "What's up", "Hey", "Hæ"].sample
+        respond "#{greetings} #{firstname}", id_user
+        @listening << from unless @listening.include?(from)
+      end
+
+      #help: `Bye Bot`
+      #help: `Bye Smart`
+      #help: `Bye NAME_OF_THE_BOT`
+      #help: Also apart of Bye you can use _Bæ, Good Bye, Adiós, Ciao, Bless, Bless Bless, Adeu_
+      #help:    Bot stops listening to you
+      #help:
+    when /^(Bye|Bæ|Good\sBye|Adiós|Ciao|Bless|Bless\sBless|Adeu)\s(#{@salutations.join("|")})\s*$/i
+      if @status == :on
+        bye = ["Bye", "Bæ", "Good Bye", "Adiós", "Ciao", "Bless", "Bless bless", "Adeu"].sample
+        respond "#{bye} #{firstname}", id_user
+        @listening.delete(from)
+      end
+
+      #help: `exit bot`
+      #help: `quit bot`
+      #help: `close bot`
+      #help:    The bot stops running and also stops all the bots created from this master channel
+      #help:    You can use this command only if you are an admin user and you are on the master channel
+      #help:
+    when /^exit\sbot/i, /^quit\sbot/i, /^close\sbot/i
+      if ON_MASTER_CHANNEL
+        if ADMIN_USERS.include?(from) #admin user
+          unless @questions.keys.include?(from)
+            ask("are you sure?", command, from, id_user)
+          else
+            case @questions[from]
+            when /yes/i, /yep/i, /sure/i
+              respond "Game over!", id_user
+              respond "Ciao #{firstname}!", id_user
+              @bots_created.each { |key, value|
+                value[:thread] = ""
+                send_msg_channel(key, "Bot has been closed by #{from}")
+                sleep 0.5
+              }
+              update_bots_file()
+              sleep 0.5
+              exit!
+            when /no/i, /nope/i, /cancel/i
+              @questions.delete(from)
+              respond "Thanks, I'm happy to be alive", id_user
+            else
+              respond "I don't understand", id_user
+              ask("are you sure do you want me to close? (yes or no)", "quit bot", from, id_user)
+            end
+          end
+        else
+          respond "Only admin users can kill me", id_user
+        end
+      else
+        respond "To do this you need to be an admin user in the master channel", id_user
+      end
+
+      #help: `start bot`
+      #help: `start this bot`
+      #help:    the bot will start to listen
+      #help:    You can use this command only if you are an admin user
+      #help:
+    when /^start\s(this\s)?bot$/i
+      if ADMIN_USERS.include?(from) #admin user
+        respond "This bot is running and listening from now on. You can pause again: pause this bot", id_user
+        @status = :on
+        unless ON_MASTER_CHANNEL
+          get_channels_name_and_id() unless @channels_name.keys.include?(MASTER_CHANNEL) and @channels_name.keys.include?(CHANNEL)
+          send_msg_channel @channels_name[MASTER_CHANNEL], "Changed status on #{@channels_name[CHANNEL]} to :on"
+        end
+      else
+        respond "Only admin users can change my status", id_user
+      end
+
+      #help: `pause bot`
+      #help: `pause this bot`
+      #help:    the bot will pause so it will listen only to admin commands
+      #help:    You can use this command only if you are an admin user
+      #help:
+    when /^pause\s(this\s)?bot$/i
+      if ADMIN_USERS.include?(from) #admin user
+        respond "This bot is paused from now on. You can start it again: start this bot", id_user
+        respond "zZzzzzZzzzzZZZZZZzzzzzzzz", id_user
+        @status = :paused
+        unless ON_MASTER_CHANNEL
+          get_channels_name_and_id() unless @channels_name.keys.include?(MASTER_CHANNEL) and @channels_name.keys.include?(CHANNEL)
+          send_msg_channel @channels_name[MASTER_CHANNEL], "Changed status on #{@channels_name[CHANNEL]} to :paused"
+        end
+      else
+        respond "Only admin users can put me on pause", id_user
+      end
+
+      #help: `bot status`
+      #help:    Displays the status of the bot
+      #help:    If on master channel and admin user also it will display info about bots created
+      #help:
+    when /^bot\sstatus/i
+      respond "Status: #{@status}. Rules file: #{File.basename RULES_FILE} ", id_user
+      if @status == :on
+        respond "I'm listening to [#{@listening.join(", ")}]", id_user
+        if ON_MASTER_CHANNEL and ADMIN_USERS.include?(from)
+          @bots_created.each { |key, value|
+            respond "#{key}: #{value}", id_user
+          }
+        end
+      end
+
+      #help: `create bot on CHANNEL_NAME`
+      #help:    creates a new bot on the channel specified
+      #help:    it will work only if you are on Master channel
+      #help:
+    when /^create\sbot\son\s(.+)\s*/i
+      if ON_MASTER_CHANNEL
+        channel = $1
+        if @bots_created.keys.include?(channel)
+          respond "There is already a bot in this channel: #{channel}, kill it before", id_user
+        else
+          get_channels_name_and_id() unless @channels_name.keys.include?(channel) or @channels_id.keys.include?(channel)
+          channel_id = nil
+          if @channels_name.key?(channel) #it is an id
+            channel_id = channel
+          elsif @channels_id.key?(channel) #it is a channel name
+            channel_id = @channels_id[channel]
+          end
+
+          if !channel_id.nil?
+            if channel_id != config[:channel]
+              begin
+                rules_file = "slack-smart-bot_rules_#{channel_id}_#{from.gsub(" ", "_")}.rb"
+                if defined?(RULES_FOLDER)
+                  rules_file = RULES_FOLDER + rules_file
+                else
+                  Dir.mkdir("rules") unless Dir.exist?("rules")
+                  Dir.mkdir("rules/#{channel_id}") unless Dir.exist?("rules/#{channel_id}")
+                  rules_file = "./rules/#{channel_id}/" + rules_file
+                end
+                default_rules = (__FILE__).gsub(/\.rb$/, "_rules.rb")
+                File.delete(rules_file) if File.exist?(rules_file)
+                FileUtils.copy_file(default_rules, rules_file) unless File.exist?(rules_file)
+                admin_users = Array.new()
+                admin_users = [from] + MASTER_USERS
+                admin_users.uniq!
+                @logger.info "ruby #{$0} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on"
+                t = Thread.new do
+                  `ruby #{$0} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on`
+                end
+                @bots_created[channel] = {
+                  creator_name: from,
+                  channel_id: channel_id,
+                  channel_name: @channels_name[channel_id],
+                  status: :on,
+                  created: Time.now.strftime("%Y-%m-%dT%H:%M:%S.000Z")[0..18],
+                  rules_file: rules_file,
+                  admins: admin_users.join(","),
+                  thread: t,
+                }
+                respond "The bot has been created on channel: #{channel}. Rules file: #{File.basename rules_file}", id_user
+                update_bots_file()
+              rescue Exception => stack
+                @logger.fatal stack
+                message = "Problem creating the bot on channel #{channel}. Error: <#{stack}>."
+                @logger.error message
+                respond message, id_user
+              end
+            else
+              respond "There is already a bot in this channel: #{channel}, and it is the Master Channel!", id_user
+            end
+          else
+            respond "There is no channel with that name: #{channel}, please be sure is written exactly the same", id_user
+          end
+        end
+      else
+        respond "Sorry I cannot create bots from this channel, please visit the master channel", id_user
+      end
+
+      #help: `kill bot on CHANNEL_NAME`
+      #help:    kills the bot on the specified channel
+      #help:    Only works if you are on Master channel and you created that bot or you are an admin user
+      #help:
+    when /^kill\sbot\son\s(.+)\s*/i
+      if ON_MASTER_CHANNEL
+        channel = $1
+        if @bots_created.keys.include?(channel)
+          if @bots_created[channel][:admins].split(",").include?(from)
+            if @bots_created[channel][:thread].kind_of?(Thread) and @bots_created[channel][:thread].alive?
+              @bots_created[channel][:thread].kill
+            end
+            @bots_created.delete(channel)
+            update_bots_file()
+            respond "Bot on channel: #{channel}, has been killed and deleted.", id_user
+            send_msg_channel(channel, "Bot has been killed by #{from}")
+          else
+            respond "You need to be the creator or an admin of that channel", id_user
+          end
+        else
+          respond "There is no bot in this channel: #{channel}", id_user
+        end
+      else
+        respond "Sorry I cannot kill bots from this channel, please visit the master channel", id_user
+      end
+
+      #help: `bot help`
+      #help: `bot what can I do?`
+      #help:    it will display this help
+      #help:
+    when /^bot help/i, /^bot,? what can I do/i
+      help_message = IO.readlines(__FILE__).join
+      help_message_rules = IO.readlines(RULES_FILE).join
+      respond help_message.scan(/#\s*help\s*:(.*)/).join("\n"), id_user
+      respond help_message_rules.scan(/#\s*help\s*:(.*)/).join("\n"), id_user
+    else
+      processed = false
+    end
+
+    #only when :on and (listening or on demand or direct message)
+    if @status == :on and
+       ((@questions.keys.include?(from) or
+         @listening.include?(from) or
+         !id_user.nil? or
+         command.match?(/^@?#{@salutations.join("|")}:*\s+(.+)$/i) or
+         command.match?(/^!(.+)$/)))
+      processed2 = true
+
+      # help:
+      # help: *These commands will run only when the smart bot is listening to you or on demand*, for example:
+      # help:       `!THE_COMMAND`
+      # help:       `@bot THE_COMMAND`
+      # help:       `@NAME_OF_BOT THE_COMMAND`
+      # help:       `NAME_OF_BOT THE_COMMAND`
+      # help:
+      case command
+
+      #help: `add shortcut NAME: COMMAND`
+      #help: `add shortcut for all NAME: COMMAND`
+      #help: `shortchut NAME: COMMAND`
+      #help: `shortchut for all NAME: COMMAND`
+      #help:    It will add a shortcut that will execute the command we supply.
+      #help:    In case we supply 'for all' then the shorcut will be available for everybody
+      #help:    Example:
+      #help:        `add shortcut for all Spanish account: code require 'iso/iban'; 10.times {puts ISO::IBAN.random('ES')}`
+      #help:    Then to call this shortcut:
+      #help:        `sc spanish account`
+      #help:        `shortcut Spanish Account`
+      #help:
+      when /(add\s)?shortcut\s(for\sall)?\s*(.+):\s(.+)/i
+        for_all = $2
+        shortcut_name = $3.to_s.downcase
+        command_to_run = $4
+        @shortcuts[from] = Hash.new() unless @shortcuts.keys.include?(from)
+
+        if !ADMIN_USERS.include?(from) and @shortcuts[:all].include?(shortcut_name) and !@shortcuts[from].include?(shortcut_name)
+          respond "Only the creator of the shortcut or an admin user can modify it", id_user
+        elsif !@shortcuts[from].include?(shortcut_name)
+          #new shortcut
+          @shortcuts[from][shortcut_name] = command_to_run
+          @shortcuts[:all][shortcut_name] = command_to_run if for_all.to_s != ""
+          update_shortcuts_file()
+          respond "shortcut added", id_user
+        else
+
+          #are you sure? to avoid overwriting existing
+          unless @questions.keys.include?(from)
+            ask("The shortcut already exists, are you sure you want to overwrite it?", command, from, id_user)
+          else
+            case @questions[from]
+            when /^(yes|yep)/i
+              @shortcuts[from][shortcut_name] = command_to_run
+              @shortcuts[:all][shortcut_name] = command_to_run if for_all.to_s != ""
+              update_shortcuts_file()
+              respond "shortcut added", id_user
+              @questions.delete(from)
+            when /^no/i
+              respond "ok, I won't add it", id_user
+              @questions.delete(from)
+            else
+              respond "I don't understand, yes or no?", id_user
+            end
+          end
+        end
+
+        #help: `delete shortcut NAME`
+        #help:    It will delete the shortcut with the supplied name
+        #help:
+      when /delete\sshortcut\s(.+)/i
+        shortcut = $1.to_s.downcase
+        deleted = false
+
+        if !ADMIN_USERS.include?(from) and @shortcuts[:all].include?(shortcut) and !@shortcuts[from].include?(shortcut)
+          respond "Only the creator of the shortcut or an admin user can delete it", id_user
+        elsif (@shortcuts.keys.include?(from) and @shortcuts[from].keys.include?(shortcut)) or
+              (ADMIN_USERS.include?(from) and @shortcuts[:all].include?(shortcut))
+          #are you sure? to avoid deleting by mistake
+          unless @questions.keys.include?(from)
+            ask("are you sure you want to delete it?", command, from, id_user)
+          else
+            case @questions[from]
+            when /^(yes|yep)/i
+              respond "shortcut deleted!", id_user
+              respond "#{shortcut}: #{@shortcuts[from][shortcut]}", id_user
+              @shortcuts[from].delete(shortcut)
+              @shortcuts[:all].delete(shortcut)
+              @questions.delete(from)
+              update_shortcuts_file()
+            when /^no/i
+              respond "ok, I won't delete it", id_user
+              @questions.delete(from)
+            else
+              respond "I don't understand, yes or no?", id_user
+            end
+          end
+        else
+          respond "shortcut not found", id_user
+        end
+
+        #help: `see shortcuts`
+        #help:    It will display the shortcuts stored for the user and for :all
+        #help:
+      when /see\sshortcuts/i
+        msg = ""
+        if @shortcuts[:all].keys.size > 0
+          msg = "*Available shortcuts for all:*\n"
+          @shortcuts[:all].each { |name, value|
+            msg += "    _#{name}: #{value}_\n"
+          }
+          respond msg, id_user
+        end
+
+        if @shortcuts.keys.include?(from) and @shortcuts[from].keys.size > 0
+          new_hash = @shortcuts[from].dup
+          @shortcuts[:all].keys.each { |k| new_hash.delete(k) }
+          if new_hash.keys.size > 0
+            msg = "*Available shortcuts for #{from}:*\n"
+            new_hash.each { |name, value|
+              msg += "    _#{name}: #{value}_\n"
+            }
+            respond msg, id_user
+          end
+        end
+        respond "No shortcuts found", id_user if msg == ""
+
+        #help: `id channel CHANNEL_NAME`
+        #help:    shows the id of a channel name
+        #help:
+      when /id channel (.+)/
+        channel_name = $1
+        get_channels_name_and_id()
+        if @channels_id.keys.include?(channel_name)
+          respond "the id of #{channel_name} is #{@channels_id[channel_name]}", id_user
+        else
+          respond "channel: #{channel_name} not found", id_user
+        end
+
+        # help: `ruby RUBY_CODE`
+        # help: `code RUBY_CODE`
+        # help:     runs the code supplied and returns the output. 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:
+      when /ruby\s(.+)/im, /code\s(.+)/im
+        code = $1
+        code.gsub!("\\n", "\n")
+        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
+               code.include?("ENV")
+          begin
+            stdout, stderr, status = Open3.capture3("ruby -e \"#{code.gsub('"', '\"')}\"")
+            if stderr == ""
+              if stdout == ""
+                respond "Nothing returned. Remember you need to use p or puts to print", id_user
+              else
+                respond stdout, id_user
+              end
+            else
+              respond stderr, id_user
+            end
+          rescue Exception => exc
+            respond exc, id_user
+          end
+        else
+          respond "Sorry I cannot run this due security issues", id_user
+        end
+      else
+        processed2 = false
+      end
+      processed = true if processed or processed2
+    end
+
+    return processed
+  end
+
+  def respond(msg, id_user = nil)
+    if id_user.nil?
+      client.message(channel: @channels_id[CHANNEL], text: msg, as_user: true)
+    else #private message
+      send_msg_user(id_user, msg)
+    end
+  end
+
+  #context: previous message
+  #to: user that should answer
+  def ask(question, context, to, id_user = nil)
+    if id_user.nil?
+      client.message(channel: @channels_id[CHANNEL], text: "#{to}: #{question}", as_user: true)
+    else #private message
+      send_msg_user(id_user, "#{to}: #{question}")
+    end
+    @questions[to] = context
+  end
+
+  # to: (String) Channel name or id
+  # msg: (String) message to send
+  def send_msg_channel(to, msg)
+    unless msg == ""
+      get_channels_name_and_id() unless @channels_name.key?(to) or @channels_id.key?(to)
+      if @channels_name.key?(to) #it is an id
+        channel_id = to
+      elsif @channels_id.key?(to) #it is a channel name
+        channel_id = @channels_id[to]
+      else
+        @logger.fatal "Channel: #{to} not found. Message: #{msg}"
+      end
+      client.message(channel: channel_id, text: msg, as_user: true)
+    end
+  end
+
+  #to send messages without listening for a response to users
+  def send_msg_user(id_user, msg)
+    unless msg == ""
+      im = wclient.im_open(user: id_user)
+      client.message(channel: im["channel"]["id"], as_user: true, text: msg)
+    end
+  end
+
+  private :update_bots_file, :get_channels_name_and_id, :update_shortcuts_file
+end

data/lib/slack-smart-bot_rules.rb

@@ -0,0 +1,82 @@
+#for the case of testing, just run this file adding in the end a call to rules with the parameters you want
+if defined?(respond)
+  @testing = false
+else
+  @testing = true
+  @questions = Hash.new()
+
+  def respond(message, id_user)
+    puts message
+  end
+
+  #context: previous message
+  #to: user that should answer
+  def ask(question, context, to, id_user)
+    puts "Bot: #{question}"
+    @questions[to] = context
+  end
+end
+
+# from: Full name of the person sending the message
+# command: command to run
+# processed: in case the command has been already processed on Bot class, by default false
+# help:
+# help: *These are specific commands on this bot.*
+# help:     They will be accessible only when the bot is listening to you just writing the command
+# help:     or the bot is not listening to you but requested on demand, for example:
+# help:       `!THE_COMMAND`
+# help:       `@bot THE_COMMAND`
+# help:       `@NAME_OF_BOT THE_COMMAND`
+# help:       `NAME_OF_BOT THE_COMMAND`
+# help:
+def rules(from, command, processed, id_user)
+  if @testing
+    puts "#{from}: #{command}"
+    if @questions.keys.include?(from)
+      context = @questions[from]
+      @questions[from] = command
+      command = context
+    end
+  end
+  firstname = from.split(" ").first
+  case command
+
+  # help: `echo SOMETHING`
+  # help:     repeats SOMETHING
+  # help:
+  when /echo\s(.+)/i
+    respond $1, id_user
+
+    # help: `go to sleep`
+    # help:   it will sleep the bot for 10 seconds
+    # help:
+  when /go\sto\ssleep/i
+    unless @questions.keys.include?(from)
+      ask("do you want me to take a siesta?", command, from, id_user)
+    else
+      case @questions[from]
+      when /yes/i, /yep/i, /sure/i
+        respond "zZzzzzzZZZZZZzzzzzzz!", id_user
+        respond "I'll be sleeping for 10 secs... just for you", id_user
+        sleep 10
+      when /no/i, /nope/i, /cancel/i
+        @questions.delete(from)
+        respond "Thanks, I'm happy to be awake", id_user
+      else
+        respond "I don't understand", id_user
+        ask("are you sure do you want me to sleep? (yes or no)", "go to sleep", from, id_user)
+      end
+    end
+  else
+    unless processed
+      resp = %w{ what huh sorry }.sample
+      respond "#{firstname}: #{resp}?", id_user
+    end
+  end
+end
+
+#for the case of testing just running this file, write the dialogue in here:
+if @testing
+  rules "Peter Johson", "go to sleep, you look tired", false
+  rules "Peter Johson", "yes", false
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: slack-smart-bot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mario Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.2
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+description: "Create a Slack bot that is smart and so easy to expand, create new bots
+  on demand, run ruby code on chat, create shortcuts... \n  The main scope of this
+  gem is to be used internally in the company so teams can create team channels with
+  their own bot to help them on their daily work, almost everything is suitable to
+  be automated!! \n  slack-smart-bot can create bots on demand, create shortcuts,
+  run ruby code... just on a chat channel. \n  You can access it just from your mobile
+  phone if you want and run those tests you forgot to run, get the results, restart
+  a server... no limits."
+email: marioruizs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- lib/slack-smart-bot.rb
+- lib/slack-smart-bot_rules.rb
+homepage: https://github.com/MarioRuiz/slack-smart-bot
+licenses:
+- MIT
+metadata: {}
+post_install_message: Thanks for installing! Visit us on https://github.com/MarioRuiz/slack-smart-bot
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Create a Slack bot that is smart and so easy to expand, create new bots on
+  demand, run ruby code on chat, create shortcuts...
+test_files: []