protonbot 0.1.0

data/lib/protonbot/bot_plugins.rb

@@ -0,0 +1,110 @@
+class ProtonBot::Bot
+  # @!group Plugins
+
+  # Use it to load external plugins. You cannot provide both arguments
+  # @param file [String] Filename
+  # @param block [Proc]
+  # @example
+  #   plugin_loader do
+  #     plugin('foo') # Will load plugin from ./plugins/foo/main.rb
+  #     gem('bar') # Will load plugin from path_to_gem_bar/lib/bar/plugin.rb
+  #   end
+  # @example
+  #   plugin_loader 'foo' # Will load plugin from ./plugins/foo/main.rb
+  def plugin_loader(file = nil, &block)
+    raise(ArgumentError, 'Both filename and load-block are nil!') if
+      file.nil? && block.nil?
+
+    raise(ArgumentError, 'Both filename and load-block are not nil!') if
+      !file.nil? && !block.nil?
+
+    if file
+      @plugin_loader = lambda do
+        load(File.expand_path('./' + file))
+      end
+    end
+
+    @plugin_loader = block if block
+    self
+  end
+
+  # Basically clears plugin hash
+  # @return [Bot] self
+  def plugins_unload
+    @plugins = {}
+    self
+  end
+
+  # Loads all plugins by calling `@plugin_loader` and initializing 
+  # each plugin
+  # @return [Bot] self
+  def plugins_load
+    @plugins['core'] =
+      pluginr "#{Gem.loaded_specs['protonbot'].lib_dirs_glob.split(':')[0]}/protonbot/core_plugin/plugin.rb"
+    @plugin_loader.call if @plugin_loader
+    @plugins.each do |k, v|
+      v.bot = self
+      v.log = @_log.wrap("?#{k}")
+      v.launch
+    end
+    self
+  end
+
+  # Loads given plugin by name
+  # @param dat [String] Plugin name in file system
+  # @return [Bot] self
+  def plugin(dat)
+    pl = nil
+    if dat.instance_of? Array
+      dat.each do |i|
+        pl = pluginr(File.expand_path("plugins/#{i}/plugin.rb"))
+        raise ProtonBot::PluginError, "`plugins/#{i}/plugin.rb` did not return plugin!" unless
+          pl.instance_of? ProtonBot::Plugin
+      end
+    elsif dat.instance_of? String
+      pl = pluginr(File.expand_path("plugins/#{dat}/plugin.rb"))
+      raise ProtonBot::PluginError, "`plugins/#{dat}/plugin.rb` did not return plugin!" unless
+        pl.instance_of? ProtonBot::Plugin
+    else
+      raise ArgumentError, 'Unknown type of `dat` plugin! Use Array or String!'
+    end
+    @plugins[pl.name] = pl
+    self
+  end
+
+  # Loads plugin from gem
+  # @param gemname [String] Name of gem
+  # @return [Bot] self
+  def gem(gemname)
+    if Gem.loaded_specs[gemname]
+      path = "#{Gem.loaded_specs[gemname].lib_dirs_glob.split(':')[0]}/" \
+        "#{gemname.gsub(/-/, '/')}/plugin.rb"
+      if File.exist? path
+        pl = pluginr(path)
+        raise ProtonBot::PluginError, "`#{path}` did not return plugin!" unless
+          pl.instance_of? ProtonBot::Plugin
+        @plugins[gemname] = pl
+      else
+        raise IOError, "No such file or directory: #{path}"
+      end
+    else
+      raise ArgumentError, "No such gem: #{gemname}"
+    end
+    self
+  end
+
+  # Loads plugin by path
+  # @param path [String] Path
+  # @return [Plugin] Loaded plugin
+  def pluginr(path)
+    if File.exist? path
+      pl = eval(File.read(path), nil, %r{.*/(.+/.+)}.match(path)[1])
+      pl.path = File.dirname(path)
+      pl
+    else
+      raise IOError, 'No such file or directory: #{path}'
+    end
+  end
+
+  # @!endgroup
+end

data/lib/protonbot/core_plugin/apis/help.rb

@@ -0,0 +1,54 @@
+@help = {}
+
+fun :help_render do |query = nil, ehash = nil|
+  if query
+    done = nil
+    @help.each do |group, items|
+      items.each do |item, h|
+        next unless item == query
+        hook = nil
+        @bot.plugins.each do |_, p|
+          p.hooks.each do |hk|
+            next if hook
+            next unless hk
+            if hk.pattern[:type] == :command && hk.pattern[:cmd] == h[:name] && hk.extra[:needed_perms]
+              hook = hk
+            end
+          end
+        end
+        done = 
+          if hook && ehash && ehash[:perms]
+            perms       = ehash[:perms]
+            needed      = hook.extra[:needed_perms]
+            not_enough  = needed - perms
+            available   = needed - not_enough
+            available_  = available.map{|i|'%C%GREEN' + i + '%N'}
+            not_enough_ = not_enough.map{|i|'%C%RED' + i + '%N'}
+            permstatus  = (available_ + not_enough_).join(' ')
+            "%B#{group}/#{item} |%N #{h[:syntax]} %B|%N Perms: #{permstatus} %B|%N #{h[:description]}"
+          else
+            "%B#{group}/#{item} |%N #{h[:syntax]} %B|%N #{h[:description]}"
+          end
+      end
+    end
+    if done
+      done
+    else
+      "No such command: %B#{query}%N"
+    end
+  else
+    'Use %Blist%N command to list all groups. Use %Blist <group>%N ' +
+      'command to list all items in group. Use %Bhelp <command>%N to read ' +
+      'help for given command. ' +
+      'Parameter syntax: %B<required> [optional] {0 or more} (1 or more)%N'
+  end
+end
+
+fun :help_add do |group, name, syntax, description|
+  @help[group] = {} unless @help[group]
+  @help[group][name] = {
+    name:        name,
+    syntax:      syntax,
+    description: description
+  }
+end

data/lib/protonbot/core_plugin/apis/index.rb

@@ -0,0 +1,2 @@
+run 'apis/perms'
+run 'apis/help'

data/lib/protonbot/core_plugin/apis/perms.rb

@@ -0,0 +1,118 @@
+class ProtonBot::Hook
+  # Basic hook modifier for checking permissions. Added by core plugin.
+  # @param perms [String] Permission names
+  # @return [Hook] self
+  def perm!(*perms)
+    self.extra[:needed_perms] = perms
+    self.chain << proc do |dat, hook|
+      perms = dat[:perms]
+      canrun = true
+      needed = hook.extra[:needed_perms]
+      not_enough = needed - perms
+      available = needed - not_enough
+      if not_enough == []
+        canrun = true
+      else
+        canrun = false
+        available_  = available.map{|i|'%C%GREEN' + i + '%N'}
+        not_enough_ = not_enough.map{|i|'%C%RED' + i + '%N'}
+        status      = (available_ + not_enough_).join(' ')
+        dat.nreply("Not enough permissions to use this! (#{status})")
+      end
+      canrun
+      #
+    end
+    self
+  end
+end
+
+@permhash = {
+  'owner' => %w(
+    reload
+    eval
+    exec
+    raw
+    cross
+    admin
+    perms
+  ),
+  'admin' => %w(
+    joinpart
+    nick
+    msg
+    ctcp
+    notice
+    nctcp
+    flushq
+  ),
+  'cross' => %w(
+    crossuser
+    crosschan
+    crossplug
+  )
+}
+
+fun :process_perms do |a|
+  out = nil
+  loop do
+    out = a
+    a.each do |i|
+      next unless @permhash.keys.include? i
+      canrun = true
+      @permhash[i].each do |ii|
+        canrun = false if a.include? ii
+      end
+      a += @permhash[i] if canrun
+    end
+    break if out == a
+  end
+  out
+end
+
+fun :getperms! do |plug, host|
+  getperms(plug, host) or []
+end
+
+fun :getperms do |plug, host|
+  dat = plug.db.query('perms').ensure.select('host' => host).finish
+  if dat.empty?
+    nil
+  else
+    dat[0].to_h['perms']
+  end
+end
+
+fun :hasperm? do |plug, host, perm|
+  dat = plug.db.query('perms').ensure.select('host' => host).finish
+  perms = dat[0].to_h['perms'] unless dat.empty?
+  perms = []              if dat.empty?
+  perms.include?(perm) || dat.include?('owner')
+end
+
+fun :addperm do |plug, host, perm|
+  perms = getperms(plug, host)
+  if !perms
+    plug.db.query('perms').ensure.insert(
+      'host' => host, 'perms' => [perm]
+    ).write.finish
+  else
+    unless perms.include? perm
+      plug.db.query('perms').ensure.update(
+        { 'host' => host }, 'perms' => (perms + [perm]).uniq
+      ).write.finish
+    end
+  end
+end
+
+fun :delperm do |plug, host, perm|
+  perms = getperms(plug, host)
+  if perms && perms.include?(perm)
+    plug.db.query('perms').ensure.update(
+      { 'host' => host }, 'perms' => perms - [perm]
+    ).write.finish
+  end
+end
+
+fun :permhash do
+  @permhash
+end

data/lib/protonbot/core_plugin/codes/index.rb

@@ -0,0 +1,3 @@
+run 'codes/names'
+run 'codes/welcome'
+run 'codes/whois'

data/lib/protonbot/core_plugin/codes/names.rb

@@ -0,0 +1,21 @@
+hook(type: :code, code: @numeric::NAMREPLY) do |dat|
+  m = /[=*@] (.+?) :(.+)/.match(dat[:extra])
+
+  if !dat[:plug].chans[m[1]] || !dat[:plug].chans[m[1]][:collecting]
+    dat[:plug].chans[m[1]] = {}
+    dat[:plug].chans[m[1]][:collecting] = true
+    dat[:plug].chans[m[1]][:users] = []
+  end
+  users = m[2].split(' ')
+  users.each do |user|
+    user = /[@+%&]*(.+)/.match(user)[1]
+    dat[:plug].chans[m[1]][:users] << user
+    dat[:plug].users[user] = { nick: user }
+  end
+end
+
+hook(type: :code, code: @numeric::ENDOFNAMES) do |dat|
+  m = /(.+?) :.*/.match(dat[:extra])
+
+  dat[:plug].chans[m[1]][:collecting] = false
+end

data/lib/protonbot/core_plugin/codes/welcome.rb

@@ -0,0 +1,7 @@
+hook(type: :code, code: @numeric::WELCOME) do |dat|
+  if dat[:plug].conf['autojoin']
+    dat[:plug].conf['autojoin'].map do |e|
+      dat[:plug].join(e.to_s)
+    end
+  end
+end

data/lib/protonbot/core_plugin/codes/whois.rb

@@ -0,0 +1,9 @@
+hook(type: :code, code: @numeric::WHOISUSER) do |dat|
+  m = /(.+?) (.+?) (.+?) \* :.*/.match(dat[:extra])
+  dat[:plug].users[m[1]] = {} unless dat[:plug].users[m[1]]
+  u = dat[:plug].users[m[1]]
+  u[:nick] = m[1]
+  u[:user] = m[2]
+  u[:host] = m[3]
+  emit(dat.merge(type: :code_whoisuser, nick: u[:nick], user: u[:user], host: u[:host]))
+end

data/lib/protonbot/core_plugin/commands/admin.rb

@@ -0,0 +1,107 @@
+@key = nil
+
+core.help_add('owner', 'key', 'key [key]', 'Generates unique key. If correct key is ' +
+  'provided, gives owner privileges')
+cmd(cmd: 'key') do |dat|
+  if !dat[:split].empty?
+    if dat[:split][0] == @key && !@key.nil?
+      dat.reply "#{dat[:nick]}: given key is valid! You are an owner now!"
+      addperm(dat[:plug], dat[:host], 'owner')
+    else
+      dat.reply "#{dat[:nick]}: given key is invalid!"
+    end
+    @key = nil
+  else
+    @key = Random.rand(44**44..55**55).to_s(36)
+    log.debug 'Use this key to auth yourself: ' + @key
+    dat.reply "#{dat[:nick]}: generated your key and outputted to console!" \
+              ' Use `key <key>` to make yourself owner!'
+  end
+end
+
+core.help_add('owner', 'rb', 'rb {code}', 'Evaluates given ruby code')
+cmd(cmd: 'rb') do |dat|
+  if dat[:split]
+    out = eval(dat[:split].join(' ')).inspect
+    dat.reply "%BOutput%N: #{out}"
+  else
+    dat.reply '%BOutput%N: nil'
+  end
+end.perm!('eval')
+
+core.help_add('owner', 'exec', 'exec {command}', 'Executes given command')
+cmd(cmd: 'exec') do |dat|
+  if dat[:split]
+    stdout, stderr, status = Open3.capture3(dat[:split].join(' '))
+    STDERR.puts stderr
+    if status.success?
+      dat.reply stdout
+    else
+      dat.nreply 'Err: ' + stderr
+    end
+  end
+end.perm!('exec')
+
+core.help_add('owner', 'raw', 'raw {message}', 'Sends raw message to an IRC server')
+cmd(cmd: 'raw') do |dat|
+  dat[:plug].write(dat[:split].join(' '))
+end.perm!('raw')
+
+core.help_add('admin', 'nick', 'nick <nick>', 'Changes nick')
+cmd(cmd: 'nick') do |dat|
+  if dat[:split].empty?
+    dat.nreply ProtonBot::Messages::NOT_ENOUGH_PARAMETERS
+  else
+    dat[:plug].change_nick(dat[:split][0])
+  end
+end.perm!('nick')
+
+core.help_add('admin', 'msg', 'msg [target] <message>', 'Sends given message to target')
+cmd(cmd: 'msg') do |dat|
+  if dat[:split].empty?
+    dat.nreply ProtonBot::Messages::NOT_ENOUGH_PARAMETERS
+  else
+    dat[:plug].privmsg(dat[:split][0], dat[:split][1, dat[:split].length - 1].join(' '))
+  end
+end.perm!('msg')
+
+core.help_add('admin', 'ctcp', 'ctcp [target] <message>', 'Sends given ctcp to target')
+cmd(cmd: 'ctcp') do |dat|
+  if dat[:split].empty?
+    dat.nreply ProtonBot::Messages::NOT_ENOUGH_PARAMETERS
+  else
+    dat[:plug].ctcp(dat[:split][0], dat[:split][1, dat[:split].length - 1].join(' '))
+  end
+end.perm!('ctcp')
+
+core.help_add('admin', 'notice', 'notice [target] <message>', 'Sends given notice to target')
+cmd(cmd: 'notice') do |dat|
+  if dat[:split].empty?
+    dat.nreply ProtonBot::Messages::NOT_ENOUGH_PARAMETERS
+  else
+    dat[:plug].notice(dat[:split][0], dat[:split][1, dat[:split].length - 1].join(' '))
+  end
+end.perm!('notice')
+
+core.help_add('admin', 'nctcp', 'nctcp [target] <message>', 'Sends given nctcp to target')
+cmd(cmd: 'nctcp') do |dat|
+  if dat[:split].empty?
+    dat.nreply ProtonBot::Messages::NOT_ENOUGH_PARAMETERS
+  else
+    dat[:plug].nctcp(dat[:split][0], dat[:split][1, dat[:split].length - 1].join(' '))
+  end
+end.perm!('nctcp')
+
+core.help_add('admin', 'flushq', 'flushq', 'Flushes queue')
+cmd(cmd: 'flushq') do |dat|
+  dat[:plug].queue.clear
+end.perm!('flushq')
+
+core.help_add('owner', 'r', 'r', 'Reloads all plugins')
+hook(type: :command, cmd: 'r') do |dat|
+  dat[:bot].log.info 'Reload: START'
+  dat[:bot].plugins_unload
+  dat[:bot].plugins_load
+  dat[:bot].log.info 'Reload: END'
+  dat.nreply 'Done!'
+end.perm!('reload')

data/lib/protonbot/core_plugin/commands/basic.rb

@@ -0,0 +1,9 @@
+core.help_add('basic', 'ping', 'ping', 'Ping!')
+cmd(cmd: 'ping') do |dat|
+  dat.reply("#{dat[:nick]}: pong!")
+end
+
+core.help_add('basic', 'echo', 'echo', 'Sends given message back')
+cmd(cmd: 'echo') do |dat|
+  dat.reply("#{dat[:split].join(' ')}")
+end

data/lib/protonbot/core_plugin/commands/cross.rb

@@ -0,0 +1,40 @@
+core.help_add('cross', 'as', 'as <nickname> {message}', 'Processes given message as given user')
+cmd(cmd: 'as', perm_crossuser: true) do |dat|
+  nick = dat[:split][0]
+  if dat[:plug].users[nick]
+    user = dat[:plug].getuser(nick)
+    host = dat[:plug].gethost(nick)
+    message = dat[:split][1..dat[:split].length - 1].join(' ')
+    dat[:plug].emit(dat.merge(type: :privmsg, nick: nick, user: user, host: host,
+                              message: message, target: dat[:target], reply_to: dat[:reply_to]))
+  else
+    dat.nreply 'No such user!'
+  end
+end
+
+core.help_add('cross', 'at', 'at <channel> {message}', 'Processes given message at given channel')
+cmd(cmd: 'at', perm_crossuser: true) do |dat|
+  chan = dat[:split][0]
+  if dat[:plug].chans[chan]
+    nick = dat[:nick]
+    user = dat[:plug].getuser(nick)
+    host = dat[:plug].gethost(nick)
+    message = dat[:split][1..dat[:split].length - 1].join(' ')
+    dat[:plug].emit(dat.merge(type: :privmsg, nick: nick, user: user, host: host,
+                              message: message, target: chan, reply_to: chan))
+  else
+    dat.nreply 'No such chan!'
+  end
+end
+
+core.help_add('cross', 'on', 'on <server> {message}', 'Processes given message on given server')
+cmd(cmd: 'on', perm_crossuser: true) do |dat|
+  plug = dat[:split][0]
+  if bot.plugs[plug] && bot.plugs[plug].running
+    message = dat[:split][1..dat[:split].length - 1].join(' ')
+    bot.plugs[plug].emit(dat.merge(type: :privmsg, nick: nil, user: nil, host: nil,
+                                   message: message, plug: bot.plugs[plug]))
+  else
+    dat.nreply 'No such plug!'
+  end
+end

data/lib/protonbot/core_plugin/commands/help.rb

@@ -0,0 +1,25 @@
+core.help_add('help', 'help', 'help {commands}', 'Shows help for given commands')
+cmd(cmd: 'help') do |dat|
+  if dat[:split].empty?
+    dat.nreply(help_render)
+  else
+    dat[:split].each do |i|
+      dat.nreply(help_render(i, dat))
+    end
+  end
+end
+
+core.help_add('help', 'list', 'list {groups}', 'Lists groups or items in groups')
+cmd(cmd: 'list') do |dat|
+  if dat[:split].empty?
+    dat.nreply "%BGroups%N: #{@help.keys.join(', ')}"
+  else
+    dat[:split].each do |i|
+      if @help[i]
+        dat.nreply "Items in %B#{i}%N: #{@help[i].keys.join(', ')}"
+      else
+        dat.nreply "No such group: %B#{i}%N"
+      end
+    end
+  end
+end

data/lib/protonbot/core_plugin/commands/index.rb

@@ -0,0 +1,6 @@
+run 'commands/admin'
+run 'commands/basic'
+run 'commands/cross'
+run 'commands/joinpart'
+run 'commands/help'
+run 'commands/perms'

data/lib/protonbot/core_plugin/commands/joinpart.rb

@@ -0,0 +1,25 @@
+core.help_add('admin', 'join', 'join (chans|sep=,) [pass]', 'Joins given chans')
+hook(type: :command, cmd: 'join') do |dat|
+  if dat[:split].empty?
+    m.nreply 'Not enough parameters!'
+  else
+    (pass = dat[:split][1]) || ''
+    chans = dat[:split][0].split(',')
+    chans.each do |chan|
+      dat[:plug].join(chan, pass)
+    end
+  end
+end.perm!('joinpart')
+
+core.help_add('admin', 'part', 'part (chans|sep=,) [reason]', 'Parts given chans')
+hook(type: :command, cmd: 'part') do |dat|
+  if dat[:split].empty?
+    dat[:plug].part(dat[:target], '')
+  else
+    (reason = dat[:split][1]) || ''
+    chans = dat[:split][0].split(',')
+    chans.each do |chan|
+      dat[:plug].part(chan, reason)
+    end
+  end
+end.perm!('joinpart')

data/lib/protonbot/core_plugin/commands/perms.rb

@@ -0,0 +1,50 @@
+core.help_add('owner', 'perms', 'perms {groups}', 'Lists permissions/permisssion-groups')
+cmd(cmd: 'perms') do |dat|
+  if dat[:split].empty?
+    dat.nreply "Perm groups: #{@permhash.keys.join(', ')}"
+  else
+    dat[:split].each do |g|
+      if @permhash[g]
+        dat.nreply "Perms in group %B#{g}%N: #{@permhash[g].join(', ')}"
+      else
+        dat.nreply "No such group: %B#{g}%N"
+      end
+    end
+  end
+end
+
+core.help_add('owner', 'uperms', 'uperms <+|-|?> <user> {perms}', '%B+%N - gives perms. ' \
+  '%B-%N - removes perms. %B?%N - checks perms.')
+cmd(cmd: 'uperms') do |dat|
+  case dat[:split][0]
+  when nil
+    dat.nreply 'Not enough parameters!'
+  when '+'
+    if dat[:plug].users[dat[:split][1]]
+      dat[:split][2..dat[:split].length-1].each do |perm|
+        addperm(dat[:plug], dat[:plug].gethost(dat[:split][1]), perm)
+      end
+      dat.nreply 'Done!'
+    else
+      dat.nreply "No such user: #{dat[:split][1]}"
+    end
+  when '-'
+    if dat[:plug].users[dat[:split][1]]
+      dat[:split][2..dat[:split].length-1].each do |perm|
+        delperm(dat[:plug], dat[:plug].gethost(dat[:split][1]), perm)
+      end
+      dat.nreply 'Done!'
+    else
+      dat.nreply "No such user: #{dat[:split][1]}"
+    end
+  when '?'
+    if dat[:plug].users[dat[:split][1]]
+      dat.nreply "%B#{dat[:split][1]}%N's perms: " \
+        "#{getperms!(dat[:plug], dat[:plug].gethost(dat[:split][1])).join(', ')}"
+    else
+      dat.nreply "No such user: #{dat[:split][1]}"
+    end
+  else
+    dat.nreply "No such action: #{dat[:split][0]}"
+  end
+end.perm!('perms')

data/lib/protonbot/core_plugin/hooks/ctcp.rb

@@ -0,0 +1,9 @@
+hook(type: :ctcp, cmd: 'VERSION') do |dat|
+  dat[:plug].nctcp(dat[:nick], %(VERSION ProtonBot v#{ProtonBot::VERSION} on Ruby ) +
+    %(v#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}/#{RUBY_PLATFORM} and Heliodor ) +
+    %(v#{Gem.loaded_specs['heliodor'].version.version}))
+end
+
+hook(type: :ctcp, cmd: 'PING') do |dat|
+  dat[:plug].nctcp(dat[:nick], %(PING #{dat[:split][0]}))
+end

data/lib/protonbot/core_plugin/hooks/index.rb

@@ -0,0 +1,7 @@
+run 'hooks/raw'
+run 'hooks/ping'
+run 'hooks/kick'
+run 'hooks/privmsg'
+run 'hooks/ctcp'
+run 'hooks/joinpart'
+run 'hooks/nick'

data/lib/protonbot/core_plugin/hooks/joinpart.rb

@@ -0,0 +1,42 @@
+hook(type: :ujoin) do |dat|
+  dat[:plug].users[dat[:nick]] = {} unless dat[:plug].users[dat[:nick]]
+  u = dat[:plug].users[dat[:nick]]
+  u[:nick] = dat[:nick]
+  u[:user] = dat[:user]
+  u[:host] = dat[:host]
+
+  unless dat[:plug].chans[dat[:channel]]
+    dat[:plug].chans[dat[:channel]] = {}
+    dat[:plug].chans[dat[:channel]][:users] = []
+  end
+
+  dat[:plug].chans[dat[:channel]][:users] << u[:nick] unless
+    dat[:plug].chans[dat[:channel]][:users].include? u[:nick]
+end
+
+hook(type: :upart) do |dat|
+  dat[:plug].users[dat[:nick]] = {} unless dat[:plug].users[dat[:nick]]
+  u = dat[:plug].users[dat[:nick]]
+  u[:nick] = dat[:nick]
+  u[:user] = dat[:user]
+  u[:host] = dat[:host]
+
+  unless dat[:plug].chans[dat[:channel]]
+    dat[:plug].chans[dat[:channel]] = {}
+    dat[:plug].chans[dat[:channel]][:users] = []
+  end
+
+  dat[:plug].chans[dat[:channel]][:users].delete u[:nick] if
+    dat[:plug].chans[dat[:channel]][:users].include? u[:nick]
+
+  if dat[:nick] == dat[:plug].nick && /requested by .*/.match(dat[:message])
+    dat[:plug].join(dat[:channel])
+  end
+end
+
+hook(type: :uqit) do |dat|
+  dat[:plug].chans.each do |chan|
+    chan[:users].delete(dat[:nick]) if chan[:users]
+  end
+  dat[:plug].users.delete(dat[:nick])
+end

data/lib/protonbot/core_plugin/hooks/kick.rb

@@ -0,0 +1,17 @@
+hook(type: :ukick) do |dat|
+  dat[:plug].users[dat[:nick]] = {} unless dat[:plug].users[dat[:nick]]
+  u = dat[:plug].users[dat[:nick]]
+  u[:nick] = dat[:nick]
+  u[:user] = dat[:user]
+  u[:host] = dat[:host]
+
+  unless dat[:plug].chans[dat[:channel]]
+    dat[:plug].chans[dat[:channel]] = {}
+    dat[:plug].chans[dat[:channel]][:users] = []
+  end
+
+  dat[:plug].chans[dat[:channel]][:users].delete dat[:target] if
+    dat[:plug].chans[dat[:channel]][:users].include? dat[:target]
+
+  dat[:plug].join(dat[:channel]) if dat[:target] == dat[:plug].nick
+end