kag-gather 1.3.4 → 1.3.5

data/lib/commands/command.rb

@@ -0,0 +1,126 @@
+module Cinch
+  module Commands
+    #
+    # @api semipublic
+    #
+    class Command
+
+      # Argument formats
+      ARG_FORMATS = {
+        string:  /\S+/,
+        integer: /\d+/,
+        float:   /\d*\.\d+/,
+        text:    /.+/
+      }
+
+      # Name of the command
+      attr_reader :name
+
+      # Argument names/formats
+      attr_reader :arguments
+
+      # Short summary of the command
+      attr_reader :summary
+
+      # Long description of the command
+      attr_reader :description
+
+      # if admin-only
+      attr_reader :admin
+
+      #
+      # Creates a new command.
+      #
+      # @param [Symbol] name
+      #   Name of the command.
+      #
+      # @param [Hash{Symbol => Symbol,Regexp,String,Array}] arguments
+      #   Arguments names and their formats or possible values.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @option options [Array] :aliases
+      #   Additiona aliases for the command.
+      #
+      # @option options [String] :summary
+      #   Short summary of the command.
+      #
+      # @option options [String] :description
+      #   Long description of the command.
+      #
+      def initialize(name,arguments,options={})
+        @name        = name.to_s
+        @arguments   = arguments
+        @aliases     = options.fetch(:aliases,[]).map(&:to_s)
+
+        @summary     = options[:summary]
+        @description = options[:description]
+        @admin       = options[:admin]
+      end
+
+      #
+      # The names for the command.
+      #
+      # @return [Array<String>]
+      #   Command names.
+      #
+      def names
+        [@name] + @aliases
+      end
+
+      #
+      # Creates a Regular Expression that matches invocations of the command.
+      #
+      # @return [Regexp]
+      #   A Regular Expression that matches the command and captures it's
+      #   arguments.
+      #
+      def regexp
+        pattern = '(?:' + Regexp.union([@name] + @aliases).source + ')'
+
+        @arguments.each_value do |format|
+          arg_regexp = case format
+                       when Symbol
+                         ARG_FORMATS.fetch(format)
+                       when Regexp
+                         format
+                       else
+                         Regexp.union(format)
+                       end
+
+          pattern << ' (' << arg_regexp.source << ')'
+        end
+
+        # match the full message
+        pattern << '$'
+
+        Regexp.new(pattern)
+      end
+
+      #
+      # The usage string for the command.
+      #
+      # @return [String]
+      #   The usage string for the command and it's arguments.
+      #
+      def usage
+        usage = "#{@name}"
+
+        @arguments.each do |arg,format|
+          usage << ' ' << case format
+                          when Array
+                            '[' + format.join('|') + ']'
+                          when String
+                            format.to_s
+                          else
+                            arg.to_s.upcase
+                          end
+        end
+
+        usage
+      end
+
+    end
+  end
+end

data/lib/commands/commands.rb

@@ -0,0 +1,64 @@
+require 'commands/command'
+require 'kag/common'
+
+module Cinch
+  module Commands
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      #
+      # All registered commands.
+      #
+      # @return [Array<Command>]
+      #   The registered commands.
+      #
+      # @api semipublic
+      #
+      def commands
+        @commands ||= []
+      end
+
+      protected
+
+      #
+      # Registers a command.
+      #
+      # @param [Symbol] name
+      #
+      # @param [Hash{Symbol => Symbol,Regexp}] arguments
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @option options [String] :summary
+      #   The short summary for the command.
+      #
+      # @option options [String] :description
+      #   The long description for the command.
+      #
+      # @return [Command]
+      #   The new command.
+      #
+      # @example
+      #   command :grant, {name: :string, :level: :integer},
+      #                   summary: "Grants access",
+      #                   description: %{
+      #                     Grants a certain level of access to the user
+      #                   }
+      #
+      def command(name,arguments={},options={})
+        new_command = Command.new(name,arguments,options)
+
+        m = options.key?(:method) ? options[:method] : name
+        match(new_command.regexp, method: m)
+
+        commands << new_command
+        new_command
+      end
+    end
+
+  end
+end

data/lib/commands/help.rb

@@ -0,0 +1,101 @@
+require 'commands/commands'
+require 'cinch/plugin'
+require 'kag/common'
+
+module Cinch
+  module Commands
+    #
+    # Generic `!help` command that lists all commands.
+    #
+    class Help
+      include Cinch::Plugin
+      include Cinch::Commands
+      include KAG::Common
+
+      command :help, {command: :string},
+        summary:     %{Displays help information for the COMMAND},
+        description: %{Finds the COMMAND and prints the usage and description for the COMMAND.}
+
+      command :help, {},
+        summary: "Lists available commands",
+        description: %{If no COMMAND argument is given, then all commands will be listed.}
+
+      #
+      # Displays a list of commands or the help information for a specific
+      # command.
+      #
+      # @param [Cinch::Message]
+      #   The message that invoked `!help`.
+      #
+      # @param [String] command
+      #   The specific command to list help information for.
+      #
+      def help(m,command=nil)
+        if command
+          found = commands_named(command)
+
+          if found.empty?
+            m.reply "help: Unknown command #{command.dump}"
+          else
+            return if found.first.admin and !is_admin(m.user)
+
+            msg = []
+            # print all usages
+            found.each do |cmd|
+              msg << cmd.usage
+            end
+            # print the description of the first command
+            desc = found.first.description.to_s
+            msg = "\x0302#{msg.join(", ")}\x0314"+(desc != "" ? " - #{desc}" : " - #{found.first.summary.to_s}")
+            User(m.user.nick).send(msg)
+          end
+        else
+          msg = []
+          each_command do |cmd|
+            #msg << "\x0302#{cmd.usage}\x0314: #{cmd.summary}" unless (cmd.admin and !is_admin(m.user))
+            msg << "!"+cmd.usage
+          end
+          User(m.user.nick).send(msg.join ", ")
+        end
+      end
+
+      protected
+
+      #
+      # Enumerates over every command.
+      #
+      # @yield [command]
+      #   The given block will be passed every command.
+      #
+      # @yieldparam [Command] command
+      #   A command.
+      #
+      # @return [Enumerator]
+      #   If no block is given, an Enumerator will be returned.
+      #
+      def each_command(&block)
+        return enum_for(__method__) unless block_given?
+
+        bot.config.plugins.plugins.each do |plugin|
+          if plugin < Cinch::Commands
+            plugin.commands.each(&block)
+          end
+        end
+      end
+
+      #
+      # Finds all commands with a similar name.
+      #
+      # @param [String] name
+      #   The name to search for.
+      #
+      # @return [Array<Command>]
+      #   The commands with the matching name.
+      #
+      def commands_named(name)
+        each_command.select { |command| command.name == name }
+      end
+
+    end
+  end
+end

data/lib/gather.rb

@@ -1,4 +1,3 @@
-require 'patches'
-require 'kag/gather'
+require 'kag/bot/bot'
 
-KAG::Bot.new
+KAG::Bot::Bot.new

data/lib/kag/bans/plugin.rb

@@ -0,0 +1,93 @@
+require 'cinch'
+require 'kag/common'
+require 'commands/help'
+
+module KAG
+  module Bans
+    class Plugin
+      include Cinch::Plugin
+      include Cinch::Commands
+      include KAG::Common
+
+      command :report,{nick: :string},
+        summary: "Report a user the bot"
+      def report(m,nick)
+        unless is_banned?(m.user)
+          u = User(nick)
+          if u and !u.unknown
+            KAG::Bans::Report.new(self,m,u)
+          else
+            reply m,"User #{nick} not found!"
+          end
+        end
+      end
+
+      command :reports,{nick: :string},
+        summary: "Show the number of reports for a given user"
+      def reports(m,nick)
+        user = User(nick)
+        if user and !user.unknown
+          count = KAG::Bans::Report.reports(user)
+          if count
+            reply m,"User has been reported #{count.to_s} times."
+          else
+            reply m,"User has not been reported."
+          end
+        else
+          reply m,"Could not find user #{nick}"
+        end
+      end
+
+      command :reported,{},
+        summary: "Show a list of reported users"
+      def reported(m)
+        unless is_banned?(m.user)
+          KAG::Bans::Report.list
+        end
+      end
+
+      command :unreport,{nick: :string},
+        summary: "Clear all reports for a given user",
+        admin: true
+      def unreport(m,nick)
+        if is_admin(m.user)
+          user = User(nick)
+          if user and !user.unknown
+            KAG::Bans::Report.remove(self,m,user)
+          else
+            reply m,"Could not find user #{nick}"
+          end
+        end
+      end
+
+      command :ignore,{nick: :string},
+        summary: "Ignore (Ban) a user",
+        admin: true
+      def ignore(m,nick)
+        if is_admin(m.user)
+          user = User(nick)
+          if user and !user.unknown
+            KAG::Bans::Report.ignore(self,m,user)
+          else
+            reply m,"Could not find user #{nick}"
+          end
+        end
+      end
+
+      command :unignore,{nick: :string},
+        summary: "Unignore (Unban) a user",
+        admin: true
+      def unignore(m,nick)
+        if is_admin(m.user)
+          user = User(nick)
+          if user and !user.unknown
+            KAG::Bans::Report.unignore(self,m,user)
+          else
+            reply m,"Could not find user #{nick}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/kag/bans/report.rb

@@ -0,0 +1,172 @@
+require 'symboltable'
+require 'kag/data'
+require 'kag/config'
+
+module KAG
+  module Bans
+    class Report < SymbolTable
+      def initialize(gather,m,user)
+        hash = {
+          :nick => user.nick,
+          :authname => user.authname,
+          :host => user.host,
+          :realname => user.realname,
+          :gather => gather,
+          :message => m,
+          :count => 1
+        }
+        super(hash)
+        _ensure_data
+        if reported?
+          if can_report?
+            if past_threshold?
+              ignore
+            else
+              up_report_count
+            end
+          else
+            self.gather.reply self.message,"You have already reported #{self[:nick]}. You can only report a user once."
+          end
+        else
+          report
+        end
+      end
+
+      def can_report?
+        r = _report
+        if r and r[:reporters]
+          !r[:reporters].include?(self.message.user.authname)
+        else
+          true
+        end
+      end
+
+      def _ensure_data
+        data[:reported] = {} unless data[:reported]
+        data[:ignored] = {} unless data[:ignored]
+      end
+
+      def reported?
+        data[:reported].key?(self[:authname].to_sym)
+      end
+
+      def report
+        puts self.message.inspect
+        c = self.dup
+        c.delete(:gather)
+        c.delete(:message)
+        c[:reporters] = [self.message.user.authname]
+        data[:reported][self[:authname].to_sym] = c
+        data.save
+
+        self.gather.reply self.message,"User #{self[:nick]} reported." if self.gather.class == KAG::Gather
+      end
+
+      def ignore
+        c = self.clone
+        c.delete(:gather)
+        c.delete(:message)
+        data[:ignored][self[:authname].to_sym] = c
+        data.save
+        self.gather.reply self.message,"User #{self[:nick]} ignored." if self.gather.class == KAG::Gather
+      end
+
+      def past_threshold?
+        _report[:count].to_i > KAG::Config.instance[:report_threshold].to_i
+      end
+
+      def up_report_count
+        _report[:count] = _report[:count].to_i + 1
+        _report[:reporters] = [] unless _report[:reporters]
+        _report[:reporters] << self.message.user.authname
+        data.save
+
+        self.gather.reply message,"User #{self[:nick]} reported. #{self[:nick]} has now been reported #{data[:reported][self[:authname].to_sym][:count]} times." if self.gather.class == KAG::Gather
+      end
+
+      def self.ignore(gather,message,user)
+        KAG::Config.data[:ignored] = {} unless KAG::Config.data[:ignored]
+        if KAG::Config.data[:ignored] and !KAG::Config.data[:ignored].key?(user.authname.to_sym)
+          c = SymbolTable.new({
+            :nick => user.nick,
+            :authname => user.authname,
+            :host => user.host,
+            :realname => user.realname,
+            :gather => gather,
+            :message => message,
+            :reporters => [message.user.authname]
+          })
+          KAG::Config.data[:ignored][user.authname.to_sym] = c
+          KAG::Config.data.save
+
+          gather.reply message,"User #{user.nick} added to ignore list." if gather.class == KAG::Gather
+          true
+        else
+          gather.reply message,"User #{user.nick} already in ignore list!" if gather.class == KAG::Gather
+          false
+        end
+      end
+
+      def self.remove(gather,message,user)
+        if KAG::Config.data[:reported] and KAG::Config.data[:reported].key?(user.authname.to_sym)
+          KAG::Config.data[:reported].delete(user.authname.to_sym)
+          KAG::Config.data.save
+
+          gather.reply message,"User #{user.nick} removed from report list." if gather.class == KAG::Gather
+          true
+        else
+          gather.reply message,"User #{user.nick} not in report list!" if gather.class == KAG::Gather
+          false
+        end
+      end
+
+      def self.unignore(gather,message,user)
+        if KAG::Config.data[:ignored] and KAG::Config.data[:ignored].key?(user.authname.to_sym)
+          KAG::Config.data[:ignored].delete(user.authname.to_sym)
+          KAG::Config.data.save
+
+          gather.reply message,"User #{user.nick} removed from ignore list." if gather.class == KAG::Gather
+          true
+        else
+          gather.reply message,"User #{user.nick} not in ignore list!" if gather.class == KAG::Gather
+          false
+        end
+      end
+
+      def self.reports(user)
+        if KAG::Config.data[:reported] and KAG::Config.data[:reported].key?(user.authname.to_sym)
+          KAG::Config.data[:reported][user.authname.to_sym][:count]
+        else
+          false
+        end
+      end
+
+      def self.is_banned?(user)
+        KAG::Config.data[:ignored] = {} unless KAG::Config.data[:ignored]
+        begin
+          KAG::Config.data[:ignored].key?(user.authname.to_sym)
+        rescue Exception => e
+          puts e.message
+        end
+      end
+
+      def self.list
+        if KAG::Config.data[:ignored]
+          KAG::Config.data[:ignored].keys
+        else
+          []
+        end
+      end
+
+      protected
+
+      def data
+        KAG::Config.data
+      end
+
+      def _report
+        data[:reported][self[:authname].to_sym]
+      end
+    end
+  end
+end

data/lib/kag/bot/bot.rb

@@ -0,0 +1,42 @@
+require 'patches'
+require 'cinch'
+require 'kag/config'
+require 'kag/data'
+require 'kag/gather/plugin'
+require 'kag/bans/plugin'
+require 'kag/irc/plugin'
+require 'kag/bot/plugin'
+require 'commands/help'
+
+module KAG
+  module Bot
+    class Bot
+      def initialize
+        config = self.config
+        bot = Cinch::Bot.new do
+          configure do |c|
+            c.server = config[:server]
+            c.channels = config[:channels]
+            c.port = config[:port].to_i > 0 ? config[:port] : 6667
+            #c.ssl = config[:ssl]
+            c.nick = config[:nick].to_s != "" ? config[:nick] : "KAGatherer"
+            c.realname = config[:realname].to_s != "" ? config[:realname] : "KAG Gatherer"
+            c.messages_per_second = 1
+            c.server_queue_size = 1
+            c.plugins.plugins = [Cinch::Commands::Help,KAG::Bot::Plugin,KAG::Gather::Plugin,KAG::Bans::Plugin,KAG::IRC::Plugin]
+            if config[:sasl]
+              c.sasl.username = config[:sasl][:username]
+              c.sasl.password = config[:sasl][:password]
+            end
+          end
+        end
+
+        bot.start
+      end
+
+      def config
+        KAG::Config.instance
+      end
+    end
+  end
+end

data/lib/kag/bot/plugin.rb

@@ -0,0 +1,56 @@
+require 'cinch'
+require 'kag/common'
+require 'commands/help'
+
+module KAG
+  module Bot
+    class Plugin
+      include Cinch::Plugin
+      include Cinch::Commands
+      include KAG::Common
+
+      command :quit,{},
+        summary: "Quit the bot",
+        admin: true
+      def quit(m)
+        if is_admin(m.user)
+          m.bot.quit("Shutting down...")
+        end
+      end
+
+      command :restart,{},
+        summary: "Restart the bot",
+        admin: true
+      def restart(m)
+        if is_admin(m.user)
+          cmd = (KAG::Config.instance[:restart_method] or "nohup sh gather.sh &")
+          debug cmd
+          pid = spawn cmd
+          debug "Restarting bot, new process ID is #{pid.to_s} ..."
+          exit
+        end
+      end
+
+      command :is_an_admin,{nick: :string},
+        summary: "See if the specified user is an Admin"
+      def is_an_admin(m,nick)
+        u = User(nick)
+        if is_admin(u)
+          reply m,"Yes, #{nick} is an admin!"
+        else
+          reply m,"No, #{nick} is not an admin."
+        end
+      end
+
+      command :reload_config,{},
+        summary: "Reload the configuration file",
+        admin: true
+      def reload_config(m)
+        if is_admin(m.user)
+          KAG::Config.instance.reload
+          m.reply "Configuration reloaded."
+        end
+      end
+    end
+  end
+end

data/lib/kag/common.rb

@@ -0,0 +1,34 @@
+
+module KAG
+  module Common
+    include Cinch::Plugin
+
+    def reply(message,text,colorize = true)
+      text = Format(:grey,text) if colorize
+      message.reply text
+    end
+
+    def send_channels_msg(msg,colorize = true)
+      KAG::Config.instance[:channels].each do |c|
+        msg = Format(:grey,msg) if colorize
+        Channel(c).send(msg)
+      end
+    end
+
+    def is_banned?(user)
+      KAG::Bans::Report.is_banned?(user)
+    end
+
+    def debug(msg)
+      if KAG::Config.instance[:debug]
+        puts msg
+      end
+    end
+
+    def is_admin(user)
+      user.refresh
+      o = (KAG::Config.instance[:owners] or [])
+      o.include?(user.authname)
+    end
+  end
+end