cinch 1.1.3 → 2.0.0.pre.1

data/lib/cinch/mask.rb

@@ -1,4 +1,5 @@
 module Cinch
+  # This class represents masks, which are primarily used for bans.
   class Mask
     # @return [String]
     attr_reader :nick
@@ -8,6 +9,9 @@ module Cinch
     attr_reader :host
     # @return [String]
     attr_reader :mask
+
+    # @version 1.1.2
+    # @param [String] mask
     def initialize(mask)
       @mask = mask
       @nick, @user, @host = mask.match(/(.+)!(.+)@(.+)/)[1..-1]
@@ -15,21 +19,25 @@ module Cinch
     end
 
     # @return [Boolean]
+    # @since 1.1.0
     def ==(other)
       other.respond_to?(:mask) && other.mask == @mask
     end
 
     # @return [Boolean]
+    # @since 1.1.0
     def eql?(other)
       other.is_a?(self.class) && self == other
     end
 
+    # @return [Fixnum]
     def hash
       @mask.hash
     end
 
-    # @param [Ban, Mask, User, String] target
+    # @param [Mask, String, #mask] target
     # @return [Boolean]
+    # @version 1.1.2
     def match(target)
       return self.class.from(target).mask =~ @regexp
 
@@ -42,19 +50,20 @@ module Cinch
       @mask.dup
     end
 
-    # @param [Ban, Mask, User, String]
+    # @param [String, #mask]
+    # @return [target] if already a Mask
     # @return [Mask]
+    # @version 2.0.0
     def self.from(target)
-      case target
-      when User, Ban
-        target.mask
-      when String
-        Mask.new(target)
-      when Mask
-        target
+      return target if target.is_a?(self)
+
+      if target.respond_to?(:mask)
+        mask = target.mask
       else
-        raise ArgumentError
+        mask = Mask.new(target.to_s)
       end
+
+      return mask
     end
   end
 end

data/lib/cinch/message.rb

@@ -1,39 +1,71 @@
 # -*- coding: utf-8 -*-
+require "time"
+
 module Cinch
+  # This class serves two purposes. For one, it simply
+  # represents incoming messages and allows for querying various
+  # details (who sent the message, what kind of message it is, etc).
+  #
+  # At the same time, it allows **responding** to messages, which
+  # means sending messages to either users or channels.
+  #
+  # @attr_reader user
+  # @attr_reader error
+  # @attr_reader message
+  # @attr_reader server
+  # @attr_reader target
+  # @attr_reader channel
+  # @attr_reader action_message
+  # @attr_reader ctcp_args
+  # @attr_reader ctcp_command
+  # @attr_reader ctcp_message
   class Message
     # @return [String]
     attr_accessor :raw
+
     # @return [String]
     attr_accessor :prefix
+
     # @return [String]
     attr_accessor :command
+
     # @return [Array<String>]
     attr_accessor :params
+
+    # @return [Array<Symbol>]
     attr_reader :events
+    # @api private
+    attr_writer :events
+
+    # @return [Time]
+    # @since 2.0.0
+    attr_reader :time
+
     # @return [Bot]
+    # @since 1.1.0
     attr_reader :bot
+
     def initialize(msg, bot)
       @raw = msg
       @bot = bot
-      @matches = {:ctcp => {}, :other => {}}
+      @matches = {:ctcp => {}, :action => {}, :other => {}}
       @events = []
+      @time = Time.now
       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
 
+      if @bot.irc.network.ngametv?
+        if @prefix != "ngame"
+          @prefix = "%s!user@host" % [@prefix, @prefix, @prefix]
+        end
+      end
+
       raw_params.strip!
       if match = raw_params.match(/(?:^:| :)(.*)$/)
         @params = match.pre_match.split(" ")
@@ -51,7 +83,7 @@ module Cinch
       host = @prefix[/@(\S+)$/, 1]
 
       return nil if nick.nil?
-      @user ||= @bot.user_manager.find_ensured(user, nick, host)
+      @user ||= @bot.user_list.find_ensured(user, nick, host)
     end
 
     # @return [String, nil]
@@ -61,16 +93,24 @@ module Cinch
       @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
 
+    # @group Type checking
+
+    # @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
+
+    # @return [Boolean] true if the message describes an error
+    def error?
+      !!error
+    end
+
     # @return [Boolean] true if this message was sent in a channel
     def channel?
       !!channel
@@ -78,7 +118,22 @@ module Cinch
 
     # @return [Boolean] true if the message is an CTCP message
     def ctcp?
-      params.last =~ /\001.+\001/
+      !!(params.last =~ /\001.+\001/)
+    end
+
+    # @return [Boolean] true if the message is an action (/me)
+    # @since 2.0.0
+    def action?
+      ctcp_command == "ACTION"
+    end
+
+    # @endgroup
+
+    # @return [String, nil] The action message
+    # @since 2.0.0
+    def action_message
+      return nil unless action?
+      ctcp_message.split(" ", 2).last
     end
 
     # @return [String, nil] the command part of an CTCP message
@@ -91,25 +146,32 @@ module Cinch
     def channel
       @channel ||= begin
                      case command
-                     when "INVITE", RPL_CHANNELMODEIS.to_s, RPL_BANLIST.to_s
-                       @bot.channel_manager.find_ensured(params[1])
-                     when RPL_NAMEREPLY.to_s
-                       @bot.channel_manager.find_ensured(params[2])
+                     when "INVITE", Constants::RPL_CHANNELMODEIS.to_s, Constants::RPL_BANLIST.to_s
+                       @bot.channel_list.find_ensured(params[1])
+                     when Constants::RPL_NAMEREPLY.to_s
+                       @bot.channel_list.find_ensured(params[2])
                      else
                        if params.first.start_with?("#")
-                         @bot.channel_manager.find_ensured(params.first)
+                         @bot.channel_list.find_ensured(params.first)
                        elsif numeric_reply? and params[1].start_with?("#")
-                         @bot.channel_manager.find_ensured(params[1])
+                         @bot.channel_list.find_ensured(params[1])
                        end
                      end
                    end
     end
 
+    # @return [Target]
+    def target
+      channel || user
+    end
+
     # @api private
     # @return [MatchData]
     def match(regexp, type)
       if type == :ctcp
         @matches[:ctcp][regexp] ||= ctcp_message.match(regexp)
+      elsif type == :action
+        @matches[:action][regexp] ||= action_message.match(regexp)
       else
         @matches[:other][regexp] ||= message.to_s.match(regexp)
       end
@@ -139,13 +201,15 @@ module Cinch
                    end
     end
 
+    # @group Replying
+
     # 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
+    #   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
@@ -153,11 +217,10 @@ module Cinch
         text = text.split("\n").map {|l| "#{user.nick}: #{l}"}.join("\n")
       end
 
-      (channel || user).send(text)
+      target.send(text)
     end
 
-    # Like #reply, but using {Channel#safe_send}/{User#safe_send}
-    # instead
+    # Like #reply, but using {Target#safe_send} instead
     #
     # @param (see #reply)
     # @return (see #reply)
@@ -166,7 +229,7 @@ module Cinch
       if channel && prefix
         text = "#{user.nick}: #{text}"
       end
-      (channel || user).safe_send(text)
+      target.safe_send(text)
     end
 
     # Reply to a CTCP message
@@ -177,7 +240,10 @@ module Cinch
       user.notice "\001#{ctcp_command} #{answer}\001"
     end
 
+    # @endgroup
+
     # @return [String]
+    # @since 1.1.0
     def to_s
       "#<Cinch::Message @raw=#{raw.chomp.inspect} @params=#{@params.inspect} channel=#{channel.inspect} user=#{user.inspect}>"
     end

data/lib/cinch/message_queue.rb

@@ -1,12 +1,20 @@
 # -*- coding: utf-8 -*-
-require "thread"
+require "cinch/open_ended_queue"
 
 module Cinch
+  # This class manages all outgoing messages, applying rate throttling
+  # and fair distribution.
+  #
   # @api private
   class MessageQueue
     def initialize(socket, bot)
       @socket               = socket
-      @queue                = Queue.new
+      @queues               = {:generic => OpenEndedQueue.new}
+
+      @queues_to_process    = Queue.new
+      @queued_queues        = Set.new
+
+      @mutex                = Mutex.new
       @time_since_last_send = nil
       @bot                  = bot
 
@@ -15,50 +23,84 @@ module Cinch
 
     # @return [void]
     def queue(message)
-      command = message.split(" ").first
+      command, *rest = message.split(" ")
 
-      if command == "PONG"
-        @queue.unshift(message)
+      queue = nil
+      case command
+      when "PRIVMSG", "NOTICE"
+        @mutex.synchronize do
+          # we are assuming that each message has only one target,
+          # which will be true as long as the user does not send raw
+          # messages.
+          #
+          # this assumption is also reflected in the computation of
+          # passed time and processed messages, since our score does
+          # not take weights into account.
+          queue = @queues[rest.first] ||= OpenEndedQueue.new
+        end
       else
-        @queue << message
+        queue = @queues[:generic]
+      end
+      queue << message
+
+      @mutex.synchronize do
+        unless @queued_queues.include?(queue)
+          @queued_queues << queue
+          @queues_to_process << queue
+        end
       end
     end
 
     # @return [void]
     def process!
       while true
-        mps            = @bot.config.messages_per_second
-        max_queue_size = @bot.config.server_queue_size
+        wait
 
-        if @log.size > 1
-          time_passed = 0
+        queue = @queues_to_process.pop
+        message = queue.pop.to_s.chomp
 
-          @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
+        if queue.empty?
+          @mutex.synchronize do
+            @queued_queues.delete(queue)
           end
+        else
+          @queues_to_process << queue
         end
 
-        message = @queue.pop.to_s.chomp
-
         begin
-          @socket.writeline Cinch.encode_outgoing(message, @bot.config.encoding) + "\r\n"
+          to_send = Cinch::Utilities::Encoding.encode_outgoing(message, @bot.config.encoding)
+          @socket.write to_send + "\r\n"
           @log << Time.now
-          @bot.logger.log(message, :outgoing) if @bot.config.verbose
+          @bot.loggers.outgoing(message)
 
           @time_since_last_send = Time.now
         rescue IOError
-          @bot.debug "Could not send message (connectivity problems): #{message}"
+          @bot.loggers.error "Could not send message (connectivity problems): #{message}"
+        end
+      end
+    end
+
+    private
+    def wait
+      mps            = @bot.config.messages_per_second || @bot.irc.network.default_messages_per_second
+      max_queue_size = @bot.config.server_queue_size   || @bot.irc.network.default_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
     end

data/lib/cinch/mode_parser.rb

@@ -1,6 +1,11 @@
 module Cinch
   # @api private
+  # @since 1.1.0
   module ModeParser
+    # @param [String] modes The mode string as sent by the server
+    # @param [Array<String>] params Parameters belonging to the modes
+    # @param [Hash<:add => Array<String>, :remove => Array<String>] param_modes
+    #   A mapping describing which modes require parameters
     def self.parse_modes(modes, params, param_modes = {})
       if modes.size == 0
         raise InvalidModeString, 'Empty mode string'
@@ -30,7 +35,7 @@ module Cinch
           count = 0
         else
           param = nil
-          if param_modes[direction].include?(ch)
+          if param_modes.has_key?(direction) && param_modes[direction].include?(ch)
             if params.size > 0
               param = params.shift
             else