cinch 0.3.5 → 1.0.0

data/lib/cinch/logger/formatted_logger.rb

@@ -0,0 +1,80 @@
+require "cinch/logger/logger"
+module Cinch
+  module Logger
+    # A formatted logger that will colorize individual parts of IRC
+    # messages.
+    class FormattedLogger < Cinch::Logger::Logger
+      COLORS = {
+        :reset => "\e[0m",
+        :bold => "\e[1m",
+        :red => "\e[31m",
+        :green => "\e[32m",
+        :yellow => "\e[33m",
+        :blue => "\e[34m",
+      }
+
+      # @param [IO] output An IO to log to.
+      def initialize(output = STDERR)
+        @output = output
+        @mutex = Mutex.new
+      end
+
+      # (see Logger::Logger#debug)
+      def debug(messages)
+        log(messages, :debug)
+      end
+
+      # (see Logger::Logger#log)
+      def log(messages, kind = :generic)
+        @mutex.synchronize do
+          messages = [messages].flatten.map {|s| s.chomp}
+          # message = message.to_s.chomp # don't want to tinker with the original string
+
+          messages.each do |message|
+            if kind == :debug
+              prefix = colorize("!! ", :yellow)
+              message = prefix + message
+            else
+              pre, msg = message.split(" :", 2)
+              pre_parts = pre.split(" ")
+
+              if kind == :incoming
+                prefix = colorize(">> ", :green)
+
+                if pre_parts.size == 1
+                  pre_parts[0] = colorize(pre_parts[0], :bold)
+                else
+                  pre_parts[0] = colorize(pre_parts[0], :blue)
+                  pre_parts[1] = colorize(pre_parts[1], :bold)
+                end
+
+              elsif kind == :outgoing
+                prefix = colorize("<< ", :red)
+                pre_parts[0] = colorize(pre_parts[0], :bold)
+              end
+
+              message = prefix + pre_parts.join(" ")
+              message << colorize(" :#{msg}", :yellow) if msg
+            end
+            @output.puts message.encode
+          end
+        end
+      end
+
+      # @api private
+      # @param [String] text text to colorize
+      # @param [Array<Symbol>] codes array of colors to apply
+      # @return [String] colorized string
+      def colorize(text, *codes)
+        COLORS.values_at(*codes).join + text + COLORS[:reset]
+      end
+
+      # (see Logger::Logger#log_exception)
+      def log_exception(e)
+        lines = ["#{e.backtrace.first}: #{e.message} (#{e.class})"]
+        lines.concat e.backtrace[1..-1].map {|s| "\t" + s}
+        debug(lines)
+      end
+    end
+  end
+end

data/lib/cinch/logger/logger.rb

@@ -0,0 +1,44 @@
+module Cinch
+  module Logger
+    # This is an abstract class describing the logger interface. All
+    # loggers should inherit from this class and provide all necessary
+    # methods.
+    #
+    # Note: You cannot initialize this class directly.
+    #
+    # @abstract
+    class Logger
+      def initialize(output)
+        raise
+      end
+
+      # This method can be used by plugins to log custom messages.
+      #
+      # @param [String] message The message to log
+      # @return [void]
+      def debug(message)
+        raise
+      end
+
+      # This method is used by {#debug} and {#log_exception} to log
+      # messages, and also by the IRC parser to log incoming and
+      # outgoing messages. You should not have to call this.
+      #
+      # @param [String] message The message to log
+      # @param [Symbol<:debug, :generic, :incoming, :outgoing>] kind
+      #   The kind of message to log
+      # @return [void]
+      def log(message, kind = :generic)
+        raise
+      end
+
+      # This method is used for logging messages.
+      #
+      # @param [Exception] e The exception to log
+      # @return [void]
+      def log_exception(e)
+        raise
+      end
+    end
+  end
+end

data/lib/cinch/logger/null_logger.rb

@@ -0,0 +1,18 @@
+require "cinch/logger/logger"
+module Cinch
+  module Logger
+    class NullLogger < Cinch::Logger::Logger
+      def initialize(output = nil)
+      end
+
+      def debug(message)
+      end
+
+      def log(message, kind = :generic)
+      end
+
+      def log_exception(e)
+      end
+    end
+  end
+end

data/lib/cinch/mask.rb

@@ -0,0 +1,46 @@
+module Cinch
+  class Mask
+    # @return [String]
+    attr_reader :nick
+    # @return [String]
+    attr_reader :user
+    # @return [String]
+    attr_reader :host
+    # @return [String]
+    attr_reader :mask
+    def initialize(mask)
+      @mask = mask
+      @nick, @user, @host = mask.match(/(.+)!(.+)@(.+)/)[1..-1]
+      @regexp = Regexp.new(Regexp.escape(mask).gsub("\\*", ".*"))
+    end
+
+    # @return [Boolean]
+    def match(user)
+      mask = "%s!%s@%s" % [nick, user, host]
+      return mask =~ @regexp
+
+      # TODO support CIDR (freenode)
+    end
+    alias_method :=~, :match
+
+    # @return [String]
+    def to_s
+      @mask.dup
+    end
+
+    # @param [Ban, Mask, User, String]
+    # @return [Mask]
+    def self.from(target)
+      case target
+      when User, Ban
+        target.mask
+      when String
+        Mask.new(target)
+      when Mask
+        target
+      else
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/cinch/message.rb

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  class Message
+    # @return [String]
+    attr_accessor :raw
+    # @return [String]
+    attr_accessor :prefix
+    # @return [String]
+    attr_accessor :command
+    # @return [Array<String>]
+    attr_accessor :params
+    attr_reader :events
+
+    def initialize(msg, bot)
+      @raw = msg
+      @bot = bot
+      @matches = {:ctcp => {}, :other => {}}
+      @events = []
+      parse if msg
+    end
+
+
+
+    # @return [Boolean] true if the message is an numeric reply (as
+    # opposed to a command)
+    def numeric_reply?
+      !!(@numeric_reply ||= @command.match(/^\d{3}$/))
+    end
+
+    # @api private
+    # @return [void]
+    def parse
+      match = @raw.match(/(^:(\S+) )?(\S+)(.*)/)
+      _, @prefix, @command, raw_params = match.captures
+
+      raw_params.strip!
+      if match = raw_params.match(/(?:^:| :)(.*)$/)
+        @params = match.pre_match.split(" ")
+        @params << match[1]
+      else
+        @params = raw_params.split(" ")
+      end
+    end
+
+    # @return [User] The user who sent this message
+    def user
+      return unless @prefix
+      nick = @prefix[/^(\S+)!/, 1]
+      user = @prefix[/^\S+!(\S+)@/, 1]
+      host = @prefix[/@(\S+)$/, 1]
+
+      return nil if nick.nil?
+      @user ||= User.find_ensured(user, nick, host, @bot)
+    end
+
+    # @return [String, nil]
+    def server
+      return unless @prefix
+      return if @prefix.match(/[@!]/)
+      @server ||= @prefix[/^(\S+)/, 1]
+    end
+
+    # @return [Boolean] true if the message describes an error
+    def error?
+      !!error
+    end
+
+    # @return [Number, nil] the numeric error code, if any
+    def error
+      @error ||= (command.to_i if numeric_reply? && command[/[45]\d\d/])
+    end
+
+    # @return [Boolean] true if this message was sent in a channel
+    def channel?
+      !!channel
+    end
+
+    # @return [Boolean] true if the message is an CTCP message
+    def ctcp?
+      params.last =~ /\001.+\001/
+    end
+
+    # @return [String, nil] the command part of an CTCP message
+    def ctcp_command
+      return unless ctcp?
+      ctcp_message.split(" ").first
+    end
+
+    # @return [Channel] The channel in which this message was sent
+    def channel
+      @channel ||= begin
+                     case command
+                     when "INVITE", RPL_CHANNELMODEIS.to_s, RPL_BANLIST.to_s
+                       Channel.find_ensured(params[1], @bot)
+                     when RPL_NAMEREPLY.to_s
+                       Channel.find_ensured(params[2], @bot)
+                     else
+                       if params.first.start_with?("#")
+                         Channel.find_ensured(params.first, @bot)
+                       elsif numeric_reply? and params[1].start_with?("#")
+                         Channel.find_ensured(params[1], @bot)
+                       end
+                     end
+                   end
+    end
+
+    # @api private
+    # @return [MatchData]
+    def match(regexp, type)
+      if type == :ctcp
+        @matches[:ctcp][regexp] ||= ctcp_message.match(regexp)
+      else
+        @matches[:other][regexp] ||= message.to_s.match(regexp)
+      end
+    end
+
+    # @return [String, nil] the CTCP message, without \001 control characters
+    def ctcp_message
+      return unless ctcp?
+      params.last =~ /\001(.+)\001/
+      $1
+    end
+
+    def ctcp_args
+      return unless ctcp?
+      ctcp_message.split(" ")[1..-1]
+    end
+
+    # @return [String, nil]
+    def message
+      @message ||= begin
+                     if error?
+                       error.to_s
+                     elsif regular_command?
+                       params.last
+                     end
+                   end
+    end
+
+    # Replies to a message, automatically determining if it was a
+    # channel or a private message.
+    #
+    # @param [String] text the message
+    # @param [Boolean] prefix if prefix is true and the message was in
+    # a channel, the reply will be prefixed by the nickname of whoever
+    # send the mesage
+    # @return [void]
+    def reply(text, prefix = false)
+      text = text.to_s
+      if channel && prefix
+        text = text.split("\n").map {|l| "#{user.nick}: #{l}"}.join("\n")
+      end
+
+      (channel || user).send(text)
+    end
+
+    # Like #reply, but using {Channel#safe_send}/{User#safe_send}
+    # instead
+    #
+    # @param (see #reply)
+    # @return (see #reply)
+    def safe_reply(text, prefix = false)
+      text = text.to_s
+      if channel && prefix
+        text = "#{user.nick}: #{text}"
+      end
+      (channel || user).safe_send(text)
+    end
+
+    # Reply to a CTCP message
+    #
+    # @return [void]
+    def ctcp_reply(answer)
+      return unless ctcp?
+      @bot.raw "NOTICE #{user.nick} :\001#{ctcp_command} #{answer}\001"
+    end
+
+    private
+    def regular_command?
+      !numeric_reply? # a command can only be numeric or "regular"…
+    end
+  end
+end

data/lib/cinch/message_queue.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+require "thread"
+
+module Cinch
+  # @api private
+  class MessageQueue
+    def initialize(socket, bot)
+      @socket               = socket
+      @queue                = Queue.new
+      @time_since_last_send = nil
+      @bot                  = bot
+
+      @log = []
+    end
+
+    # @return [void]
+    def queue(message)
+      command = message.split(" ").first
+
+      if command == "PONG"
+        @queue.unshift(message)
+      else
+        @queue << message
+      end
+    end
+
+    # @return [void]
+    def process!
+      while true
+        mps            = @bot.config.messages_per_second
+        max_queue_size = @bot.config.server_queue_size
+
+        if @log.size > 1
+          time_passed = 0
+
+          @log.each_with_index do |one, index|
+            second = @log[index+1]
+            time_passed += second - one
+            break if index == @log.size - 2
+          end
+
+          messages_processed = (time_passed * mps).floor
+          effective_size = @log.size - messages_processed
+
+          if effective_size <= 0
+            @log.clear
+          elsif effective_size >= max_queue_size
+            sleep 1.0/mps
+          end
+        end
+
+        message = @queue.pop.to_s.chomp
+
+        @log << Time.now
+        @bot.logger.log(message, :outgoing) if @bot.config.verbose
+
+        @time_since_last_send = Time.now
+        @socket.print message + "\r\n"
+      end
+    end
+  end
+end

data/lib/cinch/plugin.rb

@@ -0,0 +1,205 @@
+module Cinch
+  module Plugin
+    include Helpers
+
+    module ClassMethods
+      Pattern = Struct.new(:pattern, :use_prefix, :method)
+      Listener = Struct.new(:event, :method)
+
+      # Set a match pattern.
+      #
+      # @param [Regexp, String] pattern A pattern
+      # @option options [Symbol] :method (:execute) The method to execute
+      # @option options [Boolean] :use_prefix (true) If true, the
+      #   plugin prefix will automatically be prepended to the
+      #   pattern.
+      # @return [void]
+      def match(pattern, options = {})
+        options = {:use_prefix => true, :method => :execute}.merge(options)
+        @__cinch_patterns ||= []
+        @__cinch_patterns << Pattern.new(pattern, options[:use_prefix], options[:method])
+      end
+
+      # Events to listen to.
+      # @overload listen_to(*types, options = {})
+      #   @param [String, Symbol, Integer] *types Events to listen to. Available
+      #     events are all IRC commands in lowercase as symbols, all numeric
+      #     replies, and the following:
+      #
+      #       - :channel (a channel message)
+      #       - :private (a private message)
+      #       - :message (both channel and private messages)
+      #       - :error   (IRC errors)
+      #       - :ctcp    (ctcp requests)
+      #
+      #   @param [Hash] options
+      #   @option options [Symbol] :method (:listen) The method to
+      #     execute
+      #   @return [void]
+      def listen_to(*types)
+        options = {:method => :listen}
+        if types.last.is_a?(Hash)
+          options.merge!(types.pop)
+        end
+
+        @__cinch_listeners ||= []
+
+        types.each do |type|
+          @__cinch_listeners << Listener.new(type, options[:method])
+        end
+      end
+
+      def ctcp(command)
+        (@__cinch_ctcps ||= []) << command.to_s.upcase
+      end
+
+      # Define a help message which will be returned on "<prefix>help
+      # <pluginname>".
+      #
+      # @param [String] message
+      # @return [void]
+      def help(message)
+        @__cinch_help_message = message
+      end
+
+      # Set the plugin prefix.
+      #
+      # @param [String] prefix
+      # @return [void]
+      def prefix(prefix)
+        @__cinch_prefix = prefix
+      end
+
+      # Set which kind of messages to react on (i.e. call {#execute})
+      #
+      # @param [Symbol<:message, :channel, :private>] target React to all,
+      #   only public or only private messages?
+      # @return [void]
+      def react_on(target)
+        @__cinch_react_on = target
+      end
+
+      # Define the plugin name.
+      #
+      # @param [String] name
+      # @return [void]
+      def plugin(name)
+        @__cinch_name = name
+      end
+
+      # @return [String]
+      # @api private
+      def __plugin_name
+        @__cinch_name || self.name.split("::").last.downcase
+      end
+
+      # @return [void]
+      # @api private
+      def __register_with_bot(bot, instance)
+        plugin_name = __plugin_name
+
+        (@__cinch_listeners || []).each do |listener|
+          bot.debug "[plugin] #{plugin_name}: Registering listener for type `#{listener.event}`"
+          bot.on(listener.event, [], instance) do |message, plugin|
+            plugin.__send__(listener.method, message) if plugin.respond_to?(listener.method)
+          end
+        end
+
+        if (@__cinch_patterns ||= []).empty?
+          @__cinch_patterns << Pattern.new(plugin_name, true, nil)
+        end
+
+        prefix = @__cinch_prefix || bot.config.plugins.prefix
+        if prefix.is_a?(String)
+          prefix = Regexp.escape(prefix)
+        end
+        @__cinch_patterns.each do |pattern|
+          if pattern.use_prefix && prefix
+            case pattern.pattern
+            when Regexp
+              pattern.pattern = /^#{prefix}#{pattern.pattern}/
+            when String
+              pattern.pattern = prefix + pattern.pattern
+            end
+          end
+
+          react_on = @__cinch_react_on || :message
+
+          bot.debug "[plugin] #{plugin_name}: Registering executor with pattern `#{pattern.pattern}`, reacting on `#{react_on}`"
+
+          bot.on(react_on, pattern.pattern, instance, pattern) do |message, plugin, pattern, *args|
+            if plugin.respond_to?(pattern.method)
+              method = plugin.method(pattern.method)
+              arity = method.arity - 1
+              if arity > 0
+                args = args[0..arity - 1]
+              elsif arity == 0
+                args = []
+              end
+              method.call(message, *args)
+            end
+          end
+        end
+
+        (@__cinch_ctcps || []).each do |ctcp|
+          bot.debug "[plugin] #{plugin_name}: Registering CTCP `#{ctcp}`"
+          bot.on(:ctcp, ctcp, instance, ctcp) do |message, plugin, ctcp, *args|
+            plugin.__send__("ctcp_#{ctcp.downcase}", message, *args)
+          end
+        end
+
+        if @__cinch_help_message
+          bot.debug "[plugin] #{plugin_name}: Registering help message"
+          bot.on(:message, /#{prefix}help #{Regexp.escape(plugin_name)}/, @__cinch_help_message) do |message, help_message|
+            message.reply(help_message)
+          end
+        end
+      end
+    end
+
+    # @return [Bot]
+    attr_reader :bot
+    # @api private
+    def initialize(bot)
+      @bot = bot
+      self.class.__register_with_bot(bot, self)
+    end
+
+    # @param (see Bot#synchronize)
+    # @yield
+    # @return (see Bot#synchronize)
+    # @see Bot#synchronize
+    def synchronize(*args, &block)
+      @bot.synchronize(*args, &block)
+    end
+
+    # This method will be executed whenever an event the plugin
+    # {Plugin::ClassMethods#listen_to listens to} occurs.
+    #
+    # @abstract
+    # @return [void]
+    # @see Plugin::ClassMethods#listen_to
+    def listen(*args)
+    end
+
+    # This method will be executed whenever a message matches the
+    # {Plugin::ClassMethods#match match pattern} of the plugin.
+    #
+    # @abstract
+    # @return [void]
+    # @see Plugin::ClassMethods#match
+    def execute(*args)
+    end
+
+    # Provides access to plugin-specific options.
+    #
+    # @return [Hash] A hash of options
+    def config
+      @bot.config.plugins.options[self.class]
+    end
+
+    def self.included(by)
+      by.extend ClassMethods
+    end
+  end
+end