zetabot 0.0.1

data/lib/Zeta/admin/oper.rb

@@ -0,0 +1,50 @@
+# This is considered a dangerous plugin, use it only if you know what you are doing
+module Admin
+  class Oper
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:oper)
+
+    # Regex
+    match 'operup', method: :oper_up
+    match /kill ([\S]+) (.+)/, method: :oper_kill
+    match /clearchan (.+) (true|yes)/, method: :oper_clearchan
+
+    # Methods
+    def oper_up(m)
+      if Config.oper_username && Config.oper_password
+        @bot.oper(Config.oper_password, Config.oper_username)
+      end
+    end
+
+    def oper_kill(m, nick, message)
+      return if User(nick).oper?
+      if @bot.irc.send("KILL #{nick} #{message}")
+        m.reply "#{nick}: has been killed by #{m.user.nick} for #{message}"
+      end
+    end
+
+    def oper_clearchan(m, chan, confirm=false)
+      if confirm == 'yes' || confirm == 'true'
+        Channel(chan).join
+        User('OperServ').send("mode #{chan} +o #{Zeta}")
+        User('OperServ').send("mode #{chan} +mi")
+        Channel(chan).send('This channel is being cleared')
+
+        number_killed = 0
+        Channel(chan).users.each_key do |u|
+          if u != Zeta
+            number_killed += 1
+            @bot.irc.send("KILL #{u.nick} This channel is being cleared")
+          end
+        end
+        m.safe_reply "#{chan} has been cleared, #{number_killed} clients killed"
+
+      end
+    end
+
+  end
+end
+
+Bot.config.plugins.plugins.push Admin::Oper

data/lib/Zeta/admin/plugins.rb

@@ -0,0 +1,109 @@
+module Admin
+  class Plugins
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:admin, true)
+
+    set(
+        plugin_name: 'PluginsAdmin',
+        help: "Bot administrator-only private commands.\nUsage: `~join [channel]`; `~part [channel] <reason>`; `~quit [reason]`;",
+    # prefix: /^\?/
+    )
+
+    # Regex
+    match(/plugin load (\S+)(?: (\S+))?/, method: :load_plugin)
+    match(/plugin unload (\S+)/, method: :unload_plugin)
+    match(/plugin reload (\S+)(?: (\S+))?/, method: :reload_plugin)
+    match(/plugin set (\S+) (\S+) (.+)$/, method: :set_option)
+
+    # Methods
+    def load_plugin(m, plugin, mapping)
+      mapping ||= plugin.gsub(/(.)([A-Z])/) { |_|
+        $1 + "_" + $2
+      }.downcase # we downcase here to also catch the first letter
+
+      #file_name = "lib/plugins/#{mapping}.rb"
+      stdlib_plugin = File.join('Zeta', 'plugins', p.to_s)
+      custom_plugin = File.join(Dir.home, '.zeta', 'plugins', p.to_s, "#{p.to_s}.rb")
+
+      unless File.exist?(custom_plugin)
+        m.reply "Could not load #{plugin} because #{file_name} does not exist."
+        return
+      end
+
+      begin
+        load(custom_plugin)
+      rescue
+        m.reply "Could not load #{plugin}."
+        raise
+      end
+
+      begin
+        const = Plugins.const_get(plugin)
+      rescue NameError
+        m.reply "Could not load #{plugin} because no matching class was found."
+        return
+      end
+
+      @bot.plugins.register_plugin(const)
+      m.reply "Successfully loaded #{plugin}"
+    end
+
+    def unload_plugin(m, plugin)
+      begin
+        plugin_class = Plugins.const_get(plugin)
+      rescue NameError
+        m.reply "Could not unload #{plugin} because no matching class was found."
+        return
+      end
+
+      @bot.plugins.select { |p| p.class == plugin_class }.each do |p|
+        @bot.plugins.unregister_plugin(p)
+      end
+
+      ## FIXME not doing this at the moment because it'll break
+      ## plugin options. This means, however, that reloading a
+      ## plugin is relatively dirty: old methods will not be removed
+      ## but only overwritten by new ones. You will also not be able
+      ## to change a classes superclass this way.
+      # Cinch::Plugins.__send__(:remove_const, plugin)
+
+      # Because we're not completely removing the plugin class,
+      # reset everything to the starting values.
+      plugin_class.hooks.clear
+      plugin_class.matchers.clear
+      plugin_class.listeners.clear
+      plugin_class.timers.clear
+      plugin_class.ctcps.clear
+      plugin_class.react_on = :message
+      plugin_class.plugin_name = nil
+      plugin_class.help = nil
+      plugin_class.prefix = nil
+      plugin_class.suffix = nil
+      plugin_class.required_options.clear
+
+      m.reply "Successfully unloaded #{plugin}"
+    end
+
+    def reload_plugin(m, plugin, mapping)
+      unload_plugin(m, plugin)
+      load_plugin(m, plugin, mapping)
+    end
+
+    def set_option(m, plugin, option, value)
+      begin
+        const = Plugins.const_get(plugin)
+      rescue NameError
+        m.reply "Could not set plugin option for #{plugin} because no matching class was found."
+        return
+      end
+      @bot.config.plugins.options[const][option.to_sym] = eval(value)
+    end
+  end
+
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Plugins

data/lib/Zeta/admin/users.rb

@@ -0,0 +1,5 @@
+module Admin
+  class Users
+
+  end
+end

data/lib/Zeta/blacklist.rb

@@ -0,0 +1,25 @@
+BlackListStruct = Struct.new :channels, :users, :plugins
+
+# Load Cached
+if File.exists?(File.join(Dir.home, '.zeta', 'cache', 'blacklist.rb'))
+  File.open(File.join(Dir.home, '.zeta', 'cache', 'blacklist.rb')) do |file|
+    Blacklist = Marshal.load(file)
+  end
+else
+  Blacklist = BlackListStruct.new([], [], [])
+end
+
+
+## Methods
+def save_blacklist()
+  File.open(File.join(Dir.home, '.zeta', 'cache', 'blacklist.rb'), 'w+') do |file|
+    Marshal.dump(Blacklist, file)
+  end
+end
+
+def clear_blacklist()
+  Blacklist.users = []
+  Blacklist.plugins = []
+  Blacklist.channels = []
+  File.delete(File.join(Dir.home, '.zeta', 'cache', 'blacklist.rb'))
+end

data/lib/Zeta/cinch.rb

@@ -0,0 +1,35 @@
+require 'cinch'
+
+Bot = Cinch::Bot.new do
+  configure do |c|
+    c.nick                      = Config.nickname
+    c.nicks                     = Config.nicks.split(',')
+    c.user                      = Config.username
+    c.realname                  = Config.realname
+    c.sasl.username             = Config.sasl_username
+    c.sasl.password             = Config.sasl_password
+    c.server                    = Config.server
+    c.password                  = Config.password
+    c.port                      = Config.port
+    c.ssl.use                   = Config.ssl
+    c.max_messages              = Config.max_messages
+    c.messages_per_second       = Config.messages_per_second
+    c.modes                     = Config.modes.split(',')
+    c.channels                  = Config.channels.split(',')
+    c.plugins.prefix            = /^#{Config.prefix}/
+  end
+
+  # Execute on confirmation of connection
+  on :connect do
+    # Gain operator privileges if oper username and password are set in config
+    if Config.oper_username && Config.oper_password
+      if !Config.oper_password.empty?
+        @bot.oper(Config.oper_password, Config.oper_username)
+      end
+    end
+
+  end
+
+end
+
+

data/lib/Zeta/config.rb

@@ -0,0 +1,42 @@
+ConfigStruct = Struct.new(
+                         :locale,
+                         :nickname,
+                         :nicks,
+                         :username,
+                         :realname,
+                         :prefix,
+                         :server,
+                         :password,
+                         :port,
+                         :ssl,
+                         :sasl_username,
+                         :sasl_password,
+                         :max_messages,
+                         :messages_per_second,
+                         :modes,
+                         :channels,
+                         :custom_plugins,
+                         :plugins,
+                         :oper_username,
+                         :oper_password,
+                         :oper_overide,
+                         :log_channel,
+                         :services,
+                         :secure_mode,
+                         :secure_channel,
+                         :secure_host,
+                         :options,
+                         :secrets
+)
+# Initialize Config
+Config = ConfigStruct.new
+
+if File.exists? File.join(Dir.home, '.zeta', 'config.rb')
+  begin
+    require File.join(Dir.home, '.zeta', 'config.rb')
+  rescue => e
+    puts e
+    abort('Unable to read config')
+  end
+
+end

data/lib/Zeta/locale.rb

@@ -0,0 +1,4 @@
+def load_locale(file)
+  Config.locale ||= 'en'
+  YAML::load_file(File.join('locale', Config.locale, "#{file}.yml"))
+end

data/lib/Zeta/log.rb

@@ -0,0 +1,2 @@
+Bot.loggers << Cinch::Logger::FormattedLogger.new(File.open(File.join(Dir.home, '.zeta', 'log', 'error.log'), 'a'))
+Bot.loggers.last.level = :error

data/lib/Zeta/models.rb

@@ -0,0 +1,5 @@
+module DB; end
+
+require 'Zeta/models/user'
+require 'Zeta/models/plugin'
+require 'Zeta/models/channel'

data/lib/Zeta/models/channel.rb

@@ -0,0 +1,3 @@
+class DB::Channel
+
+end

data/lib/Zeta/models/plugin.rb

@@ -0,0 +1,3 @@
+class DB::Plugin
+
+end

data/lib/Zeta/models/user.rb

@@ -0,0 +1,3 @@
+class DB::User
+
+end

data/lib/Zeta/plugins.rb

@@ -0,0 +1,27 @@
+module Plugins; end
+
+# Load STDLib plugins
+if Config.plugins.class == Array
+  Config.plugins.each do |p|
+    begin
+      require File.join('Zeta', 'plugins', p.to_s)
+    rescue => e
+      puts e
+      warn "## Unable to load plugin: #{p} ##"
+    end
+  end
+
+end
+
+## Load Custom Plugins
+if Config.custom_plugins.class == Array
+  Config.custom_plugins.each do |p|
+    begin
+      require File.join(Dir.home, '.zeta', 'plugins', p.to_s, "#{p.to_s}.rb")
+    rescue => e
+      puts e
+      warn "## Unable to load Custom plugin: #{p} ##"
+    end
+  end
+
+end

data/lib/Zeta/plugins/attack.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+require 'yaml'
+
+module Plugins
+  class Attack
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl
+
+     set(
+      plugin_name: 'Random Attacker',
+      help: 'Attacks a user with a random attack.\nUsage: `?attack <nick or phrase>`; `<nick or phrase>` may be omitted for a random attack on a random nick.',
+      react_on: :channel
+     )
+
+    def initialize(*args)
+      @attackdict = []
+      super
+    end
+
+    # Regex
+    match /attack(?: (.+))?/, group: :attack
+
+    # Methods
+    def execute(m, target=nil)
+      target = target.rstrip
+      target = m.user.nick if !target.nil? && target.match(/(\bmy\b|\b#{@bot.nick}\S*\b|\b\S*self\b)/i)
+      target.gsub(/(\bmy\b|\b#{@bot.nick}\S*\b|\b\S*self\b)/i,m.user.nick+"'s") if !target.nil?;
+       populate_attacks!
+       output = if target
+        attack!(target.gsub(/\x03([0-9]{2}(,[0-9]{2})?)?/,''), m.user.nick)
+      else
+        random_attack!(m.channel.users, m.user.nick)
+      end
+      m.channel.action output
+    end
+
+    private
+    def populate_attacks!
+      @attackdict.replace load_locale('attack').map {|e| e.gsub(/<(\w+)>/, "%<#{'\1'.downcase}>s") }
+    end
+
+    def grab_random_nick(users)
+      users.to_a.sample[0].nick;
+    end
+
+    def attack!(target, assailant)
+      return nil if target.nil?;
+      @attackdict.sample % {:target => target, :assailant => assailant, :bot => @bot.nick};
+    end
+
+    def random_attack!(targets, assailant)
+      @attackdict.sample % {:target => grab_random_nick(targets), :assailant => assailant, :bot => @bot.nick};
+    end
+   end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Attack

data/lib/Zeta/plugins/botinfo.rb

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+require 'tag_formatter'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/conversions'
+require 'chronic_duration'
+
+
+module Plugins
+  class BotInfo
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl
+
+    set(
+      plugin_name: "Botinfo",
+      help: "Notices you information about me.\nUsage: `/msg <nick> info`\nUsage: `/msg <nick> list plugins`",
+      react_on: :private)
+
+    def initialize *args
+      super
+      @started_at = Time.now
+    end
+
+    # How to config:
+    # :template -- a path to a textual file (such as *.txt) with fields in it.
+    # :owner -- What to display for the "owner_name" field.
+    # All fields in the text file must be surrounded by '<>', and lines can be commented out using '#'.
+
+    # Regex
+    match 'info', use_prefix: false
+    match 'list plugins', method: :execute_list, use_prefix: false
+    match /^help (.+)$/i, method: :execute_help, use_prefix: false
+
+    # Methods
+    def execute(m)
+      tags = {
+        bot_name: @bot.nick,
+        cinch_version: Cinch::VERSION,
+        #is_admin: config[:admins].is_admin?(m.user.mask) ? "an admin" : "not an admin",
+        owner_name: 'Liothen',
+        plugins_count_remaining: @bot.plugins.length - 10,
+        plugins_head: @bot.plugins[0..9].map {|p| p.class.plugin_name }.join(", "),
+        ruby_platform: RUBY_PLATFORM,
+        ruby_release_date: RUBY_RELEASE_DATE,
+        ruby_version: RUBY_VERSION,
+        session_start_date: @started_at.strftime("%A, %B %e, %Y, at %l:%M:%S %P"),
+        total_channels: @bot.channels.length,
+        total_users: proc {
+          users = [];
+          @bot.channels.each {|c|
+              c.users.each {|u| users << u[0].nick
+            }
+          };
+          users.uniq.size
+        }.call,
+        uptime: ChronicDuration.output(Time.now.to_i - @started_at.to_i)
+      }
+
+      tf = TagFormatter.new open(File.join(__dir__, '../botinfo.txt'),&:read), tags: tags
+
+      m.user.notice tf.parse
+    end
+
+    def execute_list(m)
+
+      list = []
+      @bot.plugins.each {|p| list << p.class.plugin_name };
+      m.user.notice("All #{list.size} currently loaded plugins for #{@bot.nick}:\n#{list.to_sentence}.\nTo view help for a plugin, use `/msg #{@bot.nick} help <plugin name>`.")
+    end
+
+    def execute_help(m, name)
+      list = {}
+      @bot.plugins.each {|p| list[p.class.plugin_name.downcase] = {name: p.class.plugin_name, help: p.class.help} };
+      return m.user.notice("Help for \"#{name}\" could not be found.") if !list.has_key?(name.downcase)
+      m.user.notice("Help for #{Format(:bold,list[name.downcase][:name])}:\n#{list[name.downcase][:help]}")
+    end
+
+  end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::BotInfo