newton 0.0.1

data/lib/newton/irc.rb

@@ -0,0 +1,261 @@
+module Newton
+  class IRC
+    # @return [ISupport]
+    attr_reader :isupport
+    def initialize(bot, config)
+      @bot, @config = bot, config
+      @isupport = ISupport.new
+    end
+
+    # Establish a connection.
+    #
+    # @return [void]
+    def connect
+      @registration = []
+
+      @whois_updates = Hash.new {|h, k| h[k] = {}}
+      @in_lists      = Set.new
+
+      tcp_socket = TCPSocket.open(@config.server, @config.port)
+
+      if @config.ssl
+        require 'openssl'
+
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        FormattedLogger.debug "Using SSL with #{@config.server}:#{@config.port}"
+
+        @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+        @socket.sync = true
+        @socket.connect
+      else
+        @socket = tcp_socket
+      end
+
+      @queue = MessageQueue.new(@socket, @bot)
+      message "PASS #{@config.password}" if @config.password
+      message "NICK #{@config.nick}"
+      message "USER #{@config.nick} 0 * :#{@config.realname}"
+
+      Thread.new do
+        while line = @socket.gets
+          parse line
+        end
+
+        @bot.dispatch(:disconnect)
+      end
+
+      @queue.process!
+    end
+
+    # @api private
+    # @return [void]
+    def parse(input)
+      FormattedLogger.log(input, :incoming) if @bot.config.verbose
+      msg          = Message.new(input, @bot)
+      events       = []
+      dispatch_msg = nil
+
+      if msg.command == ERR_NICKNAMEINUSE.to_s
+        @bot.nick = msg.params[1] + "_"
+      end
+
+      if ("001".."004").include? msg.command
+        @registration << msg.command
+        if registered?
+          events << :connect
+        end
+      elsif msg.command == "PRIVMSG"
+        events.concat(if msg.ctcp?
+                        [:ctcp]
+                      elsif msg.channel?
+                        [:message, :channel]
+                      else
+                        [:message, :private]
+                      end)
+
+        dispatch_msg = msg
+      elsif msg.command == "PING"
+        events << :ping
+        message "PONG :#{msg.params.first}"
+      else
+        if msg.command == "005"
+          require 'pp'
+          @isupport.parse(*msg.params[1..-2].map {|v| v.split(" ")}.flatten)
+        elsif [RPL_TOPIC.to_s, RPL_NOTOPIC.to_s, "TOPIC"].include?(msg.command)
+          topic = case msg.command
+                  when RPL_TOPIC.to_s
+                    msg.params[2]
+                  when "TOPIC"
+                    msg.params[1]
+                  else
+                    ""
+                  end
+          msg.channel.sync(:topic, topic)
+        elsif msg.command == "JOIN"
+          if msg.user == @bot
+            msg.channel.sync_modes
+          end
+          msg.channel.add_user(msg.user)
+        elsif msg.command == "PART"
+          msg.channel.remove_user(msg.user)
+        elsif msg.command == "KICK"
+          msg.channel.remove_user(User.find_ensured(msg.params[1], @bot))
+        elsif msg.command == "KILL"
+          user = User.find_ensured(msg.params[1], @bot)
+          Channel.all.each do |channel|
+            channel.remove_user(user)
+          end
+        elsif msg.command == "QUIT"
+          Channel.all.each do |channel|
+            channel.remove_user(msg.user)
+          end
+          msg.user.synced = false
+        elsif msg.command == "NICK"
+          if msg.user == @bot
+            @bot.config.nick = msg.params.last
+          end
+
+          msg.user.nick = msg.params.last
+        elsif msg.command == "MODE"
+          msg.channel.sync_modes if msg.channel?
+        elsif msg.command == RPL_CHANNELMODEIS.to_s
+          modes = {}
+          arguments = msg.params[3..-1]
+          msg.params[2][1..-1].split("").each do |mode|
+            if (@isupport["CHANMODES"]["B"] + @isupport["CHANMODES"]["C"]).include?(mode)
+              modes[mode] = arguments.shift
+            else
+              modes[mode] = true
+            end
+          end
+
+          msg.channel.sync(:modes, modes, false)
+        elsif msg.command == RPL_NAMEREPLY.to_s
+          unless @in_lists.include?(:names)
+            msg.channel.clear_users
+          end
+          @in_lists << :names
+
+          msg.params[3].split(" ").each do |user|
+            if @isupport["PREFIX"].values.include?(user[0..0])
+              prefix = user[0..0]
+              nick   = user[1..-1]
+            else
+              nick   = user
+              prefix = nil
+            end
+            user = User.find_ensured(nick, @bot)
+            msg.channel.add_user(user, prefix)
+          end
+
+        elsif msg.command == RPL_WHOISUSER.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          @whois_updates[user].merge!({
+                                        :user => msg.params[2],
+                                        :host => msg.params[3],
+                                        :realname => msg.params[5],
+                                      })
+        elsif msg.command == RPL_WHOISACCOUNT.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          authname = msg.params[2]
+          @whois_updates[user].merge!({:authname => authname})
+        elsif msg.command == RPL_WHOISCHANNELS.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          channels = msg.params[2].scan(/#{@isupport["CHANTYPES"].join}[^ ]+/o).map {|c| Channel.find_ensured(c, @bot) }
+          user.sync(:channels, channels, true)
+        elsif msg.command == RPL_WHOISIDLE.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          @whois_updates[user].merge!({
+                                        :idle => msg.params[2].to_i,
+                                        :signed_on_at => Time.at(msg.params[3].to_i),
+                                      })
+        elsif msg.command == "671"
+          user = User.find_ensured(msg.params[1], @bot)
+          @whois_updates[user].merge!({:secure? => true})
+        elsif msg.command == ERR_NOSUCHSERVER.to_s
+          if user = User.find(msg.params[1]) # not _ensured, we only want a user that already exists
+            user.sync(:unknown?, true, true)
+            @whois_updates.delete user
+            # TODO freenode specific, test on other IRCd
+          end
+        elsif msg.command == ERR_NOSUCHNICK.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          user.sync(:unknown?, true, true)
+        elsif msg.command == RPL_ENDOFWHOIS.to_s
+          user = User.find_ensured(msg.params[1], @bot)
+          if @whois_updates[user].empty? && !user.attr(:unknown?, true, true)
+            # for some reason, we did not receive user information. one
+            # reason is freenode throttling WHOIS
+            Thread.new do
+              sleep 2
+              user.whois
+            end
+          else
+            {
+              :authname => nil,
+              :idle => 0,
+              :secure? => false,
+            }.merge(@whois_updates[user]).each do |attr, value|
+              user.sync(attr, value, true)
+            end
+
+            user.sync(:unknown?, false, true)
+            user.synced = true
+            @whois_updates.delete user
+          end
+        elsif msg.command == RPL_ENDOFNAMES.to_s
+          @in_lists.delete :names
+          msg.channel.mark_as_synced(:users)
+        elsif msg.command == RPL_BANLIST.to_s
+          unless @in_lists.include?(:bans)
+            msg.channel.bans_unsynced.clear
+          end
+          @in_lists << :bans
+
+          mask = msg.params[2]
+          by   = User.find_ensured(msg.params[3].split("!").first, @bot)
+          at   = Time.at(msg.params[4].to_i)
+
+          ban = Ban.new(mask, by, at)
+          msg.channel.bans_unsynced << ban
+        elsif msg.command == RPL_ENDOFBANLIST.to_s
+          if @in_lists.include?(:bans)
+            @in_lists.delete :bans
+          else
+            # we never received a ban, yet an end of list => no bans
+            msg.channel.bans_unsynced.clear
+          end
+
+          msg.channel.mark_as_synced(:bans)
+        end
+
+        # TODO work with strings/constants, too
+
+        if msg.error?
+          events << :error
+        else
+          events << msg.command.downcase.to_sym
+        end
+
+        dispatch_msg = msg
+      end
+
+      events.each do |event|
+        @bot.dispatch(event, dispatch_msg)
+      end
+    end
+
+    # @return [Boolean] true if we successfully registered yet
+    def registered?
+      (("001".."004").to_a - @registration).empty?
+    end
+
+    # Send a message.
+    # @return [void]
+    def message(msg)
+      @queue.queue(msg)
+    end
+  end
+end

data/lib/newton/isupport.rb

@@ -0,0 +1,96 @@
+module Newton
+  class ISupport < Hash
+    @@mappings = {
+      %w[PREFIX] => lambda {|v|
+        modes, prefixes = v.match(/^\((.+)\)(.+)$/)[1..2]
+        h = {}
+        modes.split("").each_with_index do |c, i|
+          h[c] = prefixes[i]
+        end
+        h
+      },
+
+      %w[CHANTYPES] => lambda {|v| v.split("")},
+      %w[CHANMODES] => lambda {|v|
+        h = {}
+        h["A"], h["B"], h["C"], h["D"] = v.split(",").map {|l| l.split("")}
+        h
+      },
+
+      %w[MODES MAXCHANNELS NICKLEN MAXBANS TOPICLEN
+       KICKLEN CHANNELLEN CHIDLEN SILENCE AWAYLEN
+       MAXTARGETS WATCH] => lambda {|v| v.to_i},
+
+      %w[CHANLIMIT MAXLIST IDCHAN] => lambda {|v|
+        h = {}
+        v.split(",").each do |pair|
+          args, num = pair.split(":")
+          args.split("").each do |arg|
+            h[arg] = num.to_i
+          end
+        end
+        h
+      },
+
+      %w[TARGMAX] => lambda {|v|
+        h = {}
+        v.split(",").each do |pair|
+          name, value = pair.split(":")
+          h[name] = value.to_i
+        end
+        h
+      },
+
+      %w[NETWORK] => lambda {|v| v},
+      %w[STATUSMSG] => lambda {|v| v.split("")},
+      %w[CASEMAPPING] => lambda {|v| v.to_sym},
+      %w[ELIST] => lambda {|v| v.split("")},
+      # TODO STD
+    }
+
+    def initialize(*args)
+      super
+      # by setting most numeric values to "Infinity", we let the
+      # server truncate messages and lists while at the same time
+      # allowing the use of strictness=:strict for servers that don't
+      # support ISUPPORT (hopefully none, anyway)
+
+      self["PREFIX"]    =  {"o" => "@", "v" => "+"}
+      self["CHANTYPES"] =  ["#"]
+      self["CHANMODES"] =  {
+        "A"             => ["b"],
+        "B"             => ["k"],
+        "C"             => ["l"],
+        "D"             => %w[i m n p s t r]
+      }
+      self["MODES"]       = 1
+      self["NICKLEN"]     = Infinity
+      self["MAXBANS"]     = Infinity
+      self["TOPICLEN"]    = Infinity
+      self["KICKLEN"]     = Infinity
+      self["CHANNELLEN"]  = Infinity
+      self["CHIDLEN"]     = 5
+      self["AWAYLEN"]     = Infinity
+      self["MAXTARGETS"]  = 1
+      self["MAXCHANNELS"] = Infinity # deprecated
+      self["CHANLIMIT"]   = {"#" => Infinity}
+      self["STATUSMSG"]   = ["@", "+"]
+      self["CASEMAPPING"] = :rfc1459
+      self["ELIST"]       = []
+    end
+
+    # @api private
+    # @return [void]
+    def parse(*options)
+      options.each do |option|
+        name, value = option.split("=")
+        if value
+          proc = @@mappings.find {|key, value| key.include?(name)}
+          self[name] = (proc && proc[1].call(value)) || value
+        else
+          self[name] = true
+        end
+      end
+    end
+  end
+end

data/lib/newton/mask.rb

@@ -0,0 +1,46 @@
+module Newton
+  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/newton/message.rb

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+module Newton
+  class Message
+    # @return [String]
+    attr_accessor :raw
+    # @return [String]
+    attr_accessor :prefix
+    # @return [String]
+    attr_accessor :command
+    # @return [Array<String>]
+    attr_accessor :params
+
+
+    def initialize(msg, bot)
+      @raw = msg
+      @bot = bot
+      @matches = {:ctcp => {}, :other => {}}
+      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.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
+
+    # @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
+
+    # 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/newton/message_queue.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+require "thread"
+
+module Newton
+  # @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 == "PING"
+        @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
+        FormattedLogger.log(message, :outgoing) if @bot.config.verbose
+
+        @time_since_last_send = Time.now
+        @socket.print message + "\r\n"
+      end
+    end
+  end
+end

data/lib/newton/rubyext/infinity.rb

@@ -0,0 +1 @@
+Infinity = 1.0/0.0

data/lib/newton/rubyext/module.rb

@@ -0,0 +1,18 @@
+class Module
+  # @api private
+  def synced_attr_reader(attribute)
+    define_method(attribute) do
+      attr(attribute)
+    end
+
+    define_method("#{attribute}_unsynced") do
+      attr(attribute, false, true)
+    end
+  end
+
+  # @api private
+  def synced_attr_accessor(attr)
+    synced_attr_reader(attr)
+    attr_accessor(attr)
+  end
+end

data/lib/newton/rubyext/queue.rb

@@ -0,0 +1,19 @@
+require "thread"
+class Queue
+  def unshift(obj)
+    Thread.critical = true
+    @que.unshift obj
+    begin
+      t = @waiting.shift
+      t.wakeup if t
+    rescue ThreadError
+      retry
+    ensure
+      Thread.critical = false
+    end
+    begin
+      t.run if t
+    rescue ThreadError
+    end
+  end
+end

data/lib/newton/rubyext/string.rb

@@ -0,0 +1,24 @@
+class String
+  def irc_downcase(mapping)
+    case mapping
+    when :rfc1459
+      self.tr("A-Z[]\\^", "a-z{}|~")
+    when :"strict-rfc1459"
+      self.tr("A-Z[]\\", "a-z{}|")
+    else
+      # when :ascii or unknown/nil
+      self.tr("A-Z", "a-z")
+    end
+  end
+
+  def irc_upcase(mapping)
+    case mapping
+    when :ascii
+      self.tr("a-z", "A-Z")
+    when :rfc1459
+      self.tr("a-z{}|~", "A-Z[]\\^")
+    when :strict-rfc1459
+      self.tr("a-z{}|", "A-Z[]\\")
+    end
+  end
+end