cakewalk 3.0.0

data/lib/cakewalk/message.rb

@@ -0,0 +1,391 @@
+# -*- coding: utf-8 -*-
+require "time"
+require "cakewalk/formatting"
+
+module Cakewalk
+  # 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.
+  class Message
+    # @return [String]
+    attr_reader :raw
+
+    # @return [String]
+    attr_reader :prefix
+
+    # @return [String]
+    attr_reader :command
+
+    # @return [Array<String>]
+    attr_reader :params
+    
+    # @return [Hash]
+    attr_reader :tags
+
+    # @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
+
+    # @return [User] The user who sent this message
+    attr_reader :user
+
+    # @return [String, nil]
+    attr_reader :server
+
+    # @return [Integer, nil] the numeric error code, if any
+    attr_reader :error
+
+    # @return [String, nil] the command part of an CTCP message
+    attr_reader :ctcp_command
+
+    # @return [Channel] The channel in which this message was sent
+    attr_reader :channel
+
+    # @return [String, nil] the CTCP message, without \001 control characters
+    attr_reader :ctcp_message
+
+    # @return [Array<String>, nil]
+    attr_reader :ctcp_args
+
+    # @return [String, nil]
+    attr_reader :message
+
+    # @return [String, nil] The action message
+    # @since 2.0.0
+    attr_reader :action_message
+
+    # @return [Target]
+    attr_reader :target
+
+    # The STATUSMSG mode a channel message was sent to.
+    #
+    # Some IRC servers allow sending messages limited to people in a
+    # channel who have a certain mode. For example, by sending a
+    # message to `+#channel`, only people who are voiced, or have a
+    # higher mode (op) will receive the message.
+    #
+    # This attribute contains the mode character the message was sent
+    # to, or nil if it was a normal message. For the previous example,
+    # this attribute would be set to `"v"`, for voiced.
+    #
+    # @return [String, nil]
+    # @since 2.3.0
+    attr_reader :statusmsg_mode
+
+    def initialize(msg, bot)
+      @raw     = msg
+      @bot     = bot
+      @matches = {ctcp: {}, action: {}, other: {}}
+      @events  = []
+      @time    = Time.now
+      @statusmsg_mode = nil
+      parse if msg
+    end
+
+    # @api private
+    # @return [void]
+    def parse
+      match = @raw.match(/(?:^@([^:]+))?(?::?(\S+) )?(\S+)(.*)/)
+      if match.captures[3].empty?
+        # no IRCv3 tags 
+        @prefix, @command, raw_params = match.captures
+      else
+        tags, @prefix, @command, raw_params = match.captures
+      end
+
+      @params  = parse_params(raw_params)
+      @tags    = parse_tags(tags)
+
+      @user    = parse_user
+      @channel, @statusmsg_mode = parse_channel
+      @target  = @channel || @user
+      @server  = parse_server
+      @error   = parse_error
+      @message = parse_message
+
+      @ctcp_message = parse_ctcp_message
+      @ctcp_command = parse_ctcp_command
+      @ctcp_args    = parse_ctcp_args
+
+      @action_message = parse_action_message
+    end
+
+    # @group Type checking
+
+    # @return [Boolean] true if the message is an numeric reply (as
+    #   opposed to a command)
+    def numeric_reply?
+      !!@command.match(/^\d{3}$/)
+    end
+
+    # @return [Boolean] true if the message describes an error
+    def error?
+      !@error.nil?
+    end
+
+    # @return [Boolean] true if this message was sent in a channel
+    def channel?
+      !@channel.nil?
+    end
+
+    # @return [Boolean] true if the message is an CTCP message
+    def ctcp?
+      !!(@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
+
+    # @api private
+    # @return [MatchData]
+    def match(regexp, type, strip_colors)
+      text = ""
+      case type
+      when :ctcp
+        text = ctcp_message
+      when :action
+        text = action_message
+      else
+        text = message.to_s
+        type = :other
+      end
+
+      if strip_colors
+        text = Cakewalk::Formatting.unformat(text)
+      end
+
+      @matches[type][regexp] ||= text.match(regexp)
+    end
+
+    # @group Replying
+
+    # Replies to a message, automatically determining if it was a
+    # channel or a private message.
+    #
+    # If the message is a STATUSMSG, i.e. it was send to `+#channel`
+    # or `@#channel` instead of `#channel`, the reply will be sent as
+    # the same kind of STATUSMSG. See {#statusmsg_mode} for more
+    # information on STATUSMSG.
+    #
+    # @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
+
+      reply_target.send(text)
+    end
+
+    # Like {#reply}, but using {Target#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
+      reply_target.safe_send(text)
+    end
+
+    # Reply to a message with an action.
+    #
+    # For its behaviour with regard to STATUSMSG, see {#reply}.
+    #
+    # @param [String] text the action message
+    # @return [void]
+    def action_reply(text)
+      text = text.to_s
+      reply_target.action(text)
+    end
+
+    # Like {#action_reply}, but using {Target#safe_action} instead
+    #
+    # @param (see #action_reply)
+    # @return (see #action_reply)
+    def safe_action_reply(text)
+      text = text.to_s
+      reply_target.safe_action(text)
+    end
+
+    # Reply to a CTCP message
+    #
+    # @return [void]
+    def ctcp_reply(answer)
+      return unless ctcp?
+      @user.notice "\001#{@ctcp_command} #{answer}\001"
+    end
+
+    # @endgroup
+
+    # @return [String]
+    # @since 1.1.0
+    def to_s
+      "#<Cakewalk::Message @raw=#{@raw.chomp.inspect} @params=#{@params.inspect} channel=#{@channel.inspect} user=#{@user.inspect}>"
+    end
+
+    private
+    def reply_target
+      if @channel.nil? || @statusmsg_mode.nil?
+        return @target
+      end
+      prefix = @bot.irc.isupport["PREFIX"][@statusmsg_mode]
+      return Target.new(prefix + @channel.name, @bot)
+    end
+    def regular_command?
+      !numeric_reply? # a command can only be numeric or "regular"…
+    end
+
+    def parse_params(raw_params)
+      params     = []
+      if match = raw_params.match(/(?:^:| :)(.*)$/)
+        params = match.pre_match.split(" ")
+        params << match[1]
+      else
+        params = raw_params.split(" ")
+      end
+
+      return params
+    end
+    
+    def parse_tags(raw_tags)
+      return {} if raw_tags.nil?
+      
+      def to_symbol(string)
+        return string.gsub(/-/, "_").downcase.to_sym
+      end
+      
+      tags = {}
+      raw_tags.split(";").each do |tag|
+        tag_name, tag_value = tag.split("=")
+        if tag_value =~ /,/
+          tag_value = tag_value.split(',')
+        elsif tag_value.nil?
+          tag_value = tag_name
+        end
+        if tag_name =~ /\//
+          vendor, tag_name = tag_name.split('/')
+          tags[to_symbol(vendor)] = {
+            to_symbol(tag_name) => tag_value
+          }
+        else
+          tags[to_symbol(tag_name)] = tag_value
+        end
+      end
+      return tags
+    end
+
+    def parse_user
+      return unless @prefix
+      nick = @prefix[/^(\S+)!/, 1]
+      user = @prefix[/^\S+!(\S+)@/, 1]
+      host = @prefix[/@(\S+)$/, 1]
+
+      return nil if nick.nil?
+      return @bot.user_list.find_ensured(user, nick, host)
+    end
+
+    def parse_channel
+      # has to be called after parse_params
+      return nil if @params.empty?
+
+      case @command
+      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
+        # Note that this will also find channels for messages that
+        # don't actually include a channel parameter. For example
+        # `QUIT :#sometext` will be interpreted as a channel. The
+        # alternative to the currently used heuristic would be to
+        # hardcode a list of commands that provide a channel argument.
+        ch, status = privmsg_channel_name(@params.first)
+        if ch.nil? && numeric_reply? && @params.size > 1
+          ch, status = privmsg_channel_name(@params[1])
+        end
+        if ch
+          return @bot.channel_list.find_ensured(ch), status
+        end
+      end
+    end
+
+    def privmsg_channel_name(s)
+      chantypes = @bot.irc.isupport["CHANTYPES"]
+      statusmsg = @bot.irc.isupport["STATUSMSG"]
+      if statusmsg.include?(s[0]) && chantypes.include?(s[1])
+        status = @bot.irc.isupport["PREFIX"].invert[s[0]]
+        return s[1..-1], status
+      elsif chantypes.include?(s[0])
+        return s, nil
+      end
+    end
+
+    def parse_server
+      return unless @prefix
+      return if @prefix.match(/[@!]/)
+      return @prefix[/^(\S+)/, 1]
+    end
+
+    def parse_error
+      return @command.to_i if numeric_reply? && @command[/[45]\d\d/]
+    end
+
+    def parse_message
+      # has to be called after parse_params
+      if error?
+        @error.to_s
+      elsif regular_command?
+        @params.last
+      end
+    end
+
+    def parse_ctcp_message
+      # has to be called after parse_params
+      return unless ctcp?
+      @params.last =~ /\001(.+)\001/
+      $1
+    end
+
+    def parse_ctcp_command
+      # has to be called after parse_ctcp_message
+      return unless ctcp?
+      @ctcp_message.split(" ").first
+    end
+
+    def parse_ctcp_args
+      # has to be called after parse_ctcp_message
+      return unless ctcp?
+      @ctcp_message.split(" ")[1..-1]
+    end
+
+    def parse_action_message
+      # has to be called after parse_ctcp_message
+      return nil unless action?
+      @ctcp_message.split(" ", 2).last
+    end
+
+  end
+end

data/lib/cakewalk/message_queue.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+require "cakewalk/open_ended_queue"
+
+module Cakewalk
+  # This class manages all outgoing messages, applying rate throttling
+  # and fair distribution.
+  #
+  # @api private
+  class MessageQueue
+    def initialize(socket, bot)
+      @socket = socket
+      @bot    = bot
+
+      @queues            = {:generic => OpenEndedQueue.new}
+      @queues_to_process = Queue.new
+      @queued_queues     = Set.new
+
+      @mutex = Mutex.new
+
+      @time_since_last_send = nil
+
+      @log = []
+    end
+
+    # @return [void]
+    def queue(message)
+      command, target, _ = message.split(" ", 3)
+
+      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[target] ||= OpenEndedQueue.new
+        end
+      else
+        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!
+      loop do
+        wait
+        process_one
+      end
+    end
+
+    private
+    def wait
+      if @log.size > 1
+        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
+
+        time_passed = @log.last - @log.first
+
+        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
+
+    def process_one
+      queue = @queues_to_process.pop
+      message = queue.pop.to_s.each_line.first.chomp
+
+      if queue.empty?
+        @mutex.synchronize do
+          @queued_queues.delete(queue)
+        end
+      else
+        @queues_to_process << queue
+      end
+
+      begin
+        to_send = Cakewalk::Utilities::Encoding.encode_outgoing(message, @bot.config.encoding)
+        @socket.write(to_send + "\r\n")
+        @log << Time.now
+        @bot.loggers.outgoing(message)
+
+        @time_since_last_send = Time.now
+      rescue IOError
+        @bot.loggers.error "Could not send message (connectivity problems): #{message}"
+      end
+    end
+
+  end # class MessageQueue
+end

data/lib/cakewalk/mode_parser.rb

@@ -0,0 +1,76 @@
+require "cakewalk/exceptions"
+
+module Cakewalk
+  # @api private
+  # @since 1.1.0
+  module ModeParser
+    ErrEmptyString = "Empty mode string"
+    MalformedError = Struct.new(:modes)
+    EmptySequenceError = Struct.new(:modes)
+    NotEnoughParametersError = Struct.new(:op)
+    TooManyParametersError = Struct.new(:modes, :params)
+
+    # @param [String] modes The mode string as sent by the server
+    # @param [Array<String>] params Parameters belonging to the modes
+    # @param [Hash{:add, :remove => Array<String>}] param_modes
+    #   A mapping describing which modes require parameters
+    # @return [(Array<(Symbol<:add, :remove>, String<char>, String<param>), foo)]
+    def self.parse_modes(modes, params, param_modes = {})
+      if modes.size == 0
+        return nil, ErrEmptyString
+        # raise Exceptions::InvalidModeString, 'Empty mode string'
+      end
+
+      if modes[0] !~ /[+-]/
+        return nil, MalformedError.new(modes)
+        # raise Exceptions::InvalidModeString, "Malformed modes string: %s" % modes
+      end
+
+      changes = []
+
+      direction = nil
+      count = -1
+
+      modes.each_char do |ch|
+        if ch =~ /[+-]/
+          if count == 0
+            return changes, EmptySequenceError.new(modes)
+            # raise Exceptions::InvalidModeString, 'Empty mode sequence: %s' % modes
+          end
+
+          direction = case ch
+                      when "+"
+                        :add
+                      when "-"
+                        :remove
+                      end
+          count = 0
+        else
+          param = nil
+          if param_modes.has_key?(direction) && param_modes[direction].include?(ch)
+            if params.size > 0
+              param = params.shift
+            else
+              return changes, NotEnoughParametersError.new(ch)
+              # raise Exceptions::InvalidModeString, 'Not enough parameters: %s' % ch.inspect
+            end
+          end
+          changes << [direction, ch, param]
+          count += 1
+        end
+      end
+
+      if params.size > 0
+        return changes, TooManyParametersError.new(modes, params)
+        # raise Exceptions::InvalidModeString, 'Too many parameters: %s %s' % [modes, params]
+      end
+
+      if count == 0
+        return changes, EmptySequenceError.new(modes)
+        # raise Exceptions::InvalidModeString, 'Empty mode sequence: %s' % modes
+      end
+
+      return changes, nil
+    end
+  end
+end

data/lib/cakewalk/network.rb

@@ -0,0 +1,89 @@
+module Cakewalk
+  # This class allows querying the IRC network for its name and used
+  # server software as well as certain non-standard behaviour.
+  #
+  # @since 2.0.0
+  class Network
+    # @return [Symbol] The name of the network. `:unknown` if the
+    #   network couldn't be detected.
+    attr_reader :name
+
+    # @api private
+    attr_writer :name
+
+    # @return [Symbol] The server software used by the network.
+    #   `:unknown` if the software couldn't be detected.
+    attr_reader :ircd
+
+    # @api private
+    attr_writer :ircd
+
+    # @return [Array<Symbol>] All client capabilities supported by the
+    # network.
+    attr_reader :capabilities
+
+    # @api private
+    attr_writer :capabilities
+
+    # @param [Symbol] name
+    # @param [Symbol] ircd
+    # @api private
+    # @note The user should not create instances of this class but use
+    #   {IRC#network} instead.
+    def initialize(name, ircd)
+      @name         = name
+      @ircd         = ircd
+      @capabilities = []
+    end
+
+    # @return [String, nil] The mode used for getting the list of
+    #   channel owners, if any
+    def owner_list_mode
+      return "q" if @ircd == :unreal || @ircd == :inspircd
+    end
+
+    # @return [String, nil] The mode used for getting the list of
+    #   channel quiets, if any
+    def quiet_list_mode
+      return "q" if @ircd == :"ircd-seven"
+    end
+
+    # @return [Boolean] True if we do not know which network we are
+    #   connected to
+    def unknown_network?
+      @name == :unknown
+    end
+
+    # @return [Boolean] True if we do not know which software the
+    #   server is running
+    def unknown_ircd?
+      @ircd == :unknown
+    end
+
+    # Note for the default_* methods: Always make sure to return a
+    # value for when no network/ircd was detected so that MessageQueue
+    # doesn't break.
+
+    # @return [Numeric] The `messages per second` value that best suits
+    #   the current network
+    def default_messages_per_second
+      case @name
+      when :freenode
+        0.7
+      else
+        0.5
+      end
+    end
+
+    # @return [Integer] The `server queue size` value that best suits
+    #   the current network
+    def default_server_queue_size
+      case @name
+      when :quakenet
+        40
+      else
+        10
+      end
+    end
+  end
+end

data/lib/cakewalk/open_ended_queue.rb

@@ -0,0 +1,26 @@
+require "thread"
+
+# Like Ruby's Queue class, but allowing both pushing and unshifting
+# objects.
+#
+# @api private
+class OpenEndedQueue < Queue
+  # @param [Object] obj
+  # @return [void]
+  def unshift(obj)
+    t = nil
+    @mutex.synchronize{
+      @que.unshift obj
+      begin
+        t = @waiting.shift
+        t.wakeup if t
+      rescue ThreadError
+        retry
+      end
+    }
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+  end
+end